From 4312f5883d5c903d928e0de581d3d425df9a8861 Mon Sep 17 00:00:00 2001 From: Konstantin Vyatkin Date: Tue, 4 Aug 2026 23:14:58 +0200 Subject: [PATCH 1/2] feat(codegen)!: centralize generated rule lifecycle Move generated parser dispatch, entry, recovery, retry, and exit scaffolding behind a doc-hidden runtime macro. Keep grammar-specific matches, rule calls, predictions, semantic actions, and attribute handling inline in each compact invocation while sharing ordinary and left-recursive lifecycle semantics. Bump the generated-code API to revision 6 because new recognizers require the lifecycle macro. Continue accepting revisions 1 through 5, update compatibility diagnostics and snapshots, and regenerate the ANTLRv4, Rust, and XPath recognizers. The ANTLRv4 parser drops from 13,509 to 11,298 lines and from 750,574 to 656,488 bytes. Cold and incremental package checks show no regression, the release generator binary is 18,720 bytes smaller, and Kotlin parse-only timing remains flat. --- README.md | 6 +- ...compact_left_recursive_rule_lifecycle.snap | 30 + ...ests__compact_ordinary_rule_lifecycle.snap | 27 + ...__tests__generated_module_file_header.snap | 2 +- .../antlr-rust-codegen/src/generator/tests.rs | 109 +- .../src/parser/render/rules.rs | 305 +- .../antlr-rust-codegen/src/parser/routing.rs | 76 +- .../tests/antlr4_rust_gen_cli/cli.rs | 4 +- .../tests/antlr4_rust_gen_cli/parser.rs | 8 +- ...li__cli__generated_codegen_api_checks.snap | 4 +- ...rated_codegen_api_mismatch_diagnostic.snap | 2 +- .../src/generated/antlr_v4_lexer.rs | 2 +- .../src/generated/antlr_v4_parser.rs | 9791 ++- .../src/generated/rust_lexer.rs | 2 +- .../src/generated/rust_parser.rs | 53695 +++++++--------- crates/antlr-rust-runtime/src/lib.rs | 5 +- crates/antlr-rust-runtime/src/parser.rs | 166 + .../src/xpath/generated/x_path_lexer.rs | 2 +- docs/migration.md | 6 +- .../antlr-v4-grammar/self-hosted.sha256 | 4 +- 20 files changed, 27488 insertions(+), 36758 deletions(-) create mode 100644 crates/antlr-rust-codegen/src/generator/snapshots/antlr_rust_codegen__generator__tests__compact_left_recursive_rule_lifecycle.snap create mode 100644 crates/antlr-rust-codegen/src/generator/snapshots/antlr_rust_codegen__generator__tests__compact_ordinary_rule_lifecycle.snap diff --git a/README.md b/README.md index bd9044fa..556bc1af 100644 --- a/README.md +++ b/README.md @@ -126,9 +126,9 @@ Using the same package release for `antlr4-rust-gen` and `antlr-rust-runtime` remains the recommended workflow, but matching the generated-code API is the compile-time requirement. -The bundled generator currently emits revision 5, which moves generated -recognizer facades and trait delegation behind runtime support macros. The -runtime also accepts revisions 1 through 4 because their older generated +The bundled generator currently emits revision 6, which moves generated parser +rule lifecycle and recovery scaffolding behind a runtime support macro. The +runtime also accepts revisions 1 through 5 because their older generated recognizers use API surfaces that remain available. Generated modules created before this check was introduced cannot be detected diff --git a/crates/antlr-rust-codegen/src/generator/snapshots/antlr_rust_codegen__generator__tests__compact_left_recursive_rule_lifecycle.snap b/crates/antlr-rust-codegen/src/generator/snapshots/antlr_rust_codegen__generator__tests__compact_left_recursive_rule_lifecycle.snap new file mode 100644 index 00000000..7368bf6d --- /dev/null +++ b/crates/antlr-rust-codegen/src/generator/snapshots/antlr_rust_codegen__generator__tests__compact_left_recursive_rule_lifecycle.snap @@ -0,0 +1,30 @@ +--- +source: crates/antlr-rust-codegen/src/generator/tests.rs +expression: rendered_generated_rule_methods(&rendered) +--- + #[allow(dead_code)] + fn parse_generated_rule_0_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 0, GeneratedRuleError::Fatal; self.parse_generated_rule_0_precedence(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_0(&mut self, allow_fallback: bool) -> Result { + self.parse_generated_rule_0_precedence(0, allow_fallback) + } + + #[allow(dead_code)] + fn parse_generated_rule_0_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 0isize, 0, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(1, 2, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} + } + } diff --git a/crates/antlr-rust-codegen/src/generator/snapshots/antlr_rust_codegen__generator__tests__compact_ordinary_rule_lifecycle.snap b/crates/antlr-rust-codegen/src/generator/snapshots/antlr_rust_codegen__generator__tests__compact_ordinary_rule_lifecycle.snap new file mode 100644 index 00000000..584008e4 --- /dev/null +++ b/crates/antlr-rust-codegen/src/generator/snapshots/antlr_rust_codegen__generator__tests__compact_ordinary_rule_lifecycle.snap @@ -0,0 +1,27 @@ +--- +source: crates/antlr-rust-codegen/src/generator/tests.rs +expression: rendered_generated_rule_methods(&rendered) +--- + #[allow(dead_code)] + fn parse_generated_rule_0_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 0, GeneratedRuleError::Fatal; self.parse_generated_rule_0(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_0(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 0isize, 0, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(1, 2, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} + } + } diff --git a/crates/antlr-rust-codegen/src/generator/snapshots/antlr_rust_codegen__generator__tests__generated_module_file_header.snap b/crates/antlr-rust-codegen/src/generator/snapshots/antlr_rust_codegen__generator__tests__generated_module_file_header.snap index ee209394..12493655 100644 --- a/crates/antlr-rust-codegen/src/generator/snapshots/antlr_rust_codegen__generator__tests__generated_module_file_header.snap +++ b/crates/antlr-rust-codegen/src/generator/snapshots/antlr_rust_codegen__generator__tests__generated_module_file_header.snap @@ -4,7 +4,7 @@ expression: "generated_module_header.replace(env!(\"CARGO_PKG_VERSION\"),\n\" - do not edit // project: https://github.com/ophi-dev/antlr-rust-runtime -antlr4_runtime::__antlr4_rust_require_codegen_api!(5, ""); +antlr4_runtime::__antlr4_rust_require_codegen_api!(6, ""); #[allow(warnings, missing_docs, clippy::all, clippy::pedantic, clippy::nursery)] #[rustfmt::skip] mod __antlr4_rust_generated { diff --git a/crates/antlr-rust-codegen/src/generator/tests.rs b/crates/antlr-rust-codegen/src/generator/tests.rs index 0bb0ac32..2edcac9a 100644 --- a/crates/antlr-rust-codegen/src/generator/tests.rs +++ b/crates/antlr-rust-codegen/src/generator/tests.rs @@ -39,6 +39,14 @@ fn rendered_facade_declaration<'a>(rendered: &'a str, macro_name: &str) -> &'a s tail[..end].trim_end() } +fn rendered_generated_rule_methods(rendered: &str) -> &str { + let marker = " #[allow(dead_code)]\n fn parse_generated_rule_0_dispatch"; + let start = rendered + .find(marker) + .unwrap_or_else(|| panic!("generated rule dispatch method")); + rendered[start..].trim_end() +} + #[test] fn renders_module_level_metadata_helpers() { let rendered = render_parser_metadata("TParser", &minimal_parser_data()); @@ -451,8 +459,44 @@ fn compiles_linear_parser_rule_body() { let rendered = render_generated_rule_dispatch(&[Some(body)], &[], &BTreeMap::new(), false); assert!(rendered.contains("match_token_recovering(1, 2, atn())")); - assert!(rendered.contains("generated_diagnostics_checkpoint()")); - assert!(rendered.contains("rollback_generated_tree(__generated_diagnostic_marker)")); + assert!(rendered.contains("antlr4_runtime::__antlr4_rust_generated_rule!")); + assert!(!rendered.contains("generated_diagnostics_checkpoint()")); + assert!(!rendered.contains("recover_generated_rule(")); +} + +#[test] +fn renders_compact_ordinary_rule_lifecycle() { + let rendered = render_generated_rule_dispatch( + &[Some(test_rule(0, vec![mt(1, 2)]))], + &[], + &BTreeMap::new(), + false, + ); + + insta::assert_snapshot!( + "compact_ordinary_rule_lifecycle", + rendered_generated_rule_methods(&rendered) + ); +} + +#[test] +fn renders_compact_left_recursive_rule_lifecycle() { + let rendered = render_generated_rule_dispatch( + &[Some(GeneratedParserRule { + rule_index: 0, + entry_state: 0, + left_recursive: true, + steps: vec![mt(1, 2)], + })], + &[], + &BTreeMap::new(), + false, + ); + + insta::assert_snapshot!( + "compact_left_recursive_rule_lifecycle", + rendered_generated_rule_methods(&rendered) + ); } #[test] @@ -979,7 +1023,9 @@ fn renders_adaptive_atn_preference_after_prediction_becomes_expensive() { assert!(rendered.contains( "self.base.number_of_syntax_errors() == self.adaptive_atn_syntax_error_starts[0]" )); - assert!(rendered.contains("return Err(GeneratedRuleError::AdaptiveRetry);")); + assert!(rendered.contains( + "retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];" + )); assert!(rendered.contains( "return self.parse_rule_precedence_from_generated(0, precedence).map_err(GeneratedRuleError::Interpreted);" )); @@ -1648,18 +1694,18 @@ fn embedded_init_action_runs_at_rule_entry() { ) .expect("embedded parser should render"); - let start_at = rendered - .find("let __rule_start") - .expect("generated rule captures rule start"); + let setup_at = rendered + .find("setup {") + .expect("generated rule declares setup section"); let init_at = rendered .find("println!(\"init\");") .expect("embedded @init body is emitted"); let body_at = rendered - .find("let mut __consumed_eof") + .find("body {") .expect("generated rule body follows entry setup"); assert!( - start_at < init_at && init_at < body_at, + setup_at < init_at && init_at < body_at, "embedded @init must run after rule entry setup and before the rule body" ); } @@ -2971,48 +3017,21 @@ fn generated_parser_renames_rule_wrapper_that_collides_with_token_stream_accesso } #[test] -fn generated_rule_recovers_own_sync_failure_unless_top_level() { +fn generated_rule_sync_policy_uses_shared_lifecycle_contract() { // A rule's own sync failure (`__sync_error`) is fatal only at the top-level // public entry (`allow_fallback`); a nested child recovers it locally and - // returns a partial subtree (so a parent never recovers the child's failure - // on the parent context, losing the child subtree). Assert the generated - // catch arm gates the `Fatal` return on `allow_fallback` and otherwise runs - // `recover_generated_rule` + `finish_rule` + `Ok`. + // returns a partial subtree. The runtime-owned lifecycle macro implements + // that policy; generated source only binds the sync-error slot used by + // grammar-specific decision steps. let rendered = render_parser("TParser", &minimal_parser_data()).expect("parser should render"); - let sync_arm = rendered - .find("if let Some(__error) = __sync_error {") - .expect("sync-error catch arm present"); - let rest = &rendered[sync_arm..]; - // Inside the sync arm, the Fatal return is guarded by `if allow_fallback`. - let guard = rest - .find("if allow_fallback {") - .expect("fatal return gated on allow_fallback"); - let fatal = rest - .find("return Err(GeneratedRuleError::Fatal(__error));") - .expect("fatal return present"); - assert!( - guard < fatal, - "Fatal return must be inside the allow_fallback guard" - ); - let count = rest - .find("self.base.record_generated_syntax_error();") - .expect("fatal sync path records syntax error"); - let rollback = rest - .find("self.base.rollback_generated_tree(__generated_diagnostic_marker);") - .expect("fatal sync path rolls back only partial tree state"); assert!( - guard < rollback && rollback < count && count < fatal, - "fatal sync path must preserve diagnostics, roll back the tree, and increment before returning" - ); - // And the nested-child path recovers locally and returns Ok. - let recover = rest - .find("self.base.recover_generated_rule(&mut __ctx, atn(), __error);") - .expect("local recovery present in sync arm"); - assert!( - recover > guard, - "recover path follows the guarded fatal return" + rendered.contains( + "ordinary self, 0isize, 0, allow_fallback, atn(), GeneratedRuleError::Fatal;" + ) ); - assert!(rest[recover..].contains("return Ok(__tree);")); + assert!(rendered.contains("bind (__ctx, __rule_start, __consumed_eof, __sync_error);")); + assert!(!rendered.contains("if let Some(__error) = __sync_error {")); + assert!(!rendered.contains("recover_generated_rule(&mut __ctx")); } #[test] diff --git a/crates/antlr-rust-codegen/src/parser/render/rules.rs b/crates/antlr-rust-codegen/src/parser/render/rules.rs index e9006206..cc51a06b 100644 --- a/crates/antlr-rust-codegen/src/parser/render/rules.rs +++ b/crates/antlr-rust-codegen/src/parser/render/rules.rs @@ -3,133 +3,37 @@ pub(crate) fn render_generated_rule_method( rule: &GeneratedParserRule, step_render_context: GeneratedStepRenderContext<'_>, ) { - if rule.left_recursive { - render_generated_left_recursive_rule_method(out, rule, step_render_context); - return; - } let index = rule.rule_index; - let entry_state = rule.entry_state; - writeln!( - out, - "\n #[allow(dead_code)]\n fn parse_generated_rule_{index}(&mut self, __precedence: i32, allow_fallback: bool) -> Result {{" - ) - .expect("writing to a string cannot fail"); - writeln!(out, " let _ = __precedence;").expect("writing to a string cannot fail"); - writeln!(out, " let _ = allow_fallback;").expect("writing to a string cannot fail"); - writeln!( - out, - " let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint();" - ) - .expect("writing to a string cannot fail"); - writeln!( - out, - " let mut __ctx = self.base.enter_rule({entry_state}isize, {index});" - ) - .expect("writing to a string cannot fail"); - // Capture the rule start AFTER `enter_rule`, which advances the cursor past any - // leading hidden-channel tokens to the first visible token. Capturing before - // would make `$start`/`$text` in generated actions include a leading hidden - // prefix (e.g. whitespace), diverging from ANTLR and the rule context start. - writeln!( - out, - " let __rule_start = antlr4_runtime::IntStream::index(self.base.input());" - ) - .expect("writing to a string cannot fail"); - render_portable_local_declarations(out, index, step_render_context); - render_embedded_attrs_local(out, index, step_render_context); - render_embedded_init_entry(out, index, step_render_context); - writeln!(out, " let mut __consumed_eof = false;") + if rule.left_recursive { + writeln!( + out, + "\n #[allow(dead_code)]\n fn parse_generated_rule_{index}(&mut self, allow_fallback: bool) -> Result {{" + ) .expect("writing to a string cannot fail"); - writeln!( - out, - " let mut __sync_error: Option = None;" - ) - .expect("writing to a string cannot fail"); - writeln!( - out, - " let __result = (|| -> Result<(), antlr4_runtime::AntlrError> {{" - ) - .expect("writing to a string cannot fail"); - render_generated_steps(out, &rule.steps, 3, step_render_context); - writeln!(out, " Ok(())").expect("writing to a string cannot fail"); - writeln!(out, " }})();").expect("writing to a string cannot fail"); - writeln!(out, " match __result {{").expect("writing to a string cannot fail"); - writeln!(out, " Ok(()) => {{").expect("writing to a string cannot fail"); - render_embedded_after_and_seal(out, index, step_render_context, true); - writeln!( - out, - " let __tree = self.base.finish_rule(__ctx, __consumed_eof);" - ) - .expect("writing to a string cannot fail"); - writeln!(out, " Ok(__tree)").expect("writing to a string cannot fail"); - writeln!(out, " }}").expect("writing to a string cannot fail"); - writeln!(out, " Err(__error) => {{").expect("writing to a string cannot fail"); - render_generated_adaptive_retry_unwind(out, step_render_context, false); - // A rule's own `sync_decision` failure (`__sync_error`) is fatal ONLY at the - // top-level public entry (`allow_fallback`). When this rule is a nested child - // (`!allow_fallback`), ANTLR recovers the mismatch INSIDE the child and returns - // a partial subtree to the parent — it never propagates the sync failure up. So - // for a nested child, recover locally like any other body error (a `Fatal` - // escaping here would make the parent recover on ITS context, dropping the - // child subtree). Only the true top-level keeps the `Fatal` abort (preserving - // antlr#6 `InvalidEmptyInput`-style start-rule errors). - writeln!( - out, - " if let Some(__error) = __sync_error {{" - ) - .expect("writing to a string cannot fail"); - writeln!(out, " if allow_fallback {{") + writeln!( + out, + " self.parse_generated_rule_{index}_precedence(0, allow_fallback)" + ) .expect("writing to a string cannot fail"); - writeln!(out, " self.base.exit_rule();") + writeln!(out, " }}").expect("writing to a string cannot fail"); + writeln!( + out, + "\n #[allow(dead_code)]\n fn parse_generated_rule_{index}_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result {{" + ) .expect("writing to a string cannot fail"); - writeln!( - out, - " self.base.rollback_generated_tree(__generated_diagnostic_marker);" - ) - .expect("writing to a string cannot fail"); - writeln!( - out, - " self.base.record_generated_syntax_error();" - ) - .expect("writing to a string cannot fail"); - writeln!( - out, - " return Err(GeneratedRuleError::Fatal(__error));" - ) - .expect("writing to a string cannot fail"); - writeln!(out, " }}").expect("writing to a string cannot fail"); - writeln!( - out, - " self.base.recover_generated_rule(&mut __ctx, atn(), __error);" - ) - .expect("writing to a string cannot fail"); - render_embedded_after_and_seal(out, index, step_render_context, false); - writeln!( - out, - " let __tree = self.base.finish_rule(__ctx, __consumed_eof);" - ) - .expect("writing to a string cannot fail"); - writeln!(out, " return Ok(__tree);") + } else { + writeln!( + out, + "\n #[allow(dead_code)]\n fn parse_generated_rule_{index}(&mut self, __precedence: i32, allow_fallback: bool) -> Result {{" + ) .expect("writing to a string cannot fail"); - writeln!(out, " }}").expect("writing to a string cannot fail"); - writeln!( - out, - " self.base.recover_generated_rule(&mut __ctx, atn(), __error);" - ) - .expect("writing to a string cannot fail"); - render_embedded_after_and_seal(out, index, step_render_context, false); - writeln!( - out, - " let __tree = self.base.finish_rule(__ctx, __consumed_eof);" - ) - .expect("writing to a string cannot fail"); - writeln!(out, " Ok(__tree)").expect("writing to a string cannot fail"); - writeln!(out, " }}").expect("writing to a string cannot fail"); - writeln!(out, " }}").expect("writing to a string cannot fail"); + writeln!(out, " let _ = __precedence;").expect("writing to a string cannot fail"); + } + render_generated_rule_lifecycle(out, rule, step_render_context); writeln!(out, " }}").expect("writing to a string cannot fail"); } -fn render_generated_left_recursive_rule_method( +fn render_generated_rule_lifecycle( out: &mut String, rule: &GeneratedParserRule, step_render_context: GeneratedStepRenderContext<'_>, @@ -138,132 +42,65 @@ fn render_generated_left_recursive_rule_method( let entry_state = rule.entry_state; writeln!( out, - "\n #[allow(dead_code)]\n fn parse_generated_rule_{index}(&mut self, allow_fallback: bool) -> Result {{" - ) - .expect("writing to a string cannot fail"); - writeln!( - out, - " self.parse_generated_rule_{index}_precedence(0, allow_fallback)" - ) - .expect("writing to a string cannot fail"); - writeln!(out, " }}").expect("writing to a string cannot fail"); - writeln!( - out, - "\n #[allow(dead_code)]\n fn parse_generated_rule_{index}_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result {{" - ) - .expect("writing to a string cannot fail"); - writeln!(out, " let _ = allow_fallback;").expect("writing to a string cannot fail"); - writeln!( - out, - " let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint();" - ) - .expect("writing to a string cannot fail"); - writeln!( - out, - " let mut __ctx = self.base.enter_recursion_rule({entry_state}isize, {index}, __precedence);" - ) - .expect("writing to a string cannot fail"); - // Capture the rule start AFTER `enter_recursion_rule`, which (via `enter_rule`) - // advances the cursor past any leading hidden-channel tokens to the first - // visible token. Capturing before would make `$start`/`$text` in generated - // actions include a leading hidden prefix, diverging from ANTLR. - writeln!( - out, - " let __rule_start = antlr4_runtime::IntStream::index(self.base.input());" + " antlr4_runtime::__antlr4_rust_generated_rule! {{" ) .expect("writing to a string cannot fail"); - render_portable_local_declarations(out, index, step_render_context); - render_embedded_attrs_local(out, index, step_render_context); - render_embedded_init_entry(out, index, step_render_context); - writeln!(out, " let mut __consumed_eof = false;") + if rule.left_recursive { + writeln!( + out, + " recursive self, {entry_state}isize, {index}, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal;" + ) .expect("writing to a string cannot fail"); - writeln!( - out, - " let mut __sync_error: Option = None;" - ) - .expect("writing to a string cannot fail"); - writeln!( - out, - " let __result = (|| -> Result<(), antlr4_runtime::AntlrError> {{" - ) - .expect("writing to a string cannot fail"); - render_generated_steps(out, &rule.steps, 3, step_render_context); - writeln!(out, " Ok(())").expect("writing to a string cannot fail"); - writeln!(out, " }})();").expect("writing to a string cannot fail"); - writeln!(out, " match __result {{").expect("writing to a string cannot fail"); - writeln!(out, " Ok(()) => {{").expect("writing to a string cannot fail"); - render_embedded_after_and_seal(out, index, step_render_context, true); - writeln!( - out, - " let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof);" - ) - .expect("writing to a string cannot fail"); - writeln!(out, " Ok(__tree)").expect("writing to a string cannot fail"); - writeln!(out, " }}").expect("writing to a string cannot fail"); - writeln!(out, " Err(__error) => {{").expect("writing to a string cannot fail"); - render_generated_adaptive_retry_unwind(out, step_render_context, true); - // Same as the non-left-recursive case: a nested child (`!allow_fallback`) - // recovers its own sync failure internally and returns a partial subtree; only - // the top-level entry propagates `Fatal`. Use `finish_recursion_rule` (which - // unrolls the recursion context) in the recover branch — do NOT also call - // `unroll_recursion_context` (that would double-unroll). - writeln!( - out, - " if let Some(__error) = __sync_error {{" - ) - .expect("writing to a string cannot fail"); - writeln!(out, " if allow_fallback {{") + } else { + writeln!( + out, + " ordinary self, {entry_state}isize, {index}, allow_fallback, atn(), GeneratedRuleError::Fatal;" + ) .expect("writing to a string cannot fail"); - writeln!( - out, - " self.base.unroll_recursion_context();" - ) - .expect("writing to a string cannot fail"); - writeln!( - out, - " self.base.rollback_generated_tree(__generated_diagnostic_marker);" - ) - .expect("writing to a string cannot fail"); - writeln!( - out, - " self.base.record_generated_syntax_error();" - ) - .expect("writing to a string cannot fail"); - writeln!( - out, - " return Err(GeneratedRuleError::Fatal(__error));" - ) - .expect("writing to a string cannot fail"); - writeln!(out, " }}").expect("writing to a string cannot fail"); - writeln!( - out, - " self.base.recover_generated_rule(&mut __ctx, atn(), __error);" - ) - .expect("writing to a string cannot fail"); - render_embedded_after_and_seal(out, index, step_render_context, false); - writeln!( - out, - " let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof);" - ) - .expect("writing to a string cannot fail"); - writeln!(out, " return Ok(__tree);") + } + if step_render_context + .adaptive_atn_preferred_rule_slots + .iter() + .any(Option::is_some) + { + writeln!( + out, + " retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];" + ) .expect("writing to a string cannot fail"); - writeln!(out, " }}").expect("writing to a string cannot fail"); - writeln!( - out, - " self.base.recover_generated_rule(&mut __ctx, atn(), __error);" - ) - .expect("writing to a string cannot fail"); - render_embedded_after_and_seal(out, index, step_render_context, false); + } else { + writeln!(out, " retry [none];").expect("writing to a string cannot fail"); + } writeln!( out, - " let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof);" + " bind (__ctx, __rule_start, __consumed_eof, __sync_error);" ) .expect("writing to a string cannot fail"); - writeln!(out, " Ok(__tree)").expect("writing to a string cannot fail"); + let mut setup = String::new(); + render_portable_local_declarations(&mut setup, index, step_render_context, 4); + render_embedded_attrs_local(&mut setup, index, step_render_context, 4); + render_embedded_init_entry(&mut setup, index, step_render_context, 4); + render_generated_rule_section(out, "setup", &setup); + writeln!(out, " body {{").expect("writing to a string cannot fail"); + render_generated_steps(out, &rule.steps, 4, step_render_context); writeln!(out, " }}").expect("writing to a string cannot fail"); + let mut success = String::new(); + render_embedded_after_and_seal(&mut success, index, step_render_context, true, 4); + render_generated_rule_section(out, "success", &success); + let mut recovery = String::new(); + render_embedded_after_and_seal(&mut recovery, index, step_render_context, false, 4); + render_generated_rule_section(out, "recovery", &recovery); writeln!(out, " }}").expect("writing to a string cannot fail"); - writeln!(out, " }}").expect("writing to a string cannot fail"); +} + +fn render_generated_rule_section(out: &mut String, name: &str, body: &str) { + if body.is_empty() { + writeln!(out, " {name} {{}}").expect("writing to a string cannot fail"); + return; + } + writeln!(out, " {name} {{").expect("writing to a string cannot fail"); + out.push_str(body); + writeln!(out, " }}").expect("writing to a string cannot fail"); } fn render_generated_steps( diff --git a/crates/antlr-rust-codegen/src/parser/routing.rs b/crates/antlr-rust-codegen/src/parser/routing.rs index e8d30ed9..a7c2d639 100644 --- a/crates/antlr-rust-codegen/src/parser/routing.rs +++ b/crates/antlr-rust-codegen/src/parser/routing.rs @@ -121,10 +121,7 @@ pub(crate) fn adaptive_atn_parser_render_slots( } } -pub(crate) fn render_generated_rule_error( - retry_variant: &str, - retry_into_error: &str, -) -> String { +pub(crate) fn render_generated_rule_error(retry_variant: &str, retry_into_error: &str) -> String { format!( r#"#[allow(dead_code)] #[derive(Debug)] @@ -352,30 +349,9 @@ pub(crate) fn render_routing_plan( writeln!(out, " let _ = precedence;").expect("writing to a string cannot fail"); format!("self.parse_generated_rule_{index}(precedence, allow_fallback)") }; - // Rule nesting maps onto native call depth; sample remaining stack - // capacity at the shared dispatch boundary so deeply nested input - // grows onto a segmented stack instead of aborting the process. The - // optional depth-cap and parse-listener probes stay inline-cheap - // (one `Option`/emptiness check each when unused) and their errors, - // while absorbed by rule-level recovery like any rule failure, stay - // sticky until the top-level entry drains them — that pairing is - // what actually enforces the abort. The matching listener exit event - // fires from the rule body's exit paths (`finish_rule`/recovery), so - // enter/exit stay balanced. Plain `if let` keeps generated output - // edition-2021 compatible. writeln!( out, - " if let Some(error) = self.base.rule_depth_cap_violation() {{\n \ - return Err(GeneratedRuleError::Fatal(error));\n \ - }}\n \ - if let Some(error) = self.base.parse_listener_enter_rule({index}) {{\n \ - return Err(GeneratedRuleError::Fatal(error));\n \ - }}\n \ - let __listener_result = if self.base.generated_rule_stack_check_due() {{\n \ - antlr4_runtime::grow_generated_rule_stack(|| {target_call})\n \ - }} else {{\n {target_call}\n }};\n \ - self.base.parse_listener_exit_rule({index});\n \ - __listener_result" + " antlr4_runtime::__antlr4_rust_generated_rule! {{ dispatch self, {index}, GeneratedRuleError::Fatal; {target_call} }}" ) .expect("writing to a string cannot fail"); writeln!(out, " }}").expect("writing to a string cannot fail"); @@ -428,6 +404,7 @@ pub(crate) fn render_portable_local_declarations( out: &mut String, rule_index: usize, step_render_context: GeneratedStepRenderContext<'_>, + indent: usize, ) { let Some(portable) = step_render_context.portable_locals else { return; @@ -435,8 +412,9 @@ pub(crate) fn render_portable_local_declarations( let Some(declarations) = portable.declarations.get(rule_index) else { return; }; + let pad = " ".repeat(indent); for declaration in declarations { - writeln!(out, " #[allow(unused_mut)]\n {declaration}") + writeln!(out, "{pad}#[allow(unused_mut)]\n{pad}{declaration}") .expect("writing to a string cannot fail"); } } @@ -446,6 +424,7 @@ pub(crate) fn render_embedded_attrs_local( out: &mut String, rule_index: usize, step_render_context: GeneratedStepRenderContext<'_>, + indent: usize, ) { let Some(embedded) = step_render_context.embedded else { return; @@ -458,10 +437,11 @@ pub(crate) fn render_embedded_attrs_local( { return; } + let pad = " ".repeat(indent); let attrs_struct = embedded::attrs_struct_name(rule_index); writeln!( out, - " #[allow(unused_mut)]\n let mut __attrs = {attrs_struct}::default();" + "{pad}#[allow(unused_mut)]\n{pad}let mut __attrs = {attrs_struct}::default();" ) .expect("writing to a string cannot fail"); if let Some(arg0) = embedded @@ -471,7 +451,7 @@ pub(crate) fn render_embedded_attrs_local( { writeln!( out, - " if let Some(__arg) = self.__embedded_pending_arg.take() {{ __attrs.{arg0} = __arg as _; }}" + "{pad}if let Some(__arg) = self.__embedded_pending_arg.take() {{ __attrs.{arg0} = __arg as _; }}" ) .expect("writing to a string cannot fail"); } @@ -483,12 +463,14 @@ pub(crate) fn render_embedded_init_entry( out: &mut String, rule_index: usize, step_render_context: GeneratedStepRenderContext<'_>, + indent: usize, ) { let Some(embedded) = step_render_context.embedded else { return; }; if let Some(init) = embedded.init_entry.get(&rule_index) { - writeln!(out, " {init}").expect("writing to a string cannot fail"); + let pad = " ".repeat(indent); + writeln!(out, "{pad}{init}").expect("writing to a string cannot fail"); } } @@ -499,13 +481,15 @@ pub(crate) fn render_embedded_after_and_seal( rule_index: usize, step_render_context: GeneratedStepRenderContext<'_>, run_after: bool, + indent: usize, ) { let Some(embedded) = step_render_context.embedded else { return; }; + let pad = " ".repeat(indent); if run_after { if let Some(after) = embedded.after.get(&rule_index) { - writeln!(out, " {after}").expect("writing to a string cannot fail"); + writeln!(out, "{pad}{after}").expect("writing to a string cannot fail"); } } if embedded @@ -516,36 +500,8 @@ pub(crate) fn render_embedded_after_and_seal( { writeln!( out, - " __ctx.set_generated_attrs(antlr4_runtime::GeneratedAttrs::new(__attrs.clone()));" + "{pad}__ctx.set_generated_attrs(antlr4_runtime::GeneratedAttrs::new(__attrs.clone()));" ) .expect("writing to a string cannot fail"); } } - -pub(crate) fn render_generated_adaptive_retry_unwind( - out: &mut String, - step_render_context: GeneratedStepRenderContext<'_>, - left_recursive: bool, -) { - if !step_render_context - .adaptive_atn_preferred_rule_slots - .iter() - .any(Option::is_some) - { - return; - } - let exit_rule = if left_recursive { - "self.base.unroll_recursion_context();" - } else { - "self.base.exit_rule();" - }; - writeln!( - out, - " if self.adaptive_atn_retry_slot.is_some() {{\n \ - {exit_rule}\n \ - self.base.restore_generated_diagnostics(__generated_diagnostic_marker);\n \ - return Err(GeneratedRuleError::AdaptiveRetry);\n \ - }}" - ) - .expect("writing to a string cannot fail"); -} diff --git a/crates/antlr-rust-codegen/tests/antlr4_rust_gen_cli/cli.rs b/crates/antlr-rust-codegen/tests/antlr4_rust_gen_cli/cli.rs index e32357d9..70503473 100644 --- a/crates/antlr-rust-codegen/tests/antlr4_rust_gen_cli/cli.rs +++ b/crates/antlr-rust-codegen/tests/antlr4_rust_gen_cli/cli.rs @@ -97,7 +97,7 @@ fn generated_modules_enforce_codegen_api_compatibility() { "__antlr4_rust_require_codegen_api!({},", antlr4_runtime::__ANTLR4_RUST_CODEGEN_API ); - for revision in [1, 2, 3, 4] { + for revision in [1, 2, 3, 4, 5] { let supported = format!("__antlr4_rust_require_codegen_api!({revision},"); let mut supported_parser = parser.clone(); let check_start = supported_parser @@ -129,7 +129,7 @@ fn generated_modules_enforce_codegen_api_compatibility() { .collect::>() .join("\n"); assert!( - diagnostic.contains("supports revisions 1, 2, 3, 4, and 5"), + diagnostic.contains("supports revisions 1, 2, 3, 4, 5, and 6"), "diagnostic should name every supported revision: {diagnostic}" ); insta::assert_snapshot!( diff --git a/crates/antlr-rust-codegen/tests/antlr4_rust_gen_cli/parser.rs b/crates/antlr-rust-codegen/tests/antlr4_rust_gen_cli/parser.rs index 8b2756a9..3f6379f7 100644 --- a/crates/antlr-rust-codegen/tests/antlr4_rust_gen_cli/parser.rs +++ b/crates/antlr-rust-codegen/tests/antlr4_rust_gen_cli/parser.rs @@ -154,12 +154,12 @@ fn deeply_nested_input_parses_without_native_stack_overflow() { utf8(&output.stderr) ); - // Every generated dispatch method must carry the stack guard; the rule - // chain here multiplies each `[` into ~6 native rule frames (issue #193). + // Every generated dispatch method must use the shared lifecycle contract; + // the 10,000-level parse below proves its segmented-stack guard is active. let parser = fs::read_to_string(out.join("nest_parser.rs")).expect("parser should be emitted"); assert!( - parser.contains("antlr4_runtime::grow_generated_rule_stack("), - "generated dispatch must guard native stack growth\n{parser}" + parser.contains("antlr4_runtime::__antlr4_rust_generated_rule!"), + "generated dispatch must use the shared rule lifecycle\n{parser}" ); assert_generated_project( diff --git a/crates/antlr-rust-codegen/tests/antlr4_rust_gen_cli/snapshots/antlr4_rust_gen_cli__cli__generated_codegen_api_checks.snap b/crates/antlr-rust-codegen/tests/antlr4_rust_gen_cli/snapshots/antlr4_rust_gen_cli__cli__generated_codegen_api_checks.snap index e8f71d1c..41ce0f3f 100644 --- a/crates/antlr-rust-codegen/tests/antlr4_rust_gen_cli/snapshots/antlr4_rust_gen_cli__cli__generated_codegen_api_checks.snap +++ b/crates/antlr-rust-codegen/tests/antlr4_rust_gen_cli/snapshots/antlr4_rust_gen_cli__cli__generated_codegen_api_checks.snap @@ -2,5 +2,5 @@ source: crates/antlr-rust-codegen/tests/antlr4_rust_gen_cli/cli.rs expression: normalize_current_package_version(&checks) --- -lexer: antlr4_runtime::__antlr4_rust_require_codegen_api!(5, ""); -parser: antlr4_runtime::__antlr4_rust_require_codegen_api!(5, ""); +lexer: antlr4_runtime::__antlr4_rust_require_codegen_api!(6, ""); +parser: antlr4_runtime::__antlr4_rust_require_codegen_api!(6, ""); diff --git a/crates/antlr-rust-codegen/tests/antlr4_rust_gen_cli/snapshots/antlr4_rust_gen_cli__cli__generated_codegen_api_mismatch_diagnostic.snap b/crates/antlr-rust-codegen/tests/antlr4_rust_gen_cli/snapshots/antlr4_rust_gen_cli__cli__generated_codegen_api_mismatch_diagnostic.snap index 5af33391..4e8cb2e5 100644 --- a/crates/antlr-rust-codegen/tests/antlr4_rust_gen_cli/snapshots/antlr4_rust_gen_cli__cli__generated_codegen_api_mismatch_diagnostic.snap +++ b/crates/antlr-rust-codegen/tests/antlr4_rust_gen_cli/snapshots/antlr4_rust_gen_cli__cli__generated_codegen_api_mismatch_diagnostic.snap @@ -2,5 +2,5 @@ source: crates/antlr-rust-codegen/tests/antlr4_rust_gen_cli/cli.rs expression: normalize_current_package_version(&diagnostic) --- -error: antlr4-rust generated-code API mismatch: antlr4-rust-gen v emitted generated-code API revision 999, but the selected antlr-rust-runtime supports revisions 1, 2, 3, 4, and 5; regenerate this recognizer with a compatible antlr4-rust-gen or select a compatible antlr-rust-runtime dependency +error: antlr4-rust generated-code API mismatch: antlr4-rust-gen v emitted generated-code API revision 999, but the selected antlr-rust-runtime supports revisions 1, 2, 3, 4, 5, and 6; regenerate this recognizer with a compatible antlr4-rust-gen or select a compatible antlr-rust-runtime dependency --> src/codegen_api_parser.rs:3:1 diff --git a/crates/antlr-rust-g4-parser/src/generated/antlr_v4_lexer.rs b/crates/antlr-rust-g4-parser/src/generated/antlr_v4_lexer.rs index 5b1e6746..6af107fe 100644 --- a/crates/antlr-rust-g4-parser/src/generated/antlr_v4_lexer.rs +++ b/crates/antlr-rust-g4-parser/src/generated/antlr_v4_lexer.rs @@ -1,6 +1,6 @@ // @generated by antlr-rust-codegen v0.28.0 - do not edit // project: https://github.com/ophi-dev/antlr-rust-runtime -antlr4_runtime::__antlr4_rust_require_codegen_api!(5, "0.28.0"); +antlr4_runtime::__antlr4_rust_require_codegen_api!(6, "0.28.0"); #[allow(warnings, missing_docs, clippy::all, clippy::pedantic, clippy::nursery)] #[rustfmt::skip] mod __antlr4_rust_generated { diff --git a/crates/antlr-rust-g4-parser/src/generated/antlr_v4_parser.rs b/crates/antlr-rust-g4-parser/src/generated/antlr_v4_parser.rs index 27db37da..29c797b0 100644 --- a/crates/antlr-rust-g4-parser/src/generated/antlr_v4_parser.rs +++ b/crates/antlr-rust-g4-parser/src/generated/antlr_v4_parser.rs @@ -1,6 +1,6 @@ // @generated by antlr-rust-codegen v0.28.0 - do not edit // project: https://github.com/ophi-dev/antlr-rust-runtime -antlr4_runtime::__antlr4_rust_require_codegen_api!(5, "0.28.0"); +antlr4_runtime::__antlr4_rust_require_codegen_api!(6, "0.28.0"); #[allow(warnings, missing_docs, clippy::all, clippy::pedantic, clippy::nursery)] #[rustfmt::skip] mod __antlr4_rust_generated { @@ -6157,626 +6157,316 @@ where #[allow(dead_code)] fn parse_generated_rule_0_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(0) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_0(precedence, allow_fallback)) - } else { - self.parse_generated_rule_0(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(0); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 0, GeneratedRuleError::Fatal; self.parse_generated_rule_0(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_0(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(0isize, 0); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(134isize); - let __child = self.parse_generated_rule_1_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_138 = false; - loop { - match self.base.sync_decision(atn(), 138, !__ctx.has_matched_child(), __loop_iter_138) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 36..=39 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - -1 | 9 | 12 | 40 | 44..=46 | 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 138, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_138 = true; - let __invoking_marker = self.base.push_invoking_state(135isize); - let __child = self.parse_generated_rule_3_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - let __invoking_marker = self.base.push_invoking_state(141isize); - let __child = self.parse_generated_rule_17_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_145 = false; - loop { - match self.base.sync_decision(atn(), 145, !__ctx.has_matched_child(), __loop_iter_145) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 0isize, 0, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(134isize); + let __child = self.parse_generated_rule_1_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_138 = false; + loop { + match self.base.sync_decision(atn(), 138, !__ctx.has_matched_child(), __loop_iter_138) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 36..=39 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + -1 | 9 | 12 | 40 | 44..=46 | 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 138, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_138 = true; + let __invoking_marker = self.base.push_invoking_state(135isize); + let __child = self.parse_generated_rule_3_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 52 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - -1 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 145, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_145 = true; - let __invoking_marker = self.base.push_invoking_state(142isize); - let __child = self.parse_generated_rule_16_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(141isize); + let __child = self.parse_generated_rule_17_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_145 = false; + loop { + match self.base.sync_decision(atn(), 145, !__ctx.has_matched_child(), __loop_iter_145) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { - break; + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 52 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + -1 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 145, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_145 = true; + let __invoking_marker = self.base.push_invoking_state(142isize); + let __child = self.parse_generated_rule_16_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - let __match = self.base.match_token_recovering(-1, 149, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __match = self.base.match_token_recovering(-1, 149, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_1_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(1) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_1(precedence, allow_fallback)) - } else { - self.parse_generated_rule_1(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(1); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 1, GeneratedRuleError::Fatal; self.parse_generated_rule_1(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_1(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(2isize, 1); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(150isize); - let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __invoking_marker = self.base.push_invoking_state(151isize); - let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(56, 153, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 2isize, 1, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(150isize); + let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(151isize); + let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(56, 153, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_2_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(2) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_2(precedence, allow_fallback)) - } else { - self.parse_generated_rule_2(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(2); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 2, GeneratedRuleError::Fatal; self.parse_generated_rule_2(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_2(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(4isize, 2); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 41 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 42 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 43 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 159, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 4isize, 2, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 41 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 42 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 43 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 159, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 41 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 42 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 43 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 41 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 42 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 43 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 159, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(41, 155, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(43, 160, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + 2 => { + let __match = self.base.match_token_recovering(42, 157, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(43, 160, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 3 => { + let __match = self.base.match_token_recovering(43, 160, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 159, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(41, 155, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(43, 160, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __match = self.base.match_token_recovering(42, 157, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(43, 160, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __match = self.base.match_token_recovering(43, 160, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_3_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(3) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_3(precedence, allow_fallback)) - } else { - self.parse_generated_rule_3(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(3); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 3, GeneratedRuleError::Fatal; self.parse_generated_rule_3(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_3(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(6isize, 3); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 39 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 37 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 38 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 71 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 166, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 6isize, 3, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 39 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 37 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 38 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 71 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 166, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 39 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 37 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 38 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 71 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 39 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 37 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 38 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 71 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 166, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(161isize); - let __child = self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(162isize); - let __child = self.parse_generated_rule_7_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 3 => { - let __invoking_marker = self.base.push_invoking_state(163isize); - let __child = self.parse_generated_rule_9_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 4 => { - let __invoking_marker = self.base.push_invoking_state(164isize); - let __child = self.parse_generated_rule_10_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 5 => { - let __invoking_marker = self.base.push_invoking_state(165isize); - let __child = self.parse_generated_rule_12_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_4_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(4) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_4(precedence, allow_fallback)) - } else { - self.parse_generated_rule_4(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(4); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_4(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(8isize, 4); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(36, 174, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_174 = false; - loop { - match self.base.sync_decision(atn(), 174, !__ctx.has_matched_child(), __loop_iter_174) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 59 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 174, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 166, &__prediction); match __prediction.alt { 1 => { - __loop_iter_174 = true; - let __invoking_marker = self.base.push_invoking_state(169isize); - let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(161isize); + let __child = self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(56, 171, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } 2 => { - break; + let __invoking_marker = self.base.push_invoking_state(162isize); + let __child = self.parse_generated_rule_7_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 3 => { + let __invoking_marker = self.base.push_invoking_state(163isize); + let __child = self.parse_generated_rule_9_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 4 => { + let __invoking_marker = self.base.push_invoking_state(164isize); + let __child = self.parse_generated_rule_10_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 5 => { + let __invoking_marker = self.base.push_invoking_state(165isize); + let __child = self.parse_generated_rule_12_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __match = self.base.match_token_recovering(59, 178, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_5_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_4_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(5) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_5(precedence, allow_fallback)) - } else { - self.parse_generated_rule_5(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(5); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 4, GeneratedRuleError::Fatal; self.parse_generated_rule_4(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_5(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_4(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(10isize, 5); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(179isize); - let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(7, 181, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(181isize); - let __child = self.parse_generated_rule_6_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_6_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(6) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_6(precedence, allow_fallback)) - } else { - self.parse_generated_rule_6(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(6); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_6(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(12isize, 6); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 11 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 33 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 194, !__ctx.has_matched_child(), false) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 8isize, 4, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(36, 174, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_174 = false; + loop { + match self.base.sync_decision(atn(), 174, !__ctx.has_matched_child(), __loop_iter_174) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -6785,533 +6475,269 @@ where return Err(__error); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 11 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 33 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 59 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 194, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(183isize); - let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_188 = false; - loop { - match self.base.sync_decision(atn(), 188, !__ctx.has_matched_child(), __loop_iter_188) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + }; + self.base.record_generated_prediction_diagnostic(atn(), 174, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_174 = true; + let __invoking_marker = self.base.push_invoking_state(169isize); + let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(56, 171, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 70 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 188, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_188 = true; - let __match = self.base.match_token_recovering(70, 185, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(185isize); - let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 2 => { + break; } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - 2 => { - let __match = self.base.match_token_recovering(11, 195, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __invoking_marker = self.base.push_invoking_state(192isize); - let __child = self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 4 => { - let __match = self.base.match_token_recovering(33, 195, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __match = self.base.match_token_recovering(59, 178, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_7_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_5_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(7) { - return Err(GeneratedRuleError::Fatal(error)); + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 5, GeneratedRuleError::Fatal; self.parse_generated_rule_5(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_5(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 10isize, 5, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(179isize); + let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(7, 181, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(181isize); + let __child = self.parse_generated_rule_6_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + success {} + recovery {} } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_7(precedence, allow_fallback)) - } else { - self.parse_generated_rule_7(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(7); - __listener_result } #[allow(dead_code)] - fn parse_generated_rule_7(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_6_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 6, GeneratedRuleError::Fatal; self.parse_generated_rule_6(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_6(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(14isize, 7); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(39, 197, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(197isize); - let __child = self.parse_generated_rule_8_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_202 = false; - loop { - match self.base.sync_decision(atn(), 202, !__ctx.has_matched_child(), __loop_iter_202) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 12isize, 6, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 55 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 11 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 33 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 194, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 11 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 33 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } }; - self.base.record_generated_prediction_diagnostic(atn(), 202, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 194, &__prediction); match __prediction.alt { 1 => { - __loop_iter_202 = true; - let __match = self.base.match_token_recovering(55, 199, atn())?; + let __invoking_marker = self.base.push_invoking_state(183isize); + let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_188 = false; + loop { + match self.base.sync_decision(atn(), 188, !__ctx.has_matched_child(), __loop_iter_188) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 70 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 188, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_188 = true; + let __match = self.base.match_token_recovering(70, 185, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(185isize); + let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + } + 2 => { + let __match = self.base.match_token_recovering(11, 195, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(199isize); - let __child = self.parse_generated_rule_8_dispatch(0, false).map_err(GeneratedRuleError::into_error); + } + 3 => { + let __invoking_marker = self.base.push_invoking_state(192isize); + let __child = self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } - 2 => { - break; + 4 => { + let __match = self.base.match_token_recovering(33, 195, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __match = self.base.match_token_recovering(56, 206, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_8_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(8) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_8(precedence, allow_fallback)) - } else { - self.parse_generated_rule_8(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(8); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_8(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(16isize, 8); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 212, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 212) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(8, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(8, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 212, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(207isize); - let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(7, 209, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(209isize); - let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(211isize); - let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_9_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(9) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_9(precedence, allow_fallback)) - } else { - self.parse_generated_rule_9(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(9); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_9(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(18isize, 9); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(37, 216, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 216, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 59 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 216, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(215isize); - let __child = self.parse_generated_rule_11_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(59, 219, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_10_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_7_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(10) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_10(precedence, allow_fallback)) - } else { - self.parse_generated_rule_10(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(10); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 7, GeneratedRuleError::Fatal; self.parse_generated_rule_7(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_10(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_7(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(20isize, 10); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(38, 222, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 222, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 59 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 222, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(221isize); - let __child = self.parse_generated_rule_11_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(59, 225, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 14isize, 7, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(39, 197, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(197isize); + let __child = self.parse_generated_rule_8_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_202 = false; + loop { + match self.base.sync_decision(atn(), 202, !__ctx.has_matched_child(), __loop_iter_202) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 55 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 202, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_202 = true; + let __match = self.base.match_token_recovering(55, 199, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(199isize); + let __child = self.parse_generated_rule_8_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __match = self.base.match_token_recovering(56, 206, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_11_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_8_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(11) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_11(precedence, allow_fallback)) - } else { - self.parse_generated_rule_11(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(11); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 8, GeneratedRuleError::Fatal; self.parse_generated_rule_8(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_11(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_8(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(22isize, 11); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(226isize); - let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_231 = false; - loop { - match self.base.sync_decision(atn(), 231, !__ctx.has_matched_child(), __loop_iter_231) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 16isize, 8, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 212, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -7321,12 +6747,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 231) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 212) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(11, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(8, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -7336,7 +6762,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(11, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(8, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -7345,384 +6771,224 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 231, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 212, &__prediction); match __prediction.alt { 1 => { - __loop_iter_231 = true; - let __match = self.base.match_token_recovering(55, 228, atn())?; + let __invoking_marker = self.base.push_invoking_state(207isize); + let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(7, 209, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(228isize); + let __invoking_marker = self.base.push_invoking_state(209isize); let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; + let __invoking_marker = self.base.push_invoking_state(211isize); + let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - match self.base.sync_decision(atn(), 235, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 55 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 59 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 235, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(55, 236, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_12_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_9_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(12) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_12(precedence, allow_fallback)) - } else { - self.parse_generated_rule_12(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(12); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 9, GeneratedRuleError::Fatal; self.parse_generated_rule_9(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_12(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_9(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(24isize, 12); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(71, 241, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 241, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 18isize, 9, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(37, 216, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 216, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 241) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(13, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 59 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(13, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 241, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(238isize); - let __child = self.parse_generated_rule_13_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(54, 240, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(243isize); - let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __invoking_marker = self.base.push_invoking_state(244isize); - let __child = self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); + self.base.record_generated_prediction_diagnostic(atn(), 216, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(215isize); + let __child = self.parse_generated_rule_11_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __match = self.base.match_token_recovering(59, 219, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_13_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_10_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(13) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_13(precedence, allow_fallback)) - } else { - self.parse_generated_rule_13(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(13); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 10, GeneratedRuleError::Fatal; self.parse_generated_rule_10(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_13(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_10(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(26isize, 13); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 41 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 42 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 249, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 20isize, 10, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(38, 222, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 222, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 41 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 42 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 249, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(246isize); - let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(41, 250, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __match = self.base.match_token_recovering(42, 250, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 59 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 222, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(221isize); + let __child = self.parse_generated_rule_11_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __match = self.base.match_token_recovering(59, 225, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_14_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_11_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(14) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_14(precedence, allow_fallback)) - } else { - self.parse_generated_rule_14(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(14); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 11, GeneratedRuleError::Fatal; self.parse_generated_rule_11(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_14(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_11(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(28isize, 14); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(4, 252, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 22isize, 11, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(226isize); + let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_231 = false; + loop { + match self.base.sync_decision(atn(), 231, !__ctx.has_matched_child(), __loop_iter_231) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 231) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(11, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(11, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 231, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_231 = true; + let __match = self.base.match_token_recovering(55, 228, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(228isize); + let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_15_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(15) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_15(precedence, allow_fallback)) - } else { - self.parse_generated_rule_15(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(15); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_15(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(30isize, 15); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(35, 257, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_257 = false; - loop { - match self.base.sync_decision(atn(), 257, !__ctx.has_matched_child(), __loop_iter_257) { + match self.base.sync_decision(atn(), 235, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -7732,101 +6998,47 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(15, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __prediction = match self.base.la(1) { + 55 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 59 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - self.base.record_generated_prediction_diagnostic(atn(), 257, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 235, &__prediction); match __prediction.alt { - 2 => { - __loop_iter_257 = true; - let __match = self.base.match_token_recovering(77, 256, atn())?; + 1 => { + let __match = self.base.match_token_recovering(55, 236, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - 1 => { - break; + 2 => { } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __match = self.base.match_token_recovering(75, 261, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_16_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_12_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(16) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_16(precedence, allow_fallback)) - } else { - self.parse_generated_rule_16(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(16); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 12, GeneratedRuleError::Fatal; self.parse_generated_rule_12(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_16(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_12(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(32isize, 16); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(52, 263, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(263isize); - let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(56, 268, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_268 = false; - loop { - match self.base.sync_decision(atn(), 268, !__ctx.has_matched_child(), __loop_iter_268) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 24isize, 12, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(71, 241, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 241, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -7836,174 +7048,173 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 12 | 40 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - -1 | 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 241) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(13, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(13, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } }; - self.base.record_generated_prediction_diagnostic(atn(), 268, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 241, &__prediction); match __prediction.alt { 1 => { - __loop_iter_268 = true; - let __invoking_marker = self.base.push_invoking_state(265isize); - let __child = self.parse_generated_rule_33_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(238isize); + let __child = self.parse_generated_rule_13_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(54, 240, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __invoking_marker = self.base.push_invoking_state(243isize); + let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(244isize); + let __child = self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_17_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_13_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(17) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_17(precedence, allow_fallback)) - } else { - self.parse_generated_rule_17(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(17); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 13, GeneratedRuleError::Fatal; self.parse_generated_rule_13(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_17(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_13(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(34isize, 17); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __loop_iter_274 = false; - loop { - match self.base.sync_decision(atn(), 274, !__ctx.has_matched_child(), __loop_iter_274) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 26isize, 13, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 9 | 12 | 40 | 44..=46 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - -1 | 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 41 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 42 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 249, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 41 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 42 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } }; - self.base.record_generated_prediction_diagnostic(atn(), 274, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 249, &__prediction); match __prediction.alt { 1 => { - __loop_iter_274 = true; - let __invoking_marker = self.base.push_invoking_state(271isize); - let __child = self.parse_generated_rule_18_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(246isize); + let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; + let __match = self.base.match_token_recovering(41, 250, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 3 => { + let __match = self.base.match_token_recovering(42, 250, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_18_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_14_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(18) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_18(precedence, allow_fallback)) - } else { - self.parse_generated_rule_18(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(18); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 14, GeneratedRuleError::Fatal; self.parse_generated_rule_14(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_18(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_14(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(36isize, 18); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 9 | 44..=46 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 12 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 279, !__ctx.has_matched_child(), false) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 28isize, 14, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(4, 252, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_15_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 15, GeneratedRuleError::Fatal; self.parse_generated_rule_15(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_15(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 30isize, 15, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(35, 257, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_257 = false; + loop { + match self.base.sync_decision(atn(), 257, !__ctx.has_matched_child(), __loop_iter_257) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -8012,354 +7223,255 @@ where return Err(__error); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 279) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(18, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(18, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(15, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + self.base.record_generated_prediction_diagnostic(atn(), 257, &__prediction); + match __prediction.alt { + 2 => { + __loop_iter_257 = true; + let __match = self.base.match_token_recovering(77, 256, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 1 => { + break; } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 279, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(277isize); - let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(278isize); - let __child = self.parse_generated_rule_33_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __match = self.base.match_token_recovering(75, 261, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_19_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_16_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(19) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_19(precedence, allow_fallback)) - } else { - self.parse_generated_rule_19(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(19); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 16, GeneratedRuleError::Fatal; self.parse_generated_rule_16(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_19(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_16(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(38isize, 19); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 282, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 40 | 44..=46 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 9 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 282, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(281isize); - let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(9, 286, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 286, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 35 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 36 | 47..=49 | 53 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 286, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(285isize); - let __child = self.parse_generated_rule_15_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 289, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 36 | 48..=49 | 53 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 289, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(288isize); - let __child = self.parse_generated_rule_24_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 292, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 49 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 36 | 48 | 53 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 292, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(291isize); - let __child = self.parse_generated_rule_25_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 295, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 48 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 36 | 53 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 295, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(294isize); - let __child = self.parse_generated_rule_26_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 32isize, 16, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(52, 263, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(263isize); + let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(56, 268, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_268 = false; + loop { + match self.base.sync_decision(atn(), 268, !__ctx.has_matched_child(), __loop_iter_268) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 12 | 40 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + -1 | 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 268, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_268 = true; + let __invoking_marker = self.base.push_invoking_state(265isize); + let __child = self.parse_generated_rule_33_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let mut __loop_iter_300 = false; - loop { - match self.base.sync_decision(atn(), 300, !__ctx.has_matched_child(), __loop_iter_300) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_17_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 17, GeneratedRuleError::Fatal; self.parse_generated_rule_17(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_17(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 34isize, 17, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __loop_iter_274 = false; + loop { + match self.base.sync_decision(atn(), 274, !__ctx.has_matched_child(), __loop_iter_274) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 9 | 12 | 40 | 44..=46 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + -1 | 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 274, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_274 = true; + let __invoking_marker = self.base.push_invoking_state(271isize); + let __child = self.parse_generated_rule_18_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_18_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 18, GeneratedRuleError::Fatal; self.parse_generated_rule_18(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_18(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 36isize, 18, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 36 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 53 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 9 | 44..=46 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 12 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 279, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 279) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(18, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(18, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } + } }; - self.base.record_generated_prediction_diagnostic(atn(), 300, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 279, &__prediction); match __prediction.alt { 1 => { - __loop_iter_300 = true; - let __invoking_marker = self.base.push_invoking_state(297isize); - let __child = self.parse_generated_rule_23_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(277isize); + let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; + let __invoking_marker = self.base.push_invoking_state(278isize); + let __child = self.parse_generated_rule_33_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __match = self.base.match_token_recovering(53, 304, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(304isize); - let __child = self.parse_generated_rule_30_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(56, 306, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(306isize); - let __child = self.parse_generated_rule_20_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_20_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_19_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(20) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_20(precedence, allow_fallback)) - } else { - self.parse_generated_rule_20(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(20); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 19, GeneratedRuleError::Fatal; self.parse_generated_rule_19(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_20(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_19(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(40isize, 20); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __loop_iter_311 = false; - loop { - match self.base.sync_decision(atn(), 311, !__ctx.has_matched_child(), __loop_iter_311) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 38isize, 19, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 282, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -8370,243 +7482,141 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - -1 | 9 | 12 | 40 | 44..=46 | 51..=52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 40 | 44..=46 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 9 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 311, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 282, &__prediction); match __prediction.alt { 1 => { - __loop_iter_311 = true; - let __invoking_marker = self.base.push_invoking_state(308isize); - let __child = self.parse_generated_rule_21_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(281isize); + let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - match self.base.sync_decision(atn(), 315, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 51 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - -1 | 9 | 12 | 40 | 44..=46 | 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 315, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(314isize); - let __child = self.parse_generated_rule_22_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(9, 286, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 286, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 35 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 36 | 47..=49 | 53 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 286, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(285isize); + let __child = self.parse_generated_rule_15_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); + match self.base.sync_decision(atn(), 289, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_21_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(21) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_21(precedence, allow_fallback)) - } else { - self.parse_generated_rule_21(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(21); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_21(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(42isize, 21); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(50, 318, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(318isize); - let __child = self.parse_generated_rule_15_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __invoking_marker = self.base.push_invoking_state(319isize); - let __child = self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 36 | 48..=49 | 53 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 289, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(288isize); + let __child = self.parse_generated_rule_24_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_22_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(22) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_22(precedence, allow_fallback)) - } else { - self.parse_generated_rule_22(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(22); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_22(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(44isize, 22); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(51, 322, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(322isize); - let __child = self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); + match self.base.sync_decision(atn(), 292, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_23_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(23) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_23(precedence, allow_fallback)) - } else { - self.parse_generated_rule_23(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(23); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_23(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(46isize, 23); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 326, !__ctx.has_matched_child(), false) { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 49 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 36 | 48 | 53 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 292, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(291isize); + let __child = self.parse_generated_rule_25_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 295, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 48 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 36 | 53 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 295, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(294isize); + let __child = self.parse_generated_rule_26_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let mut __loop_iter_300 = false; + loop { + match self.base.sync_decision(atn(), 300, !__ctx.has_matched_child(), __loop_iter_300) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -8615,159 +7625,99 @@ where return Err(__error); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 36 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 53 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 300, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_300 = true; + let __invoking_marker = self.base.push_invoking_state(297isize); + let __child = self.parse_generated_rule_23_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 326, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(324isize); - let __child = self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(325isize); - let __child = self.parse_generated_rule_27_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __match = self.base.match_token_recovering(53, 304, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(304isize); + let __child = self.parse_generated_rule_30_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(56, 306, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(306isize); + let __child = self.parse_generated_rule_20_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_24_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_20_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(24) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_24(precedence, allow_fallback)) - } else { - self.parse_generated_rule_24(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(24); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 20, GeneratedRuleError::Fatal; self.parse_generated_rule_20(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_24(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_20(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(48isize, 24); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(47, 329, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(329isize); - let __child = self.parse_generated_rule_15_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 40isize, 20, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __loop_iter_311 = false; + loop { + match self.base.sync_decision(atn(), 311, !__ctx.has_matched_child(), __loop_iter_311) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + -1 | 9 | 12 | 40 | 44..=46 | 51..=52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 311, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_311 = true; + let __invoking_marker = self.base.push_invoking_state(308isize); + let __child = self.parse_generated_rule_21_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_25_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(25) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_25(precedence, allow_fallback)) - } else { - self.parse_generated_rule_25(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(25); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_25(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(50isize, 25); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(49, 332, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(332isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_337 = false; - loop { - match self.base.sync_decision(atn(), 337, !__ctx.has_matched_child(), __loop_iter_337) { + match self.base.sync_decision(atn(), 315, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -8778,924 +7728,442 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 55 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 36 | 48 | 53 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 51 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + -1 | 9 | 12 | 40 | 44..=46 | 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - self.base.record_generated_prediction_diagnostic(atn(), 337, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 315, &__prediction); match __prediction.alt { 1 => { - __loop_iter_337 = true; - let __match = self.base.match_token_recovering(55, 334, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(334isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(314isize); + let __child = self.parse_generated_rule_22_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_26_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_21_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(26) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_26(precedence, allow_fallback)) - } else { - self.parse_generated_rule_26(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(26); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 21, GeneratedRuleError::Fatal; self.parse_generated_rule_21(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_26(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_21(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(52isize, 26); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(48, 341, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(341isize); - let __child = self.parse_generated_rule_15_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 42isize, 21, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(50, 318, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(318isize); + let __child = self.parse_generated_rule_15_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(319isize); + let __child = self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_27_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_22_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(27) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_27(precedence, allow_fallback)) - } else { - self.parse_generated_rule_27(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(27); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 22, GeneratedRuleError::Fatal; self.parse_generated_rule_22(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_27(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_22(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(54isize, 27); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(71, 344, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(344isize); - let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __invoking_marker = self.base.push_invoking_state(345isize); - let __child = self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 44isize, 22, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(51, 322, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(322isize); + let __child = self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_28_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_23_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(28) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_28(precedence, allow_fallback)) - } else { - self.parse_generated_rule_28(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(28); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 23, GeneratedRuleError::Fatal; self.parse_generated_rule_23(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_28(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_23(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(56isize, 28); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(347isize); - let __child = self.parse_generated_rule_29_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_350 = true; - loop { - match self.base.sync_decision(atn(), 350, !__ctx.has_matched_child(), __loop_iter_350) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 46isize, 23, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 40 | 44..=46 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 9 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 326, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } }; - self.base.record_generated_prediction_diagnostic(atn(), 350, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 326, &__prediction); match __prediction.alt { 1 => { - __loop_iter_350 = true; - let __invoking_marker = self.base.push_invoking_state(347isize); - let __child = self.parse_generated_rule_29_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(324isize); + let __child = self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; + let __invoking_marker = self.base.push_invoking_state(325isize); + let __child = self.parse_generated_rule_27_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_29_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_24_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(29) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_29(precedence, allow_fallback)) - } else { - self.parse_generated_rule_29(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(29); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 24, GeneratedRuleError::Fatal; self.parse_generated_rule_24(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_29(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_24(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(58isize, 29); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_set_recovering(&[(40, 40), (44, 46)], 353, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 48isize, 24, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(47, 329, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(329isize); + let __child = self.parse_generated_rule_15_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_30_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_25_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(30) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_30(precedence, allow_fallback)) - } else { - self.parse_generated_rule_30(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(30); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 25, GeneratedRuleError::Fatal; self.parse_generated_rule_25(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_30(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_25(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(60isize, 30); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(354isize); - let __child = self.parse_generated_rule_31_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 50isize, 25, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(49, 332, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(332isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_337 = false; + loop { + match self.base.sync_decision(atn(), 337, !__ctx.has_matched_child(), __loop_iter_337) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 55 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 36 | 48 | 53 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 337, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_337 = true; + let __match = self.base.match_token_recovering(55, 334, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(334isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_31_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_26_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(31) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_31(precedence, allow_fallback)) - } else { - self.parse_generated_rule_31(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(31); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 26, GeneratedRuleError::Fatal; self.parse_generated_rule_26(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_31(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_26(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(62isize, 31); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(356isize); - let __child = self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_361 = false; - loop { - match self.base.sync_decision(atn(), 361, !__ctx.has_matched_child(), __loop_iter_361) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 67 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 361, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_361 = true; - let __match = self.base.match_token_recovering(67, 358, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(358isize); - let __child = self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 52isize, 26, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(48, 341, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(341isize); + let __child = self.parse_generated_rule_15_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_32_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_27_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(32) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_32(precedence, allow_fallback)) - } else { - self.parse_generated_rule_32(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(32); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 27, GeneratedRuleError::Fatal; self.parse_generated_rule_27(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_32(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_27(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(64isize, 32); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(364isize); - let __child = self.parse_generated_rule_45_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 367, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 72 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 56 | 67 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 367, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(72, 366, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(366isize); - let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 54isize, 27, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(71, 344, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(344isize); + let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(345isize); + let __child = self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_33_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_28_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(33) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_33(precedence, allow_fallback)) - } else { - self.parse_generated_rule_33(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(33); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 28, GeneratedRuleError::Fatal; self.parse_generated_rule_28(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_33(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_28(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(66isize, 33); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 370, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 40 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 12 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 370, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(40, 371, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(12, 374, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 374, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 53 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 374, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(373isize); - let __child = self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(53, 377, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(377isize); - let __child = self.parse_generated_rule_34_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(56, 379, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 56isize, 28, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(347isize); + let __child = self.parse_generated_rule_29_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_350 = true; + loop { + match self.base.sync_decision(atn(), 350, !__ctx.has_matched_child(), __loop_iter_350) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 40 | 44..=46 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 9 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 350, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_350 = true; + let __invoking_marker = self.base.push_invoking_state(347isize); + let __child = self.parse_generated_rule_29_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_34_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_29_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(34) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_34(precedence, allow_fallback)) - } else { - self.parse_generated_rule_34(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(34); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 29, GeneratedRuleError::Fatal; self.parse_generated_rule_29(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_34(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_29(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(68isize, 34); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(380isize); - let __child = self.parse_generated_rule_35_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 58isize, 29, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_set_recovering(&[(40, 40), (44, 46)], 353, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_35_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_30_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(35) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_35(precedence, allow_fallback)) - } else { - self.parse_generated_rule_35(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(35); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 30, GeneratedRuleError::Fatal; self.parse_generated_rule_30(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_35(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_30(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(70isize, 35); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(382isize); - let __child = self.parse_generated_rule_36_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_387 = false; - loop { - match self.base.sync_decision(atn(), 387, !__ctx.has_matched_child(), __loop_iter_387) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 67 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 56 | 58 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 387, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_387 = true; - let __match = self.base.match_token_recovering(67, 384, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(384isize); - let __child = self.parse_generated_rule_36_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 60isize, 30, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(354isize); + let __child = self.parse_generated_rule_31_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_36_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_31_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(36) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_36(precedence, allow_fallback)) - } else { - self.parse_generated_rule_36(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(36); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 31, GeneratedRuleError::Fatal; self.parse_generated_rule_31(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_36(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_31(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(72isize, 36); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 395, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 395) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(36, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(36, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 395, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(390isize); - let __child = self.parse_generated_rule_37_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 392, !__ctx.has_matched_child(), false) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 62isize, 31, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(356isize); + let __child = self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_361 = false; + loop { + match self.base.sync_decision(atn(), 361, !__ctx.has_matched_child(), __loop_iter_361) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -9706,300 +8174,230 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 60 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 56 | 58 | 67 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 67 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - self.base.record_generated_prediction_diagnostic(atn(), 392, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 361, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(391isize); - let __child = self.parse_generated_rule_40_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_361 = true; + let __match = self.base.match_token_recovering(67, 358, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(358isize); + let __child = self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_37_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_32_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(37) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_37(precedence, allow_fallback)) - } else { - self.parse_generated_rule_37(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(37); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 32, GeneratedRuleError::Fatal; self.parse_generated_rule_32(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_37(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_32(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(74isize, 37); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 403, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 64isize, 32, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(364isize); + let __child = self.parse_generated_rule_45_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 367, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 4 | 8..=9 | 11..=12 | 57 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 56 | 58 | 60 | 67 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 403, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(397isize); - let __child = self.parse_generated_rule_38_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_400 = true; - loop { - match self.base.sync_decision(atn(), 400, !__ctx.has_matched_child(), __loop_iter_400) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 4 | 8..=9 | 11..=12 | 57 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 56 | 58 | 60 | 67 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 400, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_400 = true; - let __invoking_marker = self.base.push_invoking_state(397isize); - let __child = self.parse_generated_rule_38_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 72 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 56 | 67 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 367, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(72, 366, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(366isize); + let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_38_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_33_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(38) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_38(precedence, allow_fallback)) - } else { - self.parse_generated_rule_38(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(38); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 33, GeneratedRuleError::Fatal; self.parse_generated_rule_33(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_38(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_33(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(76isize, 38); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 8..=9 | 11..=12 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 57 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 417, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 66isize, 33, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 370, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 8..=9 | 11..=12 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 57 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 417, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(405isize); - let __child = self.parse_generated_rule_53_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 407, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 40 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 12 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 370, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(40, 371, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 63..=64 | 66 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 8..=9 | 11..=12 | 56..=58 | 60 | 67 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 407, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(406isize); - let __child = self.parse_generated_rule_52_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 2 => { } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => { - let __invoking_marker = self.base.push_invoking_state(409isize); - let __child = self.parse_generated_rule_39_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 411, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + let __match = self.base.match_token_recovering(12, 374, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 374, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 63..=64 | 66 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 8..=9 | 11..=12 | 56..=58 | 60 | 67 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 411, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(410isize); - let __child = self.parse_generated_rule_52_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } } - 3 => { - let __invoking_marker = self.base.push_invoking_state(413isize); - let __child = self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 415, !__ctx.has_matched_child(), false) { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 53 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 374, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(373isize); + let __child = self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(53, 377, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(377isize); + let __child = self.parse_generated_rule_34_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(56, 379, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_34_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 34, GeneratedRuleError::Fatal; self.parse_generated_rule_34(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_34(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 68isize, 34, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(380isize); + let __child = self.parse_generated_rule_35_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_35_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 35, GeneratedRuleError::Fatal; self.parse_generated_rule_35(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_35(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 70isize, 35, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(382isize); + let __child = self.parse_generated_rule_36_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_387 = false; + loop { + match self.base.sync_decision(atn(), 387, !__ctx.has_matched_child(), __loop_iter_387) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -10010,154 +8408,147 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 63 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 8..=9 | 11..=12 | 56..=58 | 60 | 67 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 67 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 56 | 58 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - self.base.record_generated_prediction_diagnostic(atn(), 415, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 387, &__prediction); match __prediction.alt { 1 => { - let __match = self.base.match_token_recovering(63, 416, atn())?; + __loop_iter_387 = true; + let __match = self.base.match_token_recovering(67, 384, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(384isize); + let __child = self.parse_generated_rule_36_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_39_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_36_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(39) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_39(precedence, allow_fallback)) - } else { - self.parse_generated_rule_39(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(39); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 36, GeneratedRuleError::Fatal; self.parse_generated_rule_36(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_39(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_36(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(78isize, 39); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(57, 420, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(420isize); - let __child = self.parse_generated_rule_35_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(58, 422, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 72isize, 36, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 395, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 395) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(36, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(36, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 395, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(390isize); + let __child = self.parse_generated_rule_37_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 392, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 60 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 56 | 58 | 67 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 392, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(391isize); + let __child = self.parse_generated_rule_40_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_40_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_37_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(40) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_40(precedence, allow_fallback)) - } else { - self.parse_generated_rule_40(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(40); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 37, GeneratedRuleError::Fatal; self.parse_generated_rule_37(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_40(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_37(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(80isize, 40); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(60, 424, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(424isize); - let __child = self.parse_generated_rule_41_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_429 = false; - loop { - match self.base.sync_decision(atn(), 429, !__ctx.has_matched_child(), __loop_iter_429) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 74isize, 37, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 403, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -10168,298 +8559,272 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 55 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 56 | 58 | 67 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 8..=9 | 11..=12 | 57 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 56 | 58 | 60 | 67 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - self.base.record_generated_prediction_diagnostic(atn(), 429, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 403, &__prediction); match __prediction.alt { 1 => { - __loop_iter_429 = true; - let __match = self.base.match_token_recovering(55, 426, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(426isize); - let __child = self.parse_generated_rule_41_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(397isize); + let __child = self.parse_generated_rule_38_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_400 = true; + loop { + match self.base.sync_decision(atn(), 400, !__ctx.has_matched_child(), __loop_iter_400) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 4 | 8..=9 | 11..=12 | 57 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 56 | 58 | 60 | 67 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 400, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_400 = true; + let __invoking_marker = self.base.push_invoking_state(397isize); + let __child = self.parse_generated_rule_38_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_41_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_38_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(41) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_41(precedence, allow_fallback)) - } else { - self.parse_generated_rule_41(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(41); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 38, GeneratedRuleError::Fatal; self.parse_generated_rule_38(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_41(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_38(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(82isize, 41); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 438, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 438) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(44, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 76isize, 38, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 8..=9 | 11..=12 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 57 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 417, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 8..=9 | 11..=12 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 57 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(44, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 438, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(432isize); - let __child = self.parse_generated_rule_42_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(57, 434, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(434isize); - let __child = self.parse_generated_rule_43_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(58, 436, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(437isize); - let __child = self.parse_generated_rule_42_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); + self.base.record_generated_prediction_diagnostic(atn(), 417, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(405isize); + let __child = self.parse_generated_rule_53_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 407, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 63..=64 | 66 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 8..=9 | 11..=12 | 56..=58 | 60 | 67 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 407, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(406isize); + let __child = self.parse_generated_rule_52_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(409isize); + let __child = self.parse_generated_rule_39_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 411, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 63..=64 | 66 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 8..=9 | 11..=12 | 56..=58 | 60 | 67 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 411, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(410isize); + let __child = self.parse_generated_rule_52_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + 3 => { + let __invoking_marker = self.base.push_invoking_state(413isize); + let __child = self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 415, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 63 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 8..=9 | 11..=12 | 56..=58 | 60 | 67 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 415, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(63, 416, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_42_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_39_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(42) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_42(precedence, allow_fallback)) - } else { - self.parse_generated_rule_42(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(42); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 39, GeneratedRuleError::Fatal; self.parse_generated_rule_39(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_42(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_39(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(84isize, 42); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 442, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 442, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(440isize); - let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(52, 443, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 78isize, 39, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(57, 420, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(420isize); + let __child = self.parse_generated_rule_35_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(58, 422, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_43_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_40_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(43) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_43(precedence, allow_fallback)) - } else { - self.parse_generated_rule_43(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(43); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 40, GeneratedRuleError::Fatal; self.parse_generated_rule_40(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_43(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_40(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(86isize, 43); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 33 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 446, !__ctx.has_matched_child(), false) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 80isize, 40, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(60, 424, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(424isize); + let __child = self.parse_generated_rule_41_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_429 = false; + loop { + match self.base.sync_decision(atn(), 429, !__ctx.has_matched_child(), __loop_iter_429) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -10468,92 +8833,53 @@ where return Err(__error); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 33 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 55 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 56 | 58 | 67 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 429, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_429 = true; + let __match = self.base.match_token_recovering(55, 426, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(426isize); + let __child = self.parse_generated_rule_41_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 446, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(444isize); - let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(33, 447, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_44_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_41_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(44) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_44(precedence, allow_fallback)) - } else { - self.parse_generated_rule_44(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(44); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 41, GeneratedRuleError::Fatal; self.parse_generated_rule_41(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_44(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_41(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(88isize, 44); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(448isize); - let __child = self.parse_generated_rule_45_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_453 = false; - loop { - match self.base.sync_decision(atn(), 453, !__ctx.has_matched_child(), __loop_iter_453) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 82isize, 41, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 438, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -10563,138 +8889,145 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 67 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 58 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 438) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(44, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(44, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } }; - self.base.record_generated_prediction_diagnostic(atn(), 453, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 438, &__prediction); match __prediction.alt { 1 => { - __loop_iter_453 = true; - let __match = self.base.match_token_recovering(67, 450, atn())?; + let __invoking_marker = self.base.push_invoking_state(432isize); + let __child = self.parse_generated_rule_42_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(57, 434, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(450isize); - let __child = self.parse_generated_rule_45_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(434isize); + let __child = self.parse_generated_rule_43_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(58, 436, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } 2 => { - break; + let __invoking_marker = self.base.push_invoking_state(437isize); + let __child = self.parse_generated_rule_42_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_45_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_42_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(45) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_45(precedence, allow_fallback)) - } else { - self.parse_generated_rule_45(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(45); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 42, GeneratedRuleError::Fatal; self.parse_generated_rule_42(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_45(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_42(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(90isize, 45); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 465, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 4 | 9 | 11..=12 | 57 | 61 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 56 | 58 | 67 | 72 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 465, &__prediction); - match __prediction.alt { - 1 => { - match self.base.sync_decision(atn(), 457, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 84isize, 42, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 442, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 9 | 11..=12 | 57 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 457, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(456isize); - let __child = self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 442, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(440isize); + let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __match = self.base.match_token_recovering(52, 443, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __invoking_marker = self.base.push_invoking_state(459isize); - let __child = self.parse_generated_rule_46_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_462 = true; - loop { - match self.base.sync_decision(atn(), 462, !__ctx.has_matched_child(), __loop_iter_462) { + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_43_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 43, GeneratedRuleError::Fatal; self.parse_generated_rule_43(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_43(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 86isize, 43, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 33 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 446, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -10703,215 +9036,59 @@ where return Err(__error); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 4 | 9 | 11..=12 | 57 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 56 | 58 | 67 | 72 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 462, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_462 = true; - let __invoking_marker = self.base.push_invoking_state(459isize); - let __child = self.parse_generated_rule_46_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 33 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } + }; + self.base.record_generated_prediction_diagnostic(atn(), 446, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(444isize); + let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __match = self.base.match_token_recovering(33, 447, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_46_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_44_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(46) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_46(precedence, allow_fallback)) - } else { - self.parse_generated_rule_46(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(46); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 44, GeneratedRuleError::Fatal; self.parse_generated_rule_44(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_46(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_44(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(92isize, 46); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 11 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 57 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 485, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 485) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(55, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(55, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 485, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(467isize); - let __child = self.parse_generated_rule_49_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 470, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 63..=64 | 66 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 9 | 11..=12 | 56..=58 | 67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 470, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(468isize); - let __child = self.parse_generated_rule_52_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(472isize); - let __child = self.parse_generated_rule_54_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 475, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 63..=64 | 66 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 9 | 11..=12 | 56..=58 | 67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 475, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(473isize); - let __child = self.parse_generated_rule_52_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - 3 => { - let __invoking_marker = self.base.push_invoking_state(477isize); - let __child = self.parse_generated_rule_50_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 4 => { - let __invoking_marker = self.base.push_invoking_state(478isize); - let __child = self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 480, !__ctx.has_matched_child(), false) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 88isize, 44, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(448isize); + let __child = self.parse_generated_rule_45_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_453 = false; + loop { + match self.base.sync_decision(atn(), 453, !__ctx.has_matched_child(), __loop_iter_453) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -10922,117 +9099,51 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 63 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 9 | 11..=12 | 56..=58 | 61 | 67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 67 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 58 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - self.base.record_generated_prediction_diagnostic(atn(), 480, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 453, &__prediction); match __prediction.alt { 1 => { - let __match = self.base.match_token_recovering(63, 481, atn())?; + __loop_iter_453 = true; + let __match = self.base.match_token_recovering(67, 450, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 483, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 9 | 11..=12 | 56..=58 | 67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 483, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(482isize); - let __child = self.parse_generated_rule_47_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(450isize); + let __child = self.parse_generated_rule_45_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_47_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_45_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(47) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_47(precedence, allow_fallback)) - } else { - self.parse_generated_rule_47(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(47); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 45, GeneratedRuleError::Fatal; self.parse_generated_rule_45(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_47(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_45(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(94isize, 47); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(61, 488, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(488isize); - let __child = self.parse_generated_rule_48_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_493 = false; - loop { - match self.base.sync_decision(atn(), 493, !__ctx.has_matched_child(), __loop_iter_493) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 90isize, 45, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 465, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -11043,581 +9154,1118 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 55 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 62 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 4 | 9 | 11..=12 | 57 | 61 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 56 | 58 | 67 | 72 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - self.base.record_generated_prediction_diagnostic(atn(), 493, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 465, &__prediction); match __prediction.alt { 1 => { - __loop_iter_493 = true; - let __match = self.base.match_token_recovering(55, 490, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(490isize); - let __child = self.parse_generated_rule_48_dispatch(0, false).map_err(GeneratedRuleError::into_error); + match self.base.sync_decision(atn(), 457, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 9 | 11..=12 | 57 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 457, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(456isize); + let __child = self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __invoking_marker = self.base.push_invoking_state(459isize); + let __child = self.parse_generated_rule_46_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_462 = true; + loop { + match self.base.sync_decision(atn(), 462, !__ctx.has_matched_child(), __loop_iter_462) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 4 | 9 | 11..=12 | 57 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 56 | 58 | 67 | 72 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 462, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_462 = true; + let __invoking_marker = self.base.push_invoking_state(459isize); + let __child = self.parse_generated_rule_46_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __match = self.base.match_token_recovering(62, 497, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_48_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_46_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(48) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_48(precedence, allow_fallback)) - } else { - self.parse_generated_rule_48(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(48); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 46, GeneratedRuleError::Fatal; self.parse_generated_rule_46(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_48(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_46(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(96isize, 48); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 506, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 506) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(58, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(58, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 506, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(498isize); - let __child = self.parse_generated_rule_64_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(499isize); - let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(7, 504, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 4 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 33 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 11 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 504, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 92isize, 46, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 11 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 57 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 485, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 4 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 33 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 11 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 485) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(55, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(55, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 485, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(467isize); + let __child = self.parse_generated_rule_49_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 470, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 63..=64 | 66 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 9 | 11..=12 | 56..=58 | 67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 470, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(468isize); + let __child = self.parse_generated_rule_52_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(472isize); + let __child = self.parse_generated_rule_54_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 475, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 63..=64 | 66 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 9 | 11..=12 | 56..=58 | 67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 475, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(473isize); + let __child = self.parse_generated_rule_52_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + 3 => { + let __invoking_marker = self.base.push_invoking_state(477isize); + let __child = self.parse_generated_rule_50_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 4 => { + let __invoking_marker = self.base.push_invoking_state(478isize); + let __child = self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 480, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 63 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 9 | 11..=12 | 56..=58 | 61 | 67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 480, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(63, 481, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 483, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 9 | 11..=12 | 56..=58 | 67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 483, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(482isize); + let __child = self.parse_generated_rule_47_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_47_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 47, GeneratedRuleError::Fatal; self.parse_generated_rule_47(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_47(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 94isize, 47, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(61, 488, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(488isize); + let __child = self.parse_generated_rule_48_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_493 = false; + loop { + match self.base.sync_decision(atn(), 493, !__ctx.has_matched_child(), __loop_iter_493) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 55 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 62 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 504, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 493, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(501isize); - let __child = self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_493 = true; + let __match = self.base.match_token_recovering(55, 490, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(490isize); + let __child = self.parse_generated_rule_48_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - let __match = self.base.match_token_recovering(33, 505, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __match = self.base.match_token_recovering(62, 497, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_48_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 48, GeneratedRuleError::Fatal; self.parse_generated_rule_48(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_48(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 96isize, 48, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 506, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 506) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(58, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(58, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 506, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(498isize); + let __child = self.parse_generated_rule_64_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(499isize); + let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(7, 504, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 4 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 33 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 11 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 504, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 4 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 33 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 11 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 504, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(501isize); + let __child = self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __match = self.base.match_token_recovering(33, 505, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 3 => { + let __match = self.base.match_token_recovering(11, 505, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_49_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 49, GeneratedRuleError::Fatal; self.parse_generated_rule_49(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_49(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 98isize, 49, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(508isize); + let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_set_recovering(&[(7, 7), (65, 65)], 512, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 9 | 11..=12 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 57 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 512, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 9 | 11..=12 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 57 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 512, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(510isize); + let __child = self.parse_generated_rule_54_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(511isize); + let __child = self.parse_generated_rule_59_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_50_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 50, GeneratedRuleError::Fatal; self.parse_generated_rule_50(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_50(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 100isize, 50, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(514isize); + let __child = self.parse_generated_rule_59_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 516, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 63..=64 | 66 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 9 | 11..=12 | 56..=58 | 67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 516, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(515isize); + let __child = self.parse_generated_rule_51_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_51_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 51, GeneratedRuleError::Fatal; self.parse_generated_rule_51(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_51(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 102isize, 51, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(518isize); + let __child = self.parse_generated_rule_52_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_52_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 52, GeneratedRuleError::Fatal; self.parse_generated_rule_52(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_52(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 104isize, 52, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 63 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 64 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 66 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 532, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 63 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 64 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 66 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 532, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(63, 522, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 522, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 63 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 8..=9 | 11..=12 | 56..=58 | 60 | 67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 522, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(63, 523, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + 2 => { + let __match = self.base.match_token_recovering(64, 526, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 526, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 63 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 8..=9 | 11..=12 | 56..=58 | 60 | 67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 526, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(63, 527, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + 3 => { + let __match = self.base.match_token_recovering(66, 530, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 530, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 63 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 8..=9 | 11..=12 | 56..=58 | 60 | 67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 530, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(63, 531, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_53_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 53, GeneratedRuleError::Fatal; self.parse_generated_rule_53(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_53(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 106isize, 53, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 12 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 9 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 73 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 8 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 70 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 540, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 3 => { - let __match = self.base.match_token_recovering(11, 505, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 540) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(65, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(65, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + }; + self.base.record_generated_prediction_diagnostic(atn(), 540, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(534isize); + let __child = self.parse_generated_rule_61_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(535isize); + let __child = self.parse_generated_rule_62_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 3 => { + let __match = self.base.match_token_recovering(9, 541, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 4 => { + let __invoking_marker = self.base.push_invoking_state(537isize); + let __child = self.parse_generated_rule_56_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 5 => { + let __match = self.base.match_token_recovering(8, 541, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 6 => { + let __invoking_marker = self.base.push_invoking_state(539isize); + let __child = self.parse_generated_rule_55_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_49_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_54_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(49) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_49(precedence, allow_fallback)) - } else { - self.parse_generated_rule_49(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(49); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 54, GeneratedRuleError::Fatal; self.parse_generated_rule_54(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_49(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_54(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(98isize, 49); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(508isize); - let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_set_recovering(&[(7, 7), (65, 65)], 512, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 9 | 11..=12 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 57 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 512, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 108isize, 54, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 11..=12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 9 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 73 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 70 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 546, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 11..=12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 9 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 73 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 70 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 9 | 11..=12 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 57 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 546, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(542isize); + let __child = self.parse_generated_rule_62_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + 2 => { + let __invoking_marker = self.base.push_invoking_state(543isize); + let __child = self.parse_generated_rule_60_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 3 => { + let __invoking_marker = self.base.push_invoking_state(544isize); + let __child = self.parse_generated_rule_56_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 4 => { + let __invoking_marker = self.base.push_invoking_state(545isize); + let __child = self.parse_generated_rule_55_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 512, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(510isize); - let __child = self.parse_generated_rule_54_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(511isize); - let __child = self.parse_generated_rule_59_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_50_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_55_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(50) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_50(precedence, allow_fallback)) - } else { - self.parse_generated_rule_50(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(50); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 55, GeneratedRuleError::Fatal; self.parse_generated_rule_55(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_50(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_55(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(100isize, 50); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(514isize); - let __child = self.parse_generated_rule_59_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 516, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 63..=64 | 66 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 9 | 11..=12 | 56..=58 | 67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 516, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(515isize); - let __child = self.parse_generated_rule_51_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 110isize, 55, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(70, 550, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 550, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 8..=9 | 11..=12 | 56..=58 | 60 | 63..=64 | 66..=67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 550, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(549isize); + let __child = self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_51_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_56_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(51) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_51(precedence, allow_fallback)) - } else { - self.parse_generated_rule_51(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(51); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 56, GeneratedRuleError::Fatal; self.parse_generated_rule_56(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_51(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_56(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(102isize, 51); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(518isize); - let __child = self.parse_generated_rule_52_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 112isize, 56, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 556, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 556) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(68, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(68, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 556, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(73, 553, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(553isize); + let __child = self.parse_generated_rule_58_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __match = self.base.match_token_recovering(73, 555, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(555isize); + let __child = self.parse_generated_rule_57_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_52_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_57_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(52) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_52(precedence, allow_fallback)) - } else { - self.parse_generated_rule_52(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(52); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 57, GeneratedRuleError::Fatal; self.parse_generated_rule_57(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_52(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(104isize, 52); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 63 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 64 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 66 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 532, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 63 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 64 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 66 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 532, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(63, 522, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 522, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 63 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 8..=9 | 11..=12 | 56..=58 | 60 | 67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 522, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(63, 523, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - 2 => { - let __match = self.base.match_token_recovering(64, 526, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 526, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 63 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 8..=9 | 11..=12 | 56..=58 | 60 | 67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 526, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(63, 527, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - 3 => { - let __match = self.base.match_token_recovering(66, 530, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 530, !__ctx.has_matched_child(), false) { + fn parse_generated_rule_57(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 114isize, 57, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(57, 559, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(559isize); + let __child = self.parse_generated_rule_58_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_564 = false; + loop { + match self.base.sync_decision(atn(), 564, !__ctx.has_matched_child(), __loop_iter_564) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -11628,538 +10276,320 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 63 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 8..=9 | 11..=12 | 56..=58 | 60 | 67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 67 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 58 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 530, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 564, &__prediction); match __prediction.alt { 1 => { - let __match = self.base.match_token_recovering(63, 531, atn())?; + __loop_iter_564 = true; + let __match = self.base.match_token_recovering(67, 561, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(561isize); + let __child = self.parse_generated_rule_58_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __match = self.base.match_token_recovering(58, 568, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_53_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_58_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(53) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_53(precedence, allow_fallback)) - } else { - self.parse_generated_rule_53(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(53); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 58, GeneratedRuleError::Fatal; self.parse_generated_rule_58(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_53(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_58(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(106isize, 53); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 12 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 9 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 73 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 8 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 70 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 540, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 116isize, 58, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 8 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 579, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 579) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(72, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(72, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 540) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(65, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + }; + self.base.record_generated_prediction_diagnostic(atn(), 579, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(12, 571, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 571, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 8..=9 | 11..=12 | 56..=58 | 60 | 63..=64 | 66..=67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(65, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + self.base.record_generated_prediction_diagnostic(atn(), 571, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(570isize); + let __child = self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 540, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(534isize); - let __child = self.parse_generated_rule_61_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(535isize); - let __child = self.parse_generated_rule_62_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 3 => { - let __match = self.base.match_token_recovering(9, 541, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 4 => { - let __invoking_marker = self.base.push_invoking_state(537isize); - let __child = self.parse_generated_rule_56_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 5 => { - let __match = self.base.match_token_recovering(8, 541, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 6 => { - let __invoking_marker = self.base.push_invoking_state(539isize); - let __child = self.parse_generated_rule_55_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_54_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(54) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_54(precedence, allow_fallback)) - } else { - self.parse_generated_rule_54(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(54); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_54(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(108isize, 54); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 11..=12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 9 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 73 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 70 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 546, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + 2 => { + let __match = self.base.match_token_recovering(11, 575, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 575, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 8..=9 | 11..=12 | 56..=58 | 60 | 63..=64 | 66..=67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 575, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(574isize); + let __child = self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 11..=12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 9 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 73 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 70 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 3 => { + let __invoking_marker = self.base.push_invoking_state(577isize); + let __child = self.parse_generated_rule_61_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + 4 => { + let __match = self.base.match_token_recovering(8, 580, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 546, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(542isize); - let __child = self.parse_generated_rule_62_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(543isize); - let __child = self.parse_generated_rule_60_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 3 => { - let __invoking_marker = self.base.push_invoking_state(544isize); - let __child = self.parse_generated_rule_56_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 4 => { - let __invoking_marker = self.base.push_invoking_state(545isize); - let __child = self.parse_generated_rule_55_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_55_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(55) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_55(precedence, allow_fallback)) - } else { - self.parse_generated_rule_55(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(55); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_55(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(110isize, 55); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(70, 550, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 550, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 8..=9 | 11..=12 | 56..=58 | 60 | 63..=64 | 66..=67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 550, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(549isize); - let __child = self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_56_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_59_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(56) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_56(precedence, allow_fallback)) - } else { - self.parse_generated_rule_56(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(56); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 59, GeneratedRuleError::Fatal; self.parse_generated_rule_59(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_56(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_59(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(112isize, 56); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 556, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 118isize, 59, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(57, 592, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 592, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 556) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(68, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 36 | 53 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 9 | 11..=12 | 57..=58 | 61 | 67 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(68, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 556, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(73, 553, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(553isize); - let __child = self.parse_generated_rule_58_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(73, 555, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(555isize); - let __child = self.parse_generated_rule_57_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); + self.base.record_generated_prediction_diagnostic(atn(), 592, &__prediction); + match __prediction.alt { + 1 => { + match self.base.sync_decision(atn(), 583, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 53 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 583, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(582isize); + let __child = self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let mut __loop_iter_588 = false; + loop { + match self.base.sync_decision(atn(), 588, !__ctx.has_matched_child(), __loop_iter_588) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 71 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 53 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 588, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_588 = true; + let __invoking_marker = self.base.push_invoking_state(585isize); + let __child = self.parse_generated_rule_27_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __match = self.base.match_token_recovering(53, 593, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __invoking_marker = self.base.push_invoking_state(594isize); + let __child = self.parse_generated_rule_44_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(58, 596, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_57_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_60_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(57) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_57(precedence, allow_fallback)) - } else { - self.parse_generated_rule_57(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(57); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 60, GeneratedRuleError::Fatal; self.parse_generated_rule_60(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_57(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_60(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(114isize, 57); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(57, 559, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(559isize); - let __child = self.parse_generated_rule_58_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_564 = false; - loop { - match self.base.sync_decision(atn(), 564, !__ctx.has_matched_child(), __loop_iter_564) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 120isize, 60, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(9, 599, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 599, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -12170,315 +10600,131 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 67 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 58 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 35 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 9 | 11..=12 | 56..=58 | 61 | 63..=64 | 66..=67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - self.base.record_generated_prediction_diagnostic(atn(), 564, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 599, &__prediction); match __prediction.alt { 1 => { - __loop_iter_564 = true; - let __match = self.base.match_token_recovering(67, 561, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(561isize); - let __child = self.parse_generated_rule_58_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(598isize); + let __child = self.parse_generated_rule_15_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - let __match = self.base.match_token_recovering(58, 568, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); + match self.base.sync_decision(atn(), 602, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 9 | 11..=12 | 56..=58 | 63..=64 | 66..=67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 602, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(601isize); + let __child = self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_58_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_61_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(58) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_58(precedence, allow_fallback)) - } else { - self.parse_generated_rule_58(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(58); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 61, GeneratedRuleError::Fatal; self.parse_generated_rule_61(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_58(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_61(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(116isize, 58); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 8 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 579, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 579) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(72, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(72, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 579, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(12, 571, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 571, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 8..=9 | 11..=12 | 56..=58 | 60 | 63..=64 | 66..=67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 571, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(570isize); - let __child = self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - 2 => { - let __match = self.base.match_token_recovering(11, 575, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 575, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 8..=9 | 11..=12 | 56..=58 | 60 | 63..=64 | 66..=67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 575, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(574isize); - let __child = self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - 3 => { - let __invoking_marker = self.base.push_invoking_state(577isize); - let __child = self.parse_generated_rule_61_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 4 => { - let __match = self.base.match_token_recovering(8, 580, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 122isize, 61, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(11, 605, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(69, 606, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(11, 607, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_59_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_62_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(59) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_59(precedence, allow_fallback)) - } else { - self.parse_generated_rule_59(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(59); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 62, GeneratedRuleError::Fatal; self.parse_generated_rule_62(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_59(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_62(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(118isize, 59); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(57, 592, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 592, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 36 | 53 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 9 | 11..=12 | 57..=58 | 61 | 67 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 592, &__prediction); - match __prediction.alt { - 1 => { - match self.base.sync_decision(atn(), 583, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 53 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 583, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(582isize); - let __child = self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 124isize, 62, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 11 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 616, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 11 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let mut __loop_iter_588 = false; - loop { - match self.base.sync_decision(atn(), 588, !__ctx.has_matched_child(), __loop_iter_588) { + }; + self.base.record_generated_prediction_diagnostic(atn(), 616, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(12, 610, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 610, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -12489,301 +10735,91 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 71 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 53 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 8..=9 | 11..=12 | 56..=58 | 60 | 63..=64 | 66..=67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - self.base.record_generated_prediction_diagnostic(atn(), 588, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 610, &__prediction); match __prediction.alt { 1 => { - __loop_iter_588 = true; - let __invoking_marker = self.base.push_invoking_state(585isize); - let __child = self.parse_generated_rule_27_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(609isize); + let __child = self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __match = self.base.match_token_recovering(53, 593, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(594isize); - let __child = self.parse_generated_rule_44_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(58, 596, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_60_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(60) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_60(precedence, allow_fallback)) - } else { - self.parse_generated_rule_60(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(60); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_60(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(120isize, 60); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(9, 599, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 599, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 35 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 9 | 11..=12 | 56..=58 | 61 | 63..=64 | 66..=67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 599, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(598isize); - let __child = self.parse_generated_rule_15_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 602, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 9 | 11..=12 | 56..=58 | 63..=64 | 66..=67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 602, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(601isize); - let __child = self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_61_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(61) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_61(precedence, allow_fallback)) - } else { - self.parse_generated_rule_61(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(61); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_61(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(122isize, 61); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(11, 605, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(69, 606, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(11, 607, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); + 2 => { + let __match = self.base.match_token_recovering(11, 614, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 614, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 8..=9 | 11..=12 | 56..=58 | 60 | 63..=64 | 66..=67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 614, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(613isize); + let __child = self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_62_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_63_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(62) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_62(precedence, allow_fallback)) - } else { - self.parse_generated_rule_62(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(62); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 63, GeneratedRuleError::Fatal; self.parse_generated_rule_63(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_62(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_63(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(124isize, 62); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 11 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 616, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 11 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 616, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(12, 610, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 610, !__ctx.has_matched_child(), false) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 126isize, 63, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(61, 619, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(619isize); + let __child = self.parse_generated_rule_64_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_624 = false; + loop { + match self.base.sync_decision(atn(), 624, !__ctx.has_matched_child(), __loop_iter_624) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -12794,124 +10830,54 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 8..=9 | 11..=12 | 56..=58 | 60 | 63..=64 | 66..=67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 610, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(609isize); - let __child = self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } + 55 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 62 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - 2 => { - let __match = self.base.match_token_recovering(11, 614, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 614, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 8..=9 | 11..=12 | 56..=58 | 60 | 63..=64 | 66..=67 | 70 | 72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - self.base.record_generated_prediction_diagnostic(atn(), 614, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 624, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(613isize); - let __child = self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_624 = true; + let __match = self.base.match_token_recovering(55, 621, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(621isize); + let __child = self.parse_generated_rule_64_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __match = self.base.match_token_recovering(62, 628, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_63_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_64_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(63) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_63(precedence, allow_fallback)) - } else { - self.parse_generated_rule_63(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(63); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 64, GeneratedRuleError::Fatal; self.parse_generated_rule_64(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_63(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_64(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(126isize, 63); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(61, 619, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(619isize); - let __child = self.parse_generated_rule_64_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_624 = false; - loop { - match self.base.sync_decision(atn(), 624, !__ctx.has_matched_child(), __loop_iter_624) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 128isize, 64, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 637, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -12921,362 +10887,185 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 55 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 62 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 637) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(83, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(83, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } }; - self.base.record_generated_prediction_diagnostic(atn(), 624, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 637, &__prediction); match __prediction.alt { 1 => { - __loop_iter_624 = true; - let __match = self.base.match_token_recovering(55, 621, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(621isize); - let __child = self.parse_generated_rule_64_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(629isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - let __match = self.base.match_token_recovering(62, 628, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_64_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(64) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_64(precedence, allow_fallback)) - } else { - self.parse_generated_rule_64(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(64); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_64(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(128isize, 64); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 637, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 637) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(83, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(83, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 637, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(629isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(630isize); - let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(7, 635, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 11 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 33 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 635, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(630isize); + let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(7, 635, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 11 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 33 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 635, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 11 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 33 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 11 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 33 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 635, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(632isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + 2 => { + let __match = self.base.match_token_recovering(11, 636, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 3 => { + let __match = self.base.match_token_recovering(33, 636, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 635, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(632isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(11, 636, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __match = self.base.match_token_recovering(33, 636, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_65_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(65) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_65(precedence, allow_fallback)) - } else { - self.parse_generated_rule_65(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(65); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 65, GeneratedRuleError::Fatal; self.parse_generated_rule_65(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_65(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(130isize, 65); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_set_recovering(&[(9, 9), (12, 12)], 640, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 130isize, 65, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_set_recovering(&[(9, 9), (12, 12)], 640, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_66_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(66) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_66(precedence, allow_fallback)) - } else { - self.parse_generated_rule_66(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(66); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 66, GeneratedRuleError::Fatal; self.parse_generated_rule_66(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_66(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(132isize, 66); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(641isize); - let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_646 = false; - loop { - match self.base.sync_decision(atn(), 646, !__ctx.has_matched_child(), __loop_iter_646) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 70 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 36 | 48 | 53 | 55 | 62 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 646, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_646 = true; - let __match = self.base.match_token_recovering(70, 643, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(643isize); - let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 132isize, 66, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(641isize); + let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_646 = false; + loop { + match self.base.sync_decision(atn(), 646, !__ctx.has_matched_child(), __loop_iter_646) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { - break; + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 70 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 36 | 48 | 53 | 55 | 62 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 646, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_646 = true; + let __match = self.base.match_token_recovering(70, 643, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(643isize); + let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } diff --git a/crates/antlr-rust-rs-parser/src/generated/rust_lexer.rs b/crates/antlr-rust-rs-parser/src/generated/rust_lexer.rs index 5e26a118..faaeae32 100644 --- a/crates/antlr-rust-rs-parser/src/generated/rust_lexer.rs +++ b/crates/antlr-rust-rs-parser/src/generated/rust_lexer.rs @@ -1,6 +1,6 @@ // @generated by antlr-rust-codegen v0.28.0 - do not edit // project: https://github.com/ophi-dev/antlr-rust-runtime -antlr4_runtime::__antlr4_rust_require_codegen_api!(5, "0.28.0"); +antlr4_runtime::__antlr4_rust_require_codegen_api!(6, "0.28.0"); #[allow(warnings, missing_docs, clippy::all, clippy::pedantic, clippy::nursery)] #[rustfmt::skip] mod __antlr4_rust_generated { diff --git a/crates/antlr-rust-rs-parser/src/generated/rust_parser.rs b/crates/antlr-rust-rs-parser/src/generated/rust_parser.rs index 7f5c2a53..3986c71c 100644 --- a/crates/antlr-rust-rs-parser/src/generated/rust_parser.rs +++ b/crates/antlr-rust-rs-parser/src/generated/rust_parser.rs @@ -1,6 +1,6 @@ // @generated by antlr-rust-codegen v0.28.0 - do not edit // project: https://github.com/ophi-dev/antlr-rust-runtime -antlr4_runtime::__antlr4_rust_require_codegen_api!(5, "0.28.0"); +antlr4_runtime::__antlr4_rust_require_codegen_api!(6, "0.28.0"); #[allow(warnings, missing_docs, clippy::all, clippy::pedantic, clippy::nursery)] #[rustfmt::skip] mod __antlr4_rust_generated { @@ -15674,261 +15674,50 @@ where #[allow(dead_code)] fn parse_generated_rule_0_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(0) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_0(precedence, allow_fallback)) - } else { - self.parse_generated_rule_0(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(0); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 0, GeneratedRuleError::Fatal; self.parse_generated_rule_0(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_0(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(0isize, 0); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(430isize); - let __child = self.parse_generated_rule_1_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(-1, 432, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 0isize, 0, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(430isize); + let __child = self.parse_generated_rule_1_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(-1, 432, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_1_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(1) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_1(precedence, allow_fallback)) - } else { - self.parse_generated_rule_1(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(1); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 1, GeneratedRuleError::Fatal; self.parse_generated_rule_1(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_1(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(2isize, 1); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __loop_iter_436 = false; - loop { - match self.base.sync_decision(atn(), 436, !__ctx.has_matched_child(), __loop_iter_436) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 436) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(0, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(0, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 436, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_436 = true; - let __invoking_marker = self.base.push_invoking_state(433isize); - let __child = self.parse_generated_rule_67_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - let mut __loop_iter_442 = false; - loop { - match self.base.sync_decision(atn(), 442, !__ctx.has_matched_child(), __loop_iter_442) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 1..=2 | 5..=6 | 8..=9 | 11..=12 | 19..=22 | 26..=31 | 34 | 38..=42 | 47 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - -1 | 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 442, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_442 = true; - let __invoking_marker = self.base.push_invoking_state(439isize); - let __child = self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_2_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(2) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_2(precedence, allow_fallback)) - } else { - self.parse_generated_rule_2(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(2); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_2(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(4isize, 2); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 1 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 450, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 1 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 450, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(1, 447, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 447, !__ctx.has_matched_child(), false) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 2isize, 1, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __loop_iter_436 = false; + loop { + match self.base.sync_decision(atn(), 436, !__ctx.has_matched_child(), __loop_iter_436) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -15938,12 +15727,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 447) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 436) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(2, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(0, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -15953,7 +15742,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(2, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(0, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -15962,302 +15751,25 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 447, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 436, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(446isize); - let __child = self.parse_generated_rule_3_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_436 = true; + let __invoking_marker = self.base.push_invoking_state(433isize); + let __child = self.parse_generated_rule_67_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - 2 => { - let __match = self.base.match_token_recovering(2, 451, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_3_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(3) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_3(precedence, allow_fallback)) - } else { - self.parse_generated_rule_3(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(3); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_3(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(6isize, 3); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 466, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 466) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(4, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(4, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 466, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(3, 453, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(2, 454, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(4, 467, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __match = self.base.match_token_recovering(3, 456, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(5, 457, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(4, 467, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __match = self.base.match_token_recovering(3, 459, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(6, 460, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(4, 467, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 4 => { - let __match = self.base.match_token_recovering(3, 462, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(7, 463, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(463isize); - let __child = self.parse_generated_rule_79_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(4, 465, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_4_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(4) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_4(precedence, allow_fallback)) - } else { - self.parse_generated_rule_4(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(4); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_4(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(8isize, 4); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 1 | 11 | 19 | 22 | 26 | 28..=31 | 38..=39 | 42 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 34 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 5..=6 | 12 | 21 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 8 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 506, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 506) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(11, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(11, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 506, &__prediction); - match __prediction.alt { - 1 => { - let mut __loop_iter_471 = false; - loop { - match self.base.sync_decision(atn(), 471, !__ctx.has_matched_child(), __loop_iter_471) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 1..=2 | 9 | 11 | 19..=20 | 22 | 26..=31 | 38..=42 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 471, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_471 = true; - let __invoking_marker = self.base.push_invoking_state(468isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - match self.base.sync_decision(atn(), 475, !__ctx.has_matched_child(), false) { + let mut __loop_iter_442 = false; + loop { + match self.base.sync_decision(atn(), 442, !__ctx.has_matched_child(), __loop_iter_442) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -16268,33 +15780,53 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 1..=2 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 9 | 11 | 19..=20 | 22 | 26..=31 | 38..=42 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 1..=2 | 5..=6 | 8..=9 | 11..=12 | 19..=22 | 26..=31 | 34 | 38..=42 | 47 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + -1 | 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - self.base.record_generated_prediction_diagnostic(atn(), 475, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 442, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(474isize); - let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_442 = true; + let __invoking_marker = self.base.push_invoking_state(439isize); + let __child = self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __invoking_marker = self.base.push_invoking_state(477isize); - let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); } - 2 => { - let mut __loop_iter_481 = false; - loop { - match self.base.sync_decision(atn(), 481, !__ctx.has_matched_child(), __loop_iter_481) { + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_2_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 2, GeneratedRuleError::Fatal; self.parse_generated_rule_2(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_2(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 4isize, 2, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 450, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -16303,38 +15835,21 @@ where return Err(__error); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 20 | 27 | 34 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 481, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_481 = true; - let __invoking_marker = self.base.push_invoking_state(478isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 1 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __invoking_marker = self.base.push_invoking_state(484isize); - let __child = self.parse_generated_rule_62_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 3 => { - let mut __loop_iter_488 = false; - loop { - match self.base.sync_decision(atn(), 488, !__ctx.has_matched_child(), __loop_iter_488) { + }; + self.base.record_generated_prediction_diagnostic(atn(), 450, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(1, 447, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 447, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -16344,37 +15859,188 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 9 | 20 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 447) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(2, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(2, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } }; - self.base.record_generated_prediction_diagnostic(atn(), 488, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 447, &__prediction); match __prediction.alt { 1 => { - __loop_iter_488 = true; - let __invoking_marker = self.base.push_invoking_state(485isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(446isize); + let __child = self.parse_generated_rule_3_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __invoking_marker = self.base.push_invoking_state(491isize); - let __child = self.parse_generated_rule_15_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 2 => { + let __match = self.base.match_token_recovering(2, 451, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 4 => { - let mut __loop_iter_495 = false; - loop { - match self.base.sync_decision(atn(), 495, !__ctx.has_matched_child(), __loop_iter_495) { + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_3_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 3, GeneratedRuleError::Fatal; self.parse_generated_rule_3(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_3(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 6isize, 3, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 466, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 466) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(4, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(4, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 466, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(3, 453, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(2, 454, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(4, 467, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + let __match = self.base.match_token_recovering(3, 456, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(5, 457, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(4, 467, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 3 => { + let __match = self.base.match_token_recovering(3, 459, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(6, 460, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(4, 467, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 4 => { + let __match = self.base.match_token_recovering(3, 462, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(7, 463, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(463isize); + let __child = self.parse_generated_rule_79_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(4, 465, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_4_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 4, GeneratedRuleError::Fatal; self.parse_generated_rule_4(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_4(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 8isize, 4, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1 | 11 | 19 | 22 | 26 | 28..=31 | 38..=39 | 42 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 34 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 5..=6 | 12 | 21 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 8 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 506, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -16383,38 +16049,70 @@ where return Err(__error); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 5..=6 | 12 | 21 | 27 | 40..=41 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 495, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_495 = true; - let __invoking_marker = self.base.push_invoking_state(492isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 506) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(11, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(11, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __invoking_marker = self.base.push_invoking_state(498isize); - let __child = self.parse_generated_rule_200_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 5 => { - let mut __loop_iter_502 = false; - loop { - match self.base.sync_decision(atn(), 502, !__ctx.has_matched_child(), __loop_iter_502) { + }; + self.base.record_generated_prediction_diagnostic(atn(), 506, &__prediction); + match __prediction.alt { + 1 => { + let mut __loop_iter_471 = false; + loop { + match self.base.sync_decision(atn(), 471, !__ctx.has_matched_child(), __loop_iter_471) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 1..=2 | 9 | 11 | 19..=20 | 22 | 26..=31 | 38..=42 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 471, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_471 = true; + let __invoking_marker = self.base.push_invoking_state(468isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + match self.base.sync_decision(atn(), 475, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -16425,671 +16123,529 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 8 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 1..=2 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 9 | 11 | 19..=20 | 22 | 26..=31 | 38..=42 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 502, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 475, &__prediction); match __prediction.alt { 1 => { - __loop_iter_502 = true; - let __invoking_marker = self.base.push_invoking_state(499isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(474isize); + let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __invoking_marker = self.base.push_invoking_state(477isize); + let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(8, 507, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_5_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(5) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_5(precedence, allow_fallback)) - } else { - self.parse_generated_rule_5(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(5); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_5(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(10isize, 5); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 11 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 27 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 26 => antlr4_runtime::ParserAtnPrediction { alt: 10, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 38 => antlr4_runtime::ParserAtnPrediction { alt: 11, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 39 => antlr4_runtime::ParserAtnPrediction { alt: 12, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 40 => antlr4_runtime::ParserAtnPrediction { alt: 13, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 41 => antlr4_runtime::ParserAtnPrediction { alt: 14, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 29 => antlr4_runtime::ParserAtnPrediction { alt: 16, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 524, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + 2 => { + let mut __loop_iter_481 = false; + loop { + match self.base.sync_decision(atn(), 481, !__ctx.has_matched_child(), __loop_iter_481) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 20 | 27 | 34 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 481, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_481 = true; + let __invoking_marker = self.base.push_invoking_state(478isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } + let __invoking_marker = self.base.push_invoking_state(484isize); + let __child = self.parse_generated_rule_62_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 524) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(12, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(12, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + 3 => { + let mut __loop_iter_488 = false; + loop { + match self.base.sync_decision(atn(), 488, !__ctx.has_matched_child(), __loop_iter_488) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 9 | 20 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 488, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_488 = true; + let __invoking_marker = self.base.push_invoking_state(485isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } + let __invoking_marker = self.base.push_invoking_state(491isize); + let __child = self.parse_generated_rule_15_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + 4 => { + let mut __loop_iter_495 = false; + loop { + match self.base.sync_decision(atn(), 495, !__ctx.has_matched_child(), __loop_iter_495) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 5..=6 | 12 | 21 | 27 | 40..=41 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 495, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_495 = true; + let __invoking_marker = self.base.push_invoking_state(492isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __invoking_marker = self.base.push_invoking_state(498isize); + let __child = self.parse_generated_rule_200_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 5 => { + let mut __loop_iter_502 = false; + loop { + match self.base.sync_decision(atn(), 502, !__ctx.has_matched_child(), __loop_iter_502) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 8 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 502, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_502 = true; + let __invoking_marker = self.base.push_invoking_state(499isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __match = self.base.match_token_recovering(8, 507, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 524, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(508isize); - let __child = self.parse_generated_rule_6_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(509isize); - let __child = self.parse_generated_rule_7_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 3 => { - let __invoking_marker = self.base.push_invoking_state(510isize); - let __child = self.parse_generated_rule_13_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 4 => { - let __invoking_marker = self.base.push_invoking_state(511isize); - let __child = self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 5 => { - let __invoking_marker = self.base.push_invoking_state(512isize); - let __child = self.parse_generated_rule_18_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 6 => { - let __invoking_marker = self.base.push_invoking_state(513isize); - let __child = self.parse_generated_rule_20_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 7 => { - let __invoking_marker = self.base.push_invoking_state(514isize); - let __child = self.parse_generated_rule_21_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 8 => { - let __invoking_marker = self.base.push_invoking_state(515isize); - let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 9 => { - let __invoking_marker = self.base.push_invoking_state(516isize); - let __child = self.parse_generated_rule_22_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 10 => { - let __invoking_marker = self.base.push_invoking_state(517isize); - let __child = self.parse_generated_rule_41_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 11 => { - let __invoking_marker = self.base.push_invoking_state(518isize); - let __child = self.parse_generated_rule_42_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 12 => { - let __invoking_marker = self.base.push_invoking_state(519isize); - let __child = self.parse_generated_rule_48_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 13 => { - let __invoking_marker = self.base.push_invoking_state(520isize); - let __child = self.parse_generated_rule_56_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 14 => { - let __invoking_marker = self.base.push_invoking_state(521isize); - let __child = self.parse_generated_rule_57_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 15 => { - let __invoking_marker = self.base.push_invoking_state(522isize); - let __child = self.parse_generated_rule_58_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 16 => { - let __invoking_marker = self.base.push_invoking_state(523isize); - let __child = self.parse_generated_rule_26_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_5_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 5, GeneratedRuleError::Fatal; self.parse_generated_rule_5(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_5(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 10isize, 5, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 11 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 27 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 26 => antlr4_runtime::ParserAtnPrediction { alt: 10, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 38 => antlr4_runtime::ParserAtnPrediction { alt: 11, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 39 => antlr4_runtime::ParserAtnPrediction { alt: 12, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 40 => antlr4_runtime::ParserAtnPrediction { alt: 13, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 41 => antlr4_runtime::ParserAtnPrediction { alt: 14, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 29 => antlr4_runtime::ParserAtnPrediction { alt: 16, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 524, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 524) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(12, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(12, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 524, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(508isize); + let __child = self.parse_generated_rule_6_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(509isize); + let __child = self.parse_generated_rule_7_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 3 => { + let __invoking_marker = self.base.push_invoking_state(510isize); + let __child = self.parse_generated_rule_13_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 4 => { + let __invoking_marker = self.base.push_invoking_state(511isize); + let __child = self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 5 => { + let __invoking_marker = self.base.push_invoking_state(512isize); + let __child = self.parse_generated_rule_18_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 6 => { + let __invoking_marker = self.base.push_invoking_state(513isize); + let __child = self.parse_generated_rule_20_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 7 => { + let __invoking_marker = self.base.push_invoking_state(514isize); + let __child = self.parse_generated_rule_21_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 8 => { + let __invoking_marker = self.base.push_invoking_state(515isize); + let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 9 => { + let __invoking_marker = self.base.push_invoking_state(516isize); + let __child = self.parse_generated_rule_22_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 10 => { + let __invoking_marker = self.base.push_invoking_state(517isize); + let __child = self.parse_generated_rule_41_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 11 => { + let __invoking_marker = self.base.push_invoking_state(518isize); + let __child = self.parse_generated_rule_42_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 12 => { + let __invoking_marker = self.base.push_invoking_state(519isize); + let __child = self.parse_generated_rule_48_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 13 => { + let __invoking_marker = self.base.push_invoking_state(520isize); + let __child = self.parse_generated_rule_56_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 14 => { + let __invoking_marker = self.base.push_invoking_state(521isize); + let __child = self.parse_generated_rule_57_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 15 => { + let __invoking_marker = self.base.push_invoking_state(522isize); + let __child = self.parse_generated_rule_58_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 16 => { + let __invoking_marker = self.base.push_invoking_state(523isize); + let __child = self.parse_generated_rule_26_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_6_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(6) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_6(precedence, allow_fallback)) - } else { - self.parse_generated_rule_6(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(6); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 6, GeneratedRuleError::Fatal; self.parse_generated_rule_6(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_6(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(12isize, 6); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(9, 527, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(2, 530, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 5 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 530, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 12isize, 6, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(9, 527, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(2, 530, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 5 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 530, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 5 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 5 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 530, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(528isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + 2 => { + let __match = self.base.match_token_recovering(5, 531, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 530, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(528isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(5, 531, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 533, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 17 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 533, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(532isize); - let __child = self.parse_generated_rule_12_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 533, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 17 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 533, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(532isize); + let __child = self.parse_generated_rule_12_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(10, 536, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __match = self.base.match_token_recovering(10, 536, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_7_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(7) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_7(precedence, allow_fallback)) - } else { - self.parse_generated_rule_7(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(7); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 7, GeneratedRuleError::Fatal; self.parse_generated_rule_7(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_7(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(14isize, 7); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(11, 538, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(538isize); - let __child = self.parse_generated_rule_8_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(10, 540, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 14isize, 7, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(11, 538, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(538isize); + let __child = self.parse_generated_rule_8_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(10, 540, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_8_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(8) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_8(precedence, allow_fallback)) - } else { - self.parse_generated_rule_8(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(8); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 8, GeneratedRuleError::Fatal; self.parse_generated_rule_8(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_8(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(16isize, 8); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 13 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 5..=6 | 15 | 21..=22 | 27 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 566, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 566) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(21, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(21, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 566, &__prediction); - match __prediction.alt { - 1 => { - match self.base.sync_decision(atn(), 542, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 542, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(12, 543, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(13, 546, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 546, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2 | 5..=6 | 12..=13 | 15 | 21..=22 | 27 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 546, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(545isize); - let __child = self.parse_generated_rule_11_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(14, 567, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - match self.base.sync_decision(atn(), 550, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 5..=6 | 15 | 21..=22 | 27 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 550, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(12, 551, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2 | 5..=6 | 21..=22 | 27 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 15 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 554, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 2 | 5..=6 | 21..=22 | 27 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 15 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 554, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(552isize); - let __child = self.parse_generated_rule_197_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(15, 555, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let mut __loop_iter_560 = false; - loop { - match self.base.sync_decision(atn(), 560, !__ctx.has_matched_child(), __loop_iter_560) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 16isize, 8, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 13 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 5..=6 | 15 | 21..=22 | 27 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 566, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -17098,13 +16654,13 @@ where return Err(__error); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 560) { + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 566) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(19, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(21, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -17114,7 +16670,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(19, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(21, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -17122,287 +16678,503 @@ where } else { __prediction } + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 566, &__prediction); + match __prediction.alt { + 1 => { + match self.base.sync_decision(atn(), 542, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 560, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 542, &__prediction); match __prediction.alt { 1 => { - __loop_iter_560 = true; - let __match = self.base.match_token_recovering(12, 557, atn())?; + let __match = self.base.match_token_recovering(12, 543, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(557isize); - let __child = self.parse_generated_rule_197_dispatch(0, false).map_err(GeneratedRuleError::into_error); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(13, 546, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 546, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2 | 5..=6 | 12..=13 | 15 | 21..=22 | 27 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 546, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(545isize); + let __child = self.parse_generated_rule_11_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(14, 567, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - match self.base.sync_decision(atn(), 564, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + 2 => { + match self.base.sync_decision(atn(), 550, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 564) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(20, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 5..=6 | 15 | 21..=22 | 27 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(20, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + self.base.record_generated_prediction_diagnostic(atn(), 550, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(12, 551, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 564, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(563isize); - let __child = self.parse_generated_rule_9_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2 | 5..=6 | 21..=22 | 27 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 15 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 554, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 2 | 5..=6 | 21..=22 | 27 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 15 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 554, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(552isize); + let __child = self.parse_generated_rule_197_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __match = self.base.match_token_recovering(15, 555, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => { + let mut __loop_iter_560 = false; + loop { + match self.base.sync_decision(atn(), 560, !__ctx.has_matched_child(), __loop_iter_560) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 560) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(19, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(19, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 560, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_560 = true; + let __match = self.base.match_token_recovering(12, 557, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(557isize); + let __child = self.parse_generated_rule_197_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + match self.base.sync_decision(atn(), 564, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 564) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(20, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(20, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 564, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(563isize); + let __child = self.parse_generated_rule_9_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_9_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(9) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_9(precedence, allow_fallback)) - } else { - self.parse_generated_rule_9(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(9); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 9, GeneratedRuleError::Fatal; self.parse_generated_rule_9(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_9(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(18isize, 9); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 17 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 577, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 18isize, 9, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 17 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 577, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 577) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(23, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(23, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 577) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(23, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + }; + self.base.record_generated_prediction_diagnostic(atn(), 577, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(12, 569, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(15, 578, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + let __match = self.base.match_token_recovering(12, 571, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(13, 573, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 573, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2 | 5..=6 | 12..=13 | 15 | 21..=22 | 27 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(23, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + self.base.record_generated_prediction_diagnostic(atn(), 573, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(572isize); + let __child = self.parse_generated_rule_11_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(14, 578, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + 3 => { + let __invoking_marker = self.base.push_invoking_state(576isize); + let __child = self.parse_generated_rule_12_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 577, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(12, 569, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(15, 578, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __match = self.base.match_token_recovering(12, 571, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(13, 573, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 573, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_10_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 10, GeneratedRuleError::Fatal; self.parse_generated_rule_10(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_10(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 20isize, 10, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 12..=13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 582, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 582) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(24, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(24, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2 | 5..=6 | 12..=13 | 15 | 21..=22 | 27 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 573, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(572isize); - let __child = self.parse_generated_rule_11_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 582, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(579isize); + let __child = self.parse_generated_rule_197_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(580isize); + let __child = self.parse_generated_rule_8_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 3 => { + let __match = self.base.match_token_recovering(15, 583, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __match = self.base.match_token_recovering(14, 578, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 3 => { - let __invoking_marker = self.base.push_invoking_state(576isize); - let __child = self.parse_generated_rule_12_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 585, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 17 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 | 16 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 585, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(584isize); + let __child = self.parse_generated_rule_12_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_10_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_11_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(10) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_10(precedence, allow_fallback)) - } else { - self.parse_generated_rule_10(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(10); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 11, GeneratedRuleError::Fatal; self.parse_generated_rule_11(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_10(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_11(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(20isize, 10); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 12..=13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 582, !__ctx.has_matched_child(), false) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 22isize, 11, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(587isize); + let __child = self.parse_generated_rule_10_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_592 = false; + loop { + match self.base.sync_decision(atn(), 592, !__ctx.has_matched_child(), __loop_iter_592) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -17411,13 +17183,13 @@ where return Err(__error); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 582) { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 592) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(24, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(26, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -17427,7 +17199,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(24, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(26, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -17435,122 +17207,27 @@ where } else { __prediction } + }; + self.base.record_generated_prediction_diagnostic(atn(), 592, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_592 = true; + let __match = self.base.match_token_recovering(16, 589, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(589isize); + let __child = self.parse_generated_rule_10_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 582, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(579isize); - let __child = self.parse_generated_rule_197_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(580isize); - let __child = self.parse_generated_rule_8_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 3 => { - let __match = self.base.match_token_recovering(15, 583, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 585, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 17 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 | 16 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 585, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(584isize); - let __child = self.parse_generated_rule_12_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_11_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(11) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_11(precedence, allow_fallback)) - } else { - self.parse_generated_rule_11(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(11); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_11(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(22isize, 11); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(587isize); - let __child = self.parse_generated_rule_10_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_592 = false; - loop { - match self.base.sync_decision(atn(), 592, !__ctx.has_matched_child(), __loop_iter_592) { + match self.base.sync_decision(atn(), 596, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -17560,451 +17237,178 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 592) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(26, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(26, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - self.base.record_generated_prediction_diagnostic(atn(), 592, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 596, &__prediction); match __prediction.alt { 1 => { - __loop_iter_592 = true; - let __match = self.base.match_token_recovering(16, 589, atn())?; + let __match = self.base.match_token_recovering(16, 597, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(589isize); - let __child = self.parse_generated_rule_10_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - match self.base.sync_decision(atn(), 596, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 596, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 597, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_12_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(12) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_12(precedence, allow_fallback)) - } else { - self.parse_generated_rule_12(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(12); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 12, GeneratedRuleError::Fatal; self.parse_generated_rule_12(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_12(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(24isize, 12); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(17, 601, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 18 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 601, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 24isize, 12, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(17, 601, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 18 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 601, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 18 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 18 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 601, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(599isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + 2 => { + let __match = self.base.match_token_recovering(18, 602, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 601, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(599isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(18, 602, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_13_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(13) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_13(precedence, allow_fallback)) - } else { - self.parse_generated_rule_13(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(13); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 13, GeneratedRuleError::Fatal; self.parse_generated_rule_13(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_13(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(26isize, 13); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(19, 604, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(604isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(10, 606, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 26isize, 13, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(19, 604, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(604isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(10, 606, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_14_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(14) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_14(precedence, allow_fallback)) - } else { - self.parse_generated_rule_14(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(14); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 14, GeneratedRuleError::Fatal; self.parse_generated_rule_14(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_14(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(28isize, 14); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(19, 608, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(608isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(13, 610, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(610isize); - let __child = self.parse_generated_rule_1_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(14, 612, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 28isize, 14, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(19, 608, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(608isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(13, 610, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(610isize); + let __child = self.parse_generated_rule_1_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(14, 612, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_15_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(15) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_15(precedence, allow_fallback)) - } else { - self.parse_generated_rule_15(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(15); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 15, GeneratedRuleError::Fatal; self.parse_generated_rule_15(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_15(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(30isize, 15); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 614, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 20 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 9 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 614, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(20, 615, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(616isize); - let __child = self.parse_generated_rule_114_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(13, 621, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_621 = false; - loop { - match self.base.sync_decision(atn(), 621, !__ctx.has_matched_child(), __loop_iter_621) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 621) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(30, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(30, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 621, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_621 = true; - let __invoking_marker = self.base.push_invoking_state(618isize); - let __child = self.parse_generated_rule_67_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - let mut __loop_iter_627 = false; - loop { - match self.base.sync_decision(atn(), 627, !__ctx.has_matched_child(), __loop_iter_627) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 30isize, 15, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 614, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -18015,89 +17419,32 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 1..=2 | 5..=6 | 9 | 12 | 20..=22 | 26..=28 | 30..=31 | 40..=41 | 47 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 20 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 9 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 627, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 614, &__prediction); match __prediction.alt { 1 => { - __loop_iter_627 = true; - let __invoking_marker = self.base.push_invoking_state(624isize); - let __child = self.parse_generated_rule_16_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(20, 615, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - let __match = self.base.match_token_recovering(14, 631, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_16_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(16) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_16(precedence, allow_fallback)) - } else { - self.parse_generated_rule_16(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(16); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_16(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(32isize, 16); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 1 | 9 | 20 | 22 | 26 | 28 | 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 5..=6 | 12 | 27 | 40..=41 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 649, !__ctx.has_matched_child(), false) { + let __invoking_marker = self.base.push_invoking_state(616isize); + let __child = self.parse_generated_rule_114_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(13, 621, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_621 = false; + loop { + match self.base.sync_decision(atn(), 621, !__ctx.has_matched_child(), __loop_iter_621) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -18106,13 +17453,13 @@ where return Err(__error); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 649) { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 621) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(35, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(30, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -18122,7 +17469,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(35, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(30, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -18130,46 +17477,26 @@ where } else { __prediction } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 649, &__prediction); - match __prediction.alt { - 1 => { - let mut __loop_iter_635 = false; - loop { - match self.base.sync_decision(atn(), 635, !__ctx.has_matched_child(), __loop_iter_635) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + }; + self.base.record_generated_prediction_diagnostic(atn(), 621, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_621 = true; + let __invoking_marker = self.base.push_invoking_state(618isize); + let __child = self.parse_generated_rule_67_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 1..=2 | 9 | 20..=22 | 26 | 28 | 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 635, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_635 = true; - let __invoking_marker = self.base.push_invoking_state(632isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 2 => { + break; } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - match self.base.sync_decision(atn(), 639, !__ctx.has_matched_child(), false) { + } + let mut __loop_iter_627 = false; + loop { + match self.base.sync_decision(atn(), 627, !__ctx.has_matched_child(), __loop_iter_627) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -18180,33 +17507,128 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 1..=2 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 9 | 20..=22 | 26 | 28 | 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 1..=2 | 5..=6 | 9 | 12 | 20..=22 | 26..=28 | 30..=31 | 40..=41 | 47 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 639, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 627, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(638isize); - let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_627 = true; + let __invoking_marker = self.base.push_invoking_state(624isize); + let __child = self.parse_generated_rule_16_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __invoking_marker = self.base.push_invoking_state(641isize); - let __child = self.parse_generated_rule_17_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); } - 2 => { - let mut __loop_iter_645 = false; - loop { - match self.base.sync_decision(atn(), 645, !__ctx.has_matched_child(), __loop_iter_645) { + let __match = self.base.match_token_recovering(14, 631, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_16_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 16, GeneratedRuleError::Fatal; self.parse_generated_rule_16(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_16(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 32isize, 16, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1 | 9 | 20 | 22 | 26 | 28 | 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 5..=6 | 12 | 27 | 40..=41 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 649, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 649) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(35, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(35, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 649, &__prediction); + match __prediction.alt { + 1 => { + let mut __loop_iter_635 = false; + loop { + match self.base.sync_decision(atn(), 635, !__ctx.has_matched_child(), __loop_iter_635) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 1..=2 | 9 | 20..=22 | 26 | 28 | 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 635, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_635 = true; + let __invoking_marker = self.base.push_invoking_state(632isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + match self.base.sync_decision(atn(), 639, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -18217,1817 +17639,1224 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 5..=6 | 12 | 21 | 27 | 40..=41 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 1..=2 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 9 | 20..=22 | 26 | 28 | 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 645, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 639, &__prediction); match __prediction.alt { 1 => { - __loop_iter_645 = true; - let __invoking_marker = self.base.push_invoking_state(642isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(638isize); + let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __invoking_marker = self.base.push_invoking_state(641isize); + let __child = self.parse_generated_rule_17_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let mut __loop_iter_645 = false; + loop { + match self.base.sync_decision(atn(), 645, !__ctx.has_matched_child(), __loop_iter_645) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 5..=6 | 12 | 21 | 27 | 40..=41 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 645, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_645 = true; + let __invoking_marker = self.base.push_invoking_state(642isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __invoking_marker = self.base.push_invoking_state(648isize); + let __child = self.parse_generated_rule_212_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(648isize); - let __child = self.parse_generated_rule_212_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_17_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(17) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_17(precedence, allow_fallback)) - } else { - self.parse_generated_rule_17(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(17); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 17, GeneratedRuleError::Fatal; self.parse_generated_rule_17(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_17(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(34isize, 17); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 22 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 26 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 9 | 28 | 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 689, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 34isize, 17, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 22 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 26 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 9 | 28 | 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 689, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 689) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(44, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(44, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 689) { __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(44, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(44, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 689, &__prediction); - match __prediction.alt { - 1 => { - match self.base.sync_decision(atn(), 652, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + }; + self.base.record_generated_prediction_diagnostic(atn(), 689, &__prediction); + match __prediction.alt { + 1 => { + match self.base.sync_decision(atn(), 652, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 20..=21 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 22 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 652, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_set_recovering(&[(20, 21)], 653, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 20..=21 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 22 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 652, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_set_recovering(&[(20, 21)], 653, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(22, 656, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 656, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 656, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(23, 657, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(22, 656, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 656, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(658isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(24, 660, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(660isize); + let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 663, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 25 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 663, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(25, 662, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(662isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(10, 666, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 656, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(23, 657, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { + 2 => { + let __match = self.base.match_token_recovering(26, 668, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(668isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 670, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(658isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(24, 660, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(660isize); - let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 663, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 | 24..=25 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 670, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(669isize); + let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + match self.base.sync_decision(atn(), 673, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 25 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 663, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(25, 662, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(662isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 673) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(40, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(40, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 673, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(672isize); + let __child = self.parse_generated_rule_94_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => { + match self.base.sync_decision(atn(), 676, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(10, 666, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __match = self.base.match_token_recovering(26, 668, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(668isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 670, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 | 24..=25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 676, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(675isize); + let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + match self.base.sync_decision(atn(), 680, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 | 24..=25 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 670, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(669isize); - let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 | 25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 680, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(24, 679, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(679isize); + let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => { + match self.base.sync_decision(atn(), 684, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 673, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 673) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(40, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 25 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(40, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 673, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(672isize); - let __child = self.parse_generated_rule_94_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 676, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 | 24..=25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 676, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(675isize); - let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 680, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 | 25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 680, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(24, 679, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(679isize); - let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 684, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + self.base.record_generated_prediction_diagnostic(atn(), 684, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(25, 683, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(683isize); + let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(10, 687, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 25 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 684, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(25, 683, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(683isize); - let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 3 => { + let __invoking_marker = self.base.push_invoking_state(688isize); + let __child = self.parse_generated_rule_25_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(10, 687, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __invoking_marker = self.base.push_invoking_state(688isize); - let __child = self.parse_generated_rule_25_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_18_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(18) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_18(precedence, allow_fallback)) - } else { - self.parse_generated_rule_18(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(18); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 18, GeneratedRuleError::Fatal; self.parse_generated_rule_18(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_18(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(36isize, 18); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(22, 693, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 693, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 693, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(23, 694, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 36isize, 18, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(22, 693, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 693, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 693, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(23, 694, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(695isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(24, 697, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(697isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(25, 699, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(699isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(10, 701, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + let __invoking_marker = self.base.push_invoking_state(695isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(24, 697, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(697isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(25, 699, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(699isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(10, 701, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_19_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(19) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_19(precedence, allow_fallback)) - } else { - self.parse_generated_rule_19(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(19); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 19, GeneratedRuleError::Fatal; self.parse_generated_rule_19(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_19(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(38isize, 19); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(22, 704, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 704, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 704, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(23, 705, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 38isize, 19, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(22, 704, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 704, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 704, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(23, 705, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(706isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(24, 708, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(708isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(10, 710, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __invoking_marker = self.base.push_invoking_state(706isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(24, 708, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(708isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(10, 710, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_20_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(20) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_20(precedence, allow_fallback)) - } else { - self.parse_generated_rule_20(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(20); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 20, GeneratedRuleError::Fatal; self.parse_generated_rule_20(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_20(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(40isize, 20); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 712, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 27 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 28 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 712, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(27, 713, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 40isize, 20, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 712, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 27 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 28 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 712, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(27, 713, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(28, 717, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 18 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 717, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(28, 717, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 18 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 717, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 18 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 18 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 717, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(715isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + 2 => { + let __match = self.base.match_token_recovering(18, 718, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 717, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(715isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(18, 718, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(24, 720, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(720isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(25, 722, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(722isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(10, 724, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __match = self.base.match_token_recovering(24, 720, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(720isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(25, 722, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(722isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(10, 724, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_21_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(21) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_21(precedence, allow_fallback)) - } else { - self.parse_generated_rule_21(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(21); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 21, GeneratedRuleError::Fatal; self.parse_generated_rule_21(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_21(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(42isize, 21); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(28, 726, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(726isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 729, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 729, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(24, 728, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(728isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 42isize, 21, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(28, 726, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(726isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 729, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 729, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(24, 728, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(728isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(10, 732, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __match = self.base.match_token_recovering(10, 732, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_22_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(22) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_22(precedence, allow_fallback)) - } else { - self.parse_generated_rule_22(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(22); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 22, GeneratedRuleError::Fatal; self.parse_generated_rule_22(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_22(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(44isize, 22); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(733isize); - let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(3, 736, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 736, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 44isize, 22, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(733isize); + let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(3, 736, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 736, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 736) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(50, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(50, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 736) { __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(50, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(50, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 736, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(735isize); + let __child = self.parse_generated_rule_31_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 736, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(735isize); - let __child = self.parse_generated_rule_31_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(4, 740, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 740, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 37 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 | 13 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 740, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(739isize); - let __child = self.parse_generated_rule_40_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 743, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(4, 740, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 740, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 37 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 | 13 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 740, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(739isize); + let __child = self.parse_generated_rule_40_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 | 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 743, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(742isize); - let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 743, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 | 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 743, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(742isize); + let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 13 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 747, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 13 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 747, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 13 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 13 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 747, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(745isize); + let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + 2 => { + let __match = self.base.match_token_recovering(10, 748, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 747, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(745isize); - let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(10, 748, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_23_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(23) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_23(precedence, allow_fallback)) - } else { - self.parse_generated_rule_23(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(23); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 23, GeneratedRuleError::Fatal; self.parse_generated_rule_23(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_23(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(46isize, 23); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(749isize); - let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(3, 752, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 752, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 46isize, 23, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(749isize); + let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(3, 752, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 752, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 752) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(54, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(54, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 752) { __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 752, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(751isize); - let __child = self.parse_generated_rule_35_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(4, 756, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 756, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 37 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 | 13 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 756, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(755isize); - let __child = self.parse_generated_rule_40_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 759, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 | 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 759, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(758isize); - let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 13 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 763, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(54, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(54, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 13 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 752, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(751isize); + let __child = self.parse_generated_rule_35_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 763, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(761isize); - let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(10, 764, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(4, 756, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 756, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_24_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(24) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_24(precedence, allow_fallback)) - } else { - self.parse_generated_rule_24(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(24); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_24(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(48isize, 24); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(765isize); - let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(3, 768, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 768, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 768) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(58, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 37 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 | 13 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(58, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 768, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(767isize); - let __child = self.parse_generated_rule_38_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(4, 772, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 772, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 37 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 | 13 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 772, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(771isize); - let __child = self.parse_generated_rule_39_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 775, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + self.base.record_generated_prediction_diagnostic(atn(), 756, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(755isize); + let __child = self.parse_generated_rule_40_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 | 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 775, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(774isize); - let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 759, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 | 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 759, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(758isize); + let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 13 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 779, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 13 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 763, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 13 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 13 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 763, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(761isize); + let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + 2 => { + let __match = self.base.match_token_recovering(10, 764, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 779, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(777isize); - let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(10, 780, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_25_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_24_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(25) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_25(precedence, allow_fallback)) - } else { - self.parse_generated_rule_25(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(25); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 24, GeneratedRuleError::Fatal; self.parse_generated_rule_24(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_25(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_24(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(50isize, 25); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 782, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 21 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 9 | 20 | 28 | 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 782, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(21, 783, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(784isize); - let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(3, 787, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 787, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 48isize, 24, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(765isize); + let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(3, 768, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 768, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 787) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(63, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(63, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 768) { __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 787, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(786isize); - let __child = self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(4, 791, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 791, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 37 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 | 13 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 791, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(790isize); - let __child = self.parse_generated_rule_39_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 794, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 | 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 794, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(793isize); - let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 13 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 798, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(58, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(58, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 13 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 768, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(767isize); + let __child = self.parse_generated_rule_38_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 798, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(796isize); - let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(4, 772, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 772, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { - let __match = self.base.match_token_recovering(10, 799, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 37 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 | 13 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 772, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(771isize); + let __child = self.parse_generated_rule_39_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_26_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(26) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_26(precedence, allow_fallback)) - } else { - self.parse_generated_rule_26(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(26); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_26(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(52isize, 26); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(800isize); - let __child = self.parse_generated_rule_27_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 809, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + match self.base.sync_decision(atn(), 775, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 809) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(68, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 | 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(68, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + self.base.record_generated_prediction_diagnostic(atn(), 775, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(774isize); + let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 809, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(3, 805, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_805 = false; - loop { - match self.base.sync_decision(atn(), 805, !__ctx.has_matched_child(), __loop_iter_805) { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 13 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 779, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -20036,301 +18865,52 @@ where return Err(__error); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 805, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_805 = true; - let __invoking_marker = self.base.push_invoking_state(802isize); - let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 13 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __match = self.base.match_token_recovering(4, 810, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 812, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 812) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(69, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(69, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 812, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(811isize); - let __child = self.parse_generated_rule_40_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 815, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 815) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(70, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(70, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 815, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(814isize); - let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(817isize); - let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_27_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(27) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_27(precedence, allow_fallback)) - } else { - self.parse_generated_rule_27(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(27); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_27(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(54isize, 27); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(29, 820, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(820isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 822, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 822) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(71, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(71, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 822, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(821isize); - let __child = self.parse_generated_rule_122_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { + self.base.record_generated_prediction_diagnostic(atn(), 779, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(777isize); + let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __match = self.base.match_token_recovering(10, 780, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_28_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_25_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(28) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_28(precedence, allow_fallback)) - } else { - self.parse_generated_rule_28(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(28); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 25, GeneratedRuleError::Fatal; self.parse_generated_rule_25(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_28(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_25(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(56isize, 28); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __loop_iter_827 = false; - loop { - match self.base.sync_decision(atn(), 827, !__ctx.has_matched_child(), __loop_iter_827) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 50isize, 25, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 782, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -20341,731 +18921,281 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 20 | 28 | 30 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 9 | 31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 21 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 9 | 20 | 28 | 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 827, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 782, &__prediction); match __prediction.alt { 1 => { - __loop_iter_827 = true; - let __match = self.base.match_set_recovering(&[(20, 20), (28, 28), (30, 30)], 826, atn())?; + let __match = self.base.match_token_recovering(21, 783, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - match self.base.sync_decision(atn(), 831, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(784isize); + let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(3, 787, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 787, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 787) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(63, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(63, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 787, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(786isize); + let __child = self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 9 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 831, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(830isize); - let __child = self.parse_generated_rule_114_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(4, 791, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 791, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 37 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 | 13 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 791, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(790isize); + let __child = self.parse_generated_rule_39_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(31, 834, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(834isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 836, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + match self.base.sync_decision(atn(), 794, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 3 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 836, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(835isize); - let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 | 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 794, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(793isize); + let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 13 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 798, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 13 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 798, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(796isize); + let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __match = self.base.match_token_recovering(10, 799, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_29_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_26_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(29) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_29(precedence, allow_fallback)) - } else { - self.parse_generated_rule_29(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(29); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 26, GeneratedRuleError::Fatal; self.parse_generated_rule_26(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_29(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_26(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(58isize, 29); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 1..=4 | 6..=22 | 24..=27 | 29..=31 | 34..=46 | 48..=98 | 101..=102 | 104..=117 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 883, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 52isize, 26, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(800isize); + let __child = self.parse_generated_rule_27_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 809, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 883) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(85, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(85, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 883, &__prediction); - match __prediction.alt { - 1 => { - let mut __loop_iter_841 = false; - loop { - match self.base.sync_decision(atn(), 841, !__ctx.has_matched_child(), __loop_iter_841) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 32 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 841, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_841 = true; - let __invoking_marker = self.base.push_invoking_state(838isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - let __match = self.base.match_token_recovering(32, 884, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let mut __loop_iter_848 = false; - loop { - match self.base.sync_decision(atn(), 848, !__ctx.has_matched_child(), __loop_iter_848) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 848) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(76, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(76, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 848, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_848 = true; - let __invoking_marker = self.base.push_invoking_state(845isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - match self.base.sync_decision(atn(), 852, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 852) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(77, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(77, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 809) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(68, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? }; - self.base.record_generated_prediction_diagnostic(atn(), 852, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(851isize); - let __child = self.parse_generated_rule_113_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 855, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 855) { - __prediction + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(68, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(78, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(78, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 855, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_not_set_recovering(&[(-1, -1)], 1, atn().max_token_type(), 856, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(857isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(24, 861, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 861, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2..=6 | 9 | 11..=13 | 15..=16 | 18 | 20..=21 | 27 | 31 | 33..=34 | 36 | 40..=41 | 43..=45 | 48 | 50 | 52..=55 | 57 | 69 | 98..=100 | 102..=104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 32 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 861, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(859isize); - let __child = self.parse_generated_rule_30_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(32, 862, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + __prediction } - } - 3 => { - let mut __loop_iter_866 = false; - loop { - match self.base.sync_decision(atn(), 866, !__ctx.has_matched_child(), __loop_iter_866) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 5 | 23 | 28 | 33 | 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 866, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_866 = true; - let __invoking_marker = self.base.push_invoking_state(863isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + }; + self.base.record_generated_prediction_diagnostic(atn(), 809, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(3, 805, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_805 = false; + loop { + match self.base.sync_decision(atn(), 805, !__ctx.has_matched_child(), __loop_iter_805) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { - break; + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 805, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_805 = true; + let __invoking_marker = self.base.push_invoking_state(802isize); + let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - match self.base.sync_decision(atn(), 870, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 33 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 5 | 23 | 28 | 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 870, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(33, 871, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 873, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 5 | 23 | 28 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 873, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(872isize); - let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 876, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 23 | 28 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 5 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 876, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(875isize); - let __child = self.parse_generated_rule_113_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(5, 881, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 881, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); } + let __match = self.base.match_token_recovering(4, 810, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 16 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 881, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(24, 880, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(880isize); - let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 2 => { } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_30_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(30) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_30(precedence, allow_fallback)) - } else { - self.parse_generated_rule_30(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(30); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_30(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(60isize, 30); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 888, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 888) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(86, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(86, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 888, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(885isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(34, 887, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(887isize); - let __child = self.parse_generated_rule_95_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_31_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(31) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_31(precedence, allow_fallback)) - } else { - self.parse_generated_rule_31(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(31); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_31(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(62isize, 31); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(890isize); - let __child = self.parse_generated_rule_29_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_895 = false; - loop { - match self.base.sync_decision(atn(), 895, !__ctx.has_matched_child(), __loop_iter_895) { + match self.base.sync_decision(atn(), 812, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -21075,12 +19205,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 895) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 812) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(87, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(69, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -21090,7 +19220,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(87, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(69, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -21099,207 +19229,20 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 895, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 812, &__prediction); match __prediction.alt { 1 => { - __loop_iter_895 = true; - let __match = self.base.match_token_recovering(16, 892, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(892isize); - let __child = self.parse_generated_rule_29_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(811isize); + let __child = self.parse_generated_rule_40_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - match self.base.sync_decision(atn(), 910, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 910) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(89, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(89, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 910, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 902, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_902 = false; - loop { - match self.base.sync_decision(atn(), 902, !__ctx.has_matched_child(), __loop_iter_902) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=6 | 12 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 46 | 48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 902, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_902 = true; - let __invoking_marker = self.base.push_invoking_state(899isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - let __invoking_marker = self.base.push_invoking_state(905isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __invoking_marker = self.base.push_invoking_state(906isize); - let __child = self.parse_generated_rule_113_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(24, 908, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(32, 909, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 913, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 913, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 914, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_32_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(32) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_32(precedence, allow_fallback)) - } else { - self.parse_generated_rule_32(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(32); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_32(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(64isize, 32); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(915isize); - let __child = self.parse_generated_rule_29_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_920 = false; - loop { - match self.base.sync_decision(atn(), 920, !__ctx.has_matched_child(), __loop_iter_920) { + match self.base.sync_decision(atn(), 815, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -21309,12 +19252,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 920) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 815) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(91, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(70, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -21324,7 +19267,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(91, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(70, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -21333,194 +19276,54 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 920, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 815, &__prediction); match __prediction.alt { 1 => { - __loop_iter_920 = true; - let __match = self.base.match_token_recovering(16, 917, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(917isize); - let __child = self.parse_generated_rule_29_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(814isize); + let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __invoking_marker = self.base.push_invoking_state(817isize); + let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 931, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 931) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(93, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(93, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 931, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 927, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_927 = false; - loop { - match self.base.sync_decision(atn(), 927, !__ctx.has_matched_child(), __loop_iter_927) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 32 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 927, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_927 = true; - let __invoking_marker = self.base.push_invoking_state(924isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - let __match = self.base.match_token_recovering(32, 932, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 934, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 934, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 935, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_33_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_27_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(33) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_33(precedence, allow_fallback)) - } else { - self.parse_generated_rule_33(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(33); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 27, GeneratedRuleError::Fatal; self.parse_generated_rule_27(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_33(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_27(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(66isize, 33); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(936isize); - let __child = self.parse_generated_rule_36_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_941 = false; - loop { - match self.base.sync_decision(atn(), 941, !__ctx.has_matched_child(), __loop_iter_941) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 54isize, 27, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(29, 820, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(820isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 822, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -21530,12 +19333,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 941) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 822) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(95, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(71, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -21545,7 +19348,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(95, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(71, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -21554,212 +19357,43 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 941, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 822, &__prediction); match __prediction.alt { 1 => { - __loop_iter_941 = true; - let __match = self.base.match_token_recovering(16, 938, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(938isize); - let __child = self.parse_generated_rule_36_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(821isize); + let __child = self.parse_generated_rule_122_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - match self.base.sync_decision(atn(), 952, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 952) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(97, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(97, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 952, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 948, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_948 = false; - loop { - match self.base.sync_decision(atn(), 948, !__ctx.has_matched_child(), __loop_iter_948) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 32 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 948, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_948 = true; - let __invoking_marker = self.base.push_invoking_state(945isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - let __match = self.base.match_token_recovering(32, 953, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 955, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 955, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 956, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_34_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_28_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(34) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_34(precedence, allow_fallback)) - } else { - self.parse_generated_rule_34(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(34); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 28, GeneratedRuleError::Fatal; self.parse_generated_rule_28(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_34(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_28(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(68isize, 34); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 5 | 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 33 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 973, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 5 | 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 33 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 973, &__prediction); - match __prediction.alt { - 1 => { - match self.base.sync_decision(atn(), 958, !__ctx.has_matched_child(), false) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 56isize, 28, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __loop_iter_827 = false; + loop { + match self.base.sync_decision(atn(), 827, !__ctx.has_matched_child(), __loop_iter_827) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -21770,235 +19404,61 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 5 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 958, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(23, 959, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } + 20 | 28 | 30 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 9 | 31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(5, 963, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 963, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 16 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - self.base.record_generated_prediction_diagnostic(atn(), 963, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 827, &__prediction); match __prediction.alt { 1 => { - let __match = self.base.match_token_recovering(24, 962, atn())?; + __loop_iter_827 = true; + let __match = self.base.match_set_recovering(&[(20, 20), (28, 28), (30, 30)], 826, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(962isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - 2 => { - let __match = self.base.match_token_recovering(33, 967, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 967, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 5 | 23 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 967, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(966isize); - let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 970, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + match self.base.sync_decision(atn(), 831, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 5 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 970, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(23, 971, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } - let __match = self.base.match_token_recovering(5, 974, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_35_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(35) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_35(precedence, allow_fallback)) - } else { - self.parse_generated_rule_35(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(35); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_35(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(70isize, 35); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 1..=4 | 6..=22 | 24..=32 | 34..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 977, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 9 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 831, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(830isize); + let __child = self.parse_generated_rule_114_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 977) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(104, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(104, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } + 2 => { } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 977, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(975isize); - let __child = self.parse_generated_rule_29_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(976isize); - let __child = self.parse_generated_rule_34_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let mut __loop_iter_983 = false; - loop { - match self.base.sync_decision(atn(), 983, !__ctx.has_matched_child(), __loop_iter_983) { + let __match = self.base.match_token_recovering(31, 834, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(834isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 836, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -22008,169 +19468,179 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 983) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(105, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(105, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } + let __prediction = match self.base.la(1) { + 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 3 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - self.base.record_generated_prediction_diagnostic(atn(), 983, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 836, &__prediction); match __prediction.alt { 1 => { - __loop_iter_983 = true; - let __match = self.base.match_token_recovering(16, 980, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(980isize); - let __child = self.parse_generated_rule_29_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(835isize); + let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - match self.base.sync_decision(atn(), 987, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 987, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 988, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_36_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_29_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(36) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_36(precedence, allow_fallback)) - } else { - self.parse_generated_rule_36(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(36); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 29, GeneratedRuleError::Fatal; self.parse_generated_rule_29(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_36(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_29(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(72isize, 36); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 1033, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1033) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(113, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 58isize, 29, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1..=4 | 6..=22 | 24..=27 | 29..=31 | 34..=46 | 48..=98 | 101..=102 | 104..=117 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 883, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 883) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(85, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(85, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } + } }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(113, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1033, &__prediction); - match __prediction.alt { - 1 => { - let mut __loop_iter_992 = false; - loop { - match self.base.sync_decision(atn(), 992, !__ctx.has_matched_child(), __loop_iter_992) { + self.base.record_generated_prediction_diagnostic(atn(), 883, &__prediction); + match __prediction.alt { + 1 => { + let mut __loop_iter_841 = false; + loop { + match self.base.sync_decision(atn(), 841, !__ctx.has_matched_child(), __loop_iter_841) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 32 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 841, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_841 = true; + let __invoking_marker = self.base.push_invoking_state(838isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __match = self.base.match_token_recovering(32, 884, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + let mut __loop_iter_848 = false; + loop { + match self.base.sync_decision(atn(), 848, !__ctx.has_matched_child(), __loop_iter_848) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 848) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(76, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(76, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 848, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_848 = true; + let __invoking_marker = self.base.push_invoking_state(845isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + match self.base.sync_decision(atn(), 852, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -22180,35 +19650,44 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 32 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 852) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(77, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(77, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } }; - self.base.record_generated_prediction_diagnostic(atn(), 992, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 852, &__prediction); match __prediction.alt { 1 => { - __loop_iter_992 = true; - let __invoking_marker = self.base.push_invoking_state(989isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(851isize); + let __child = self.parse_generated_rule_113_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - let __match = self.base.match_token_recovering(32, 1034, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let mut __loop_iter_999 = false; - loop { - match self.base.sync_decision(atn(), 999, !__ctx.has_matched_child(), __loop_iter_999) { + match self.base.sync_decision(atn(), 855, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -22218,33 +19697,85 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 855) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(78, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(78, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 855, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_not_set_recovering(&[(-1, -1)], 1, atn().max_token_type(), 856, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __invoking_marker = self.base.push_invoking_state(857isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(24, 861, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 861, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2..=6 | 9 | 11..=13 | 15..=16 | 18 | 20..=21 | 27 | 31 | 33..=34 | 36 | 40..=41 | 43..=45 | 48 | 50 | 52..=55 | 57 | 69 | 98..=100 | 102..=104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 32 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - self.base.record_generated_prediction_diagnostic(atn(), 999, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 861, &__prediction); match __prediction.alt { 1 => { - __loop_iter_999 = true; - let __invoking_marker = self.base.push_invoking_state(996isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(859isize); + let __child = self.parse_generated_rule_30_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; + let __match = self.base.match_token_recovering(32, 862, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1015, !__ctx.has_matched_child(), false) { + 3 => { + let mut __loop_iter_866 = false; + loop { + match self.base.sync_decision(atn(), 866, !__ctx.has_matched_child(), __loop_iter_866) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -22253,99 +19784,29 @@ where return Err(__error); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 5 | 23 | 28 | 33 | 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1015, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(3, 1008, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_1008 = false; - loop { - match self.base.sync_decision(atn(), 1008, !__ctx.has_matched_child(), __loop_iter_1008) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + }; + self.base.record_generated_prediction_diagnostic(atn(), 866, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_866 = true; + let __invoking_marker = self.base.push_invoking_state(863isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1008) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(109, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(109, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1008, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_1008 = true; - let __invoking_marker = self.base.push_invoking_state(1003isize); - let __child = self.parse_generated_rule_37_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(16, 1005, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 2 => { + break; } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __invoking_marker = self.base.push_invoking_state(1011isize); - let __child = self.parse_generated_rule_37_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(4, 1013, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(1014isize); - let __child = self.parse_generated_rule_37_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(24, 1021, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_1021 = false; - loop { - match self.base.sync_decision(atn(), 1021, !__ctx.has_matched_child(), __loop_iter_1021) { + match self.base.sync_decision(atn(), 870, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -22356,36 +19817,22 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=6 | 9 | 11..=13 | 15..=16 | 18 | 20..=21 | 27 | 31 | 33..=34 | 36 | 40..=41 | 43..=45 | 48 | 50 | 52..=55 | 57 | 69 | 98..=100 | 102..=104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 33 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 5 | 23 | 28 | 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1021, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 870, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1021 = true; - let __invoking_marker = self.base.push_invoking_state(1018isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(33, 871, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - let __invoking_marker = self.base.push_invoking_state(1024isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 3 => { - let mut __loop_iter_1029 = false; - loop { - match self.base.sync_decision(atn(), 1029, !__ctx.has_matched_child(), __loop_iter_1029) { + match self.base.sync_decision(atn(), 873, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -22396,235 +19843,110 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=6 | 9 | 11..=13 | 15..=16 | 18 | 20..=21 | 27 | 31 | 33..=34 | 36 | 40..=41 | 43..=45 | 48 | 50 | 52..=55 | 57 | 69 | 98..=100 | 102..=104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 5 | 23 | 28 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1029, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 873, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1029 = true; - let __invoking_marker = self.base.push_invoking_state(1026isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(872isize); + let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - let __invoking_marker = self.base.push_invoking_state(1032isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_37_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(37) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_37(precedence, allow_fallback)) - } else { - self.parse_generated_rule_37(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(37); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_37(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(74isize, 37); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 1036, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 35 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 18 | 21 | 23 | 27 | 33 | 36 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1036, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(35, 1037, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 1039, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 23 | 33 | 36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 18 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1039, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_set_recovering(&[(23, 23), (33, 33), (36, 36)], 1040, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 18 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1043, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 876, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 23 | 28 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 5 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 876, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(875isize); + let __child = self.parse_generated_rule_113_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(5, 881, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 881, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 16 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 881, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(24, 880, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(880isize); + let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 18 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1043, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(18, 1044, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(1042isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_38_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_30_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(38) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_38(precedence, allow_fallback)) - } else { - self.parse_generated_rule_38(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(38); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 30, GeneratedRuleError::Fatal; self.parse_generated_rule_30(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_38(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_30(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(76isize, 38); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __loop_iter_1048 = false; - loop { - match self.base.sync_decision(atn(), 1048, !__ctx.has_matched_child(), __loop_iter_1048) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 60isize, 30, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 888, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -22634,12 +19956,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1048) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 888) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(117, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(86, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -22649,7 +19971,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(117, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(86, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -22658,77 +19980,109 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 1048, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 888, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1048 = true; - let __invoking_marker = self.base.push_invoking_state(1045isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(885isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; + let __match = self.base.match_token_recovering(34, 887, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(887isize); + let __child = self.parse_generated_rule_95_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - match self.base.sync_decision(atn(), 1053, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1053) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(118, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(118, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1053, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1051isize); - let __child = self.parse_generated_rule_36_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(1052isize); - let __child = self.parse_generated_rule_34_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_31_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 31, GeneratedRuleError::Fatal; self.parse_generated_rule_31(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_31(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 62isize, 31, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(890isize); + let __child = self.parse_generated_rule_29_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_895 = false; + loop { + match self.base.sync_decision(atn(), 895, !__ctx.has_matched_child(), __loop_iter_895) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 895) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(87, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(87, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 895, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_895 = true; + let __match = self.base.match_token_recovering(16, 892, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(892isize); + let __child = self.parse_generated_rule_29_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let mut __loop_iter_1059 = false; - loop { - match self.base.sync_decision(atn(), 1059, !__ctx.has_matched_child(), __loop_iter_1059) { + match self.base.sync_decision(atn(), 910, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -22738,12 +20092,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1059) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 910) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(119, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(89, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -22753,7 +20107,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(119, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(89, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -22762,325 +20116,121 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 1059, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 910, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1059 = true; - let __match = self.base.match_token_recovering(16, 1056, atn())?; + let __match = self.base.match_token_recovering(16, 902, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1056isize); - let __child = self.parse_generated_rule_36_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let mut __loop_iter_902 = false; + loop { + match self.base.sync_decision(atn(), 902, !__ctx.has_matched_child(), __loop_iter_902) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=6 | 12 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 46 | 48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 902, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_902 = true; + let __invoking_marker = self.base.push_invoking_state(899isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __invoking_marker = self.base.push_invoking_state(905isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(906isize); + let __child = self.parse_generated_rule_113_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(24, 908, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(32, 909, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - match self.base.sync_decision(atn(), 1063, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 1063, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 1064, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_39_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(39) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_39(precedence, allow_fallback)) - } else { - self.parse_generated_rule_39(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(39); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_39(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(78isize, 39); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(37, 1066, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1066isize); - let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_40_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(40) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_40(precedence, allow_fallback)) - } else { - self.parse_generated_rule_40(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(40); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_40(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(80isize, 40); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(37, 1072, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 1072, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + match self.base.sync_decision(atn(), 913, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1072) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(121, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(121, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1072, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1069isize); - let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + self.base.record_generated_prediction_diagnostic(atn(), 913, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 914, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => { - let __match = self.base.match_token_recovering(34, 1071, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1071isize); - let __child = self.parse_generated_rule_95_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_41_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_32_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(41) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_41(precedence, allow_fallback)) - } else { - self.parse_generated_rule_41(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(41); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 32, GeneratedRuleError::Fatal; self.parse_generated_rule_32(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_41(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_32(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(82isize, 41); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 1107, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1107) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(129, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(129, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1107, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(26, 1075, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1075isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 1077, !__ctx.has_matched_child(), false) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 64isize, 32, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(915isize); + let __child = self.parse_generated_rule_29_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_920 = false; + loop { + match self.base.sync_decision(atn(), 920, !__ctx.has_matched_child(), __loop_iter_920) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -23090,102 +20240,185 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 25 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 920) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(91, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(91, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } }; - self.base.record_generated_prediction_diagnostic(atn(), 1077, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 920, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(1076isize); - let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_920 = true; + let __match = self.base.match_token_recovering(16, 917, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(917isize); + let __child = self.parse_generated_rule_29_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - match self.base.sync_decision(atn(), 1080, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + } + match self.base.sync_decision(atn(), 931, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 931) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(93, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? }; - self.base.record_generated_prediction_diagnostic(atn(), 1080, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1079isize); - let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(93, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 931, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 927, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_927 = false; + loop { + match self.base.sync_decision(atn(), 927, !__ctx.has_matched_child(), __loop_iter_927) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 32 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 927, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_927 = true; + let __invoking_marker = self.base.push_invoking_state(924isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __match = self.base.match_token_recovering(32, 932, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { } - let __match = self.base.match_token_recovering(25, 1083, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1083isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(10, 1085, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => { - let __match = self.base.match_token_recovering(26, 1087, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1087isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 1089, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + match self.base.sync_decision(atn(), 934, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 | 24..=25 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1089, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1088isize); - let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 934, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 935, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { } - match self.base.sync_decision(atn(), 1092, !__ctx.has_matched_child(), false) { + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_33_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 33, GeneratedRuleError::Fatal; self.parse_generated_rule_33(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_33(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 66isize, 33, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(936isize); + let __child = self.parse_generated_rule_36_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_941 = false; + loop { + match self.base.sync_decision(atn(), 941, !__ctx.has_matched_child(), __loop_iter_941) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -23195,12 +20428,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1092) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 941) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(125, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(95, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -23210,7 +20443,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(125, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(95, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -23219,346 +20452,385 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 1092, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1091isize); - let __child = self.parse_generated_rule_94_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 1095, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 | 24..=25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1095, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1094isize); - let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 1099, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 | 25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1099, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 941, &__prediction); match __prediction.alt { 1 => { - let __match = self.base.match_token_recovering(24, 1098, atn())?; + __loop_iter_941 = true; + let __match = self.base.match_token_recovering(16, 938, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1098isize); - let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(938isize); + let __child = self.parse_generated_rule_36_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - match self.base.sync_decision(atn(), 1103, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + } + match self.base.sync_decision(atn(), 952, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 25 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 952) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(97, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? }; - self.base.record_generated_prediction_diagnostic(atn(), 1103, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(25, 1102, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1102isize); - let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(97, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 952, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 948, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_948 = false; + loop { + match self.base.sync_decision(atn(), 948, !__ctx.has_matched_child(), __loop_iter_948) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 32 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 948, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_948 = true; + let __invoking_marker = self.base.push_invoking_state(945isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __match = self.base.match_token_recovering(32, 953, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { } - let __match = self.base.match_token_recovering(10, 1106, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 955, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 955, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 956, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_42_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_34_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(42) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_42(precedence, allow_fallback)) - } else { - self.parse_generated_rule_42(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(42); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 34, GeneratedRuleError::Fatal; self.parse_generated_rule_34(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_42(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_34(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(84isize, 42); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(38, 1110, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1110isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 1112, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 3 | 10 | 13 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1112, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1111isize); - let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 68isize, 34, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 5 | 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 33 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 973, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 5 | 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 33 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 973, &__prediction); + match __prediction.alt { + 1 => { + match self.base.sync_decision(atn(), 958, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 5 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 958, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(23, 959, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(5, 963, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 963, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 16 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 963, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(24, 962, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(962isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + 2 => { + let __match = self.base.match_token_recovering(33, 967, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 967, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 5 | 23 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 967, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(966isize); + let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 970, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 5 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 970, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(23, 971, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(5, 974, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(1114isize); - let __child = self.parse_generated_rule_43_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_43_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_35_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(43) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_43(precedence, allow_fallback)) - } else { - self.parse_generated_rule_43(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(43); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 35, GeneratedRuleError::Fatal; self.parse_generated_rule_35(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_43(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_35(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(86isize, 43); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 10 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 3 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1137, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 70isize, 35, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1..=4 | 6..=22 | 24..=32 | 34..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 977, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1137) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(136, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(136, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 977) { __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(104, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(104, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1137, &__prediction); - match __prediction.alt { - 1 => { - match self.base.sync_decision(atn(), 1117, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + }; + self.base.record_generated_prediction_diagnostic(atn(), 977, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(975isize); + let __child = self.parse_generated_rule_29_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1117, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1116isize); - let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 2 => { + let __invoking_marker = self.base.push_invoking_state(976isize); + let __child = self.parse_generated_rule_34_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(10, 1138, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => { - let __match = self.base.match_token_recovering(3, 1122, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 1122, !__ctx.has_matched_child(), false) { + let mut __loop_iter_983 = false; + loop { + match self.base.sync_decision(atn(), 983, !__ctx.has_matched_child(), __loop_iter_983) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -23568,12 +20840,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1122) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 983) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(132, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(105, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -23583,7 +20855,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(132, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(105, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -23592,177 +20864,26 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 1122, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1121isize); - let __child = self.parse_generated_rule_45_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(4, 1126, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 1126, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1126, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1125isize); - let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(10, 1138, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - match self.base.sync_decision(atn(), 1130, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1130, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1129isize); - let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(13, 1134, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 1134, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 1..=2 | 21 | 27 | 40..=41 | 47 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1134, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 983, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(1133isize); - let __child = self.parse_generated_rule_47_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_983 = true; + let __match = self.base.match_token_recovering(16, 980, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(980isize); + let __child = self.parse_generated_rule_29_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __match = self.base.match_token_recovering(14, 1138, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_44_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(44) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_44(precedence, allow_fallback)) - } else { - self.parse_generated_rule_44(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(44); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_44(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(88isize, 44); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __loop_iter_1142 = false; - loop { - match self.base.sync_decision(atn(), 1142, !__ctx.has_matched_child(), __loop_iter_1142) { + match self.base.sync_decision(atn(), 987, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -23773,140 +20894,43 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 1..=6 | 9 | 11..=13 | 15..=16 | 18 | 20..=21 | 27 | 31 | 33..=34 | 36 | 40..=41 | 43..=45 | 48 | 50 | 52..=55 | 57 | 69 | 98..=100 | 102..=104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - self.base.record_generated_prediction_diagnostic(atn(), 1142, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 987, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1142 = true; - let __invoking_marker = self.base.push_invoking_state(1139isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(16, 988, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - match self.base.sync_decision(atn(), 1146, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1146) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(138, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(138, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1146, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1145isize); - let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(1148isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_45_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_36_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(45) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_45(precedence, allow_fallback)) - } else { - self.parse_generated_rule_45(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(45); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 36, GeneratedRuleError::Fatal; self.parse_generated_rule_36(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_45(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_36(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(90isize, 45); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(1150isize); - let __child = self.parse_generated_rule_44_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_1155 = false; - loop { - match self.base.sync_decision(atn(), 1155, !__ctx.has_matched_child(), __loop_iter_1155) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 72isize, 36, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 1033, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -23916,12 +20940,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1155) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1033) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(139, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(113, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -23931,7 +20955,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(139, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(113, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -23940,260 +20964,287 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 1155, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1033, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1155 = true; - let __match = self.base.match_token_recovering(16, 1152, atn())?; + let mut __loop_iter_992 = false; + loop { + match self.base.sync_decision(atn(), 992, !__ctx.has_matched_child(), __loop_iter_992) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 32 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 992, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_992 = true; + let __invoking_marker = self.base.push_invoking_state(989isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __match = self.base.match_token_recovering(32, 1034, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1152isize); - let __child = self.parse_generated_rule_44_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - match self.base.sync_decision(atn(), 1159, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 1159, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 1160, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_46_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(46) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_46(precedence, allow_fallback)) - } else { - self.parse_generated_rule_46(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(46); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_46(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(92isize, 46); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __loop_iter_1164 = false; - loop { - match self.base.sync_decision(atn(), 1164, !__ctx.has_matched_child(), __loop_iter_1164) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 1..=2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1164, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_1164 = true; - let __invoking_marker = self.base.push_invoking_state(1161isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let mut __loop_iter_999 = false; + loop { + match self.base.sync_decision(atn(), 999, !__ctx.has_matched_child(), __loop_iter_999) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 999, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_999 = true; + let __invoking_marker = self.base.push_invoking_state(996isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1015, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1015, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(3, 1008, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_1008 = false; + loop { + match self.base.sync_decision(atn(), 1008, !__ctx.has_matched_child(), __loop_iter_1008) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1008) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(109, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(109, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1008, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_1008 = true; + let __invoking_marker = self.base.push_invoking_state(1003isize); + let __child = self.parse_generated_rule_37_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(16, 1005, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __invoking_marker = self.base.push_invoking_state(1011isize); + let __child = self.parse_generated_rule_37_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(4, 1013, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(1014isize); + let __child = self.parse_generated_rule_37_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(24, 1021, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_1021 = false; + loop { + match self.base.sync_decision(atn(), 1021, !__ctx.has_matched_child(), __loop_iter_1021) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=6 | 9 | 11..=13 | 15..=16 | 18 | 20..=21 | 27 | 31 | 33..=34 | 36 | 40..=41 | 43..=45 | 48 | 50 | 52..=55 | 57 | 69 | 98..=100 | 102..=104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 1021, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_1021 = true; + let __invoking_marker = self.base.push_invoking_state(1018isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __invoking_marker = self.base.push_invoking_state(1024isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } - 2 => { - break; + 3 => { + let mut __loop_iter_1029 = false; + loop { + match self.base.sync_decision(atn(), 1029, !__ctx.has_matched_child(), __loop_iter_1029) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=6 | 9 | 11..=13 | 15..=16 | 18 | 20..=21 | 27 | 31 | 33..=34 | 36 | 40..=41 | 43..=45 | 48 | 50 | 52..=55 | 57 | 69 | 98..=100 | 102..=104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 1029, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_1029 = true; + let __invoking_marker = self.base.push_invoking_state(1026isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __invoking_marker = self.base.push_invoking_state(1032isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - match self.base.sync_decision(atn(), 1168, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1168) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(142, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(142, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1168, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1167isize); - let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(1170isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(24, 1172, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1172isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_47_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_37_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(47) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_47(precedence, allow_fallback)) - } else { - self.parse_generated_rule_47(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(47); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 37, GeneratedRuleError::Fatal; self.parse_generated_rule_37(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_47(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_37(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(94isize, 47); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(1174isize); - let __child = self.parse_generated_rule_46_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_1179 = false; - loop { - match self.base.sync_decision(atn(), 1179, !__ctx.has_matched_child(), __loop_iter_1179) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 74isize, 37, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 1036, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -24203,284 +21254,23 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1179) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(143, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(143, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } + let __prediction = match self.base.la(1) { + 35 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 18 | 21 | 23 | 27 | 33 | 36 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1179, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1036, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1179 = true; - let __match = self.base.match_token_recovering(16, 1176, atn())?; + let __match = self.base.match_token_recovering(35, 1037, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1176isize); - let __child = self.parse_generated_rule_46_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - match self.base.sync_decision(atn(), 1183, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 1183, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 1184, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_48_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(48) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_48(precedence, allow_fallback)) - } else { - self.parse_generated_rule_48(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(48); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_48(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(96isize, 48); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(39, 1186, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1186isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 1188, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1188, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1187isize); - let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 1191, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1191, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1190isize); - let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(13, 1195, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 1195, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 1..=2 | 21 | 27 | 40..=41 | 47 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1195, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1194isize); - let __child = self.parse_generated_rule_50_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(14, 1198, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_49_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(49) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_49(precedence, allow_fallback)) - } else { - self.parse_generated_rule_49(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(49); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_49(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(98isize, 49); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __loop_iter_1202 = false; - loop { - match self.base.sync_decision(atn(), 1202, !__ctx.has_matched_child(), __loop_iter_1202) { + match self.base.sync_decision(atn(), 1039, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -24491,171 +21281,133 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 1..=2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 23 | 33 | 36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 18 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1202, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1039, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1202 = true; - let __invoking_marker = self.base.push_invoking_state(1199isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_set_recovering(&[(23, 23), (33, 33), (36, 36)], 1040, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - match self.base.sync_decision(atn(), 1206, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1206) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(149, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 18 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1043, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 18 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(149, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1206, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1205isize); - let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(1208isize); - let __child = self.parse_generated_rule_51_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 1211, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 25 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 | 16 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 1211, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(25, 1210, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1210isize); - let __child = self.parse_generated_rule_157_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { + self.base.record_generated_prediction_diagnostic(atn(), 1043, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(18, 1044, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(1042isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_50_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_38_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(50) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_50(precedence, allow_fallback)) - } else { - self.parse_generated_rule_50(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(50); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 38, GeneratedRuleError::Fatal; self.parse_generated_rule_38(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_50(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_38(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(100isize, 50); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(1213isize); - let __child = self.parse_generated_rule_49_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_1218 = false; - loop { - match self.base.sync_decision(atn(), 1218, !__ctx.has_matched_child(), __loop_iter_1218) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 76isize, 38, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __loop_iter_1048 = false; + loop { + match self.base.sync_decision(atn(), 1048, !__ctx.has_matched_child(), __loop_iter_1048) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1048) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(117, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(117, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1048, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_1048 = true; + let __invoking_marker = self.base.push_invoking_state(1045isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + match self.base.sync_decision(atn(), 1053, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -24665,12 +21417,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1218) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1053) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(151, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(118, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -24680,7 +21432,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(151, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(118, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -24689,151 +21441,27 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 1218, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1053, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1218 = true; - let __match = self.base.match_token_recovering(16, 1215, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1215isize); - let __child = self.parse_generated_rule_49_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1051isize); + let __child = self.parse_generated_rule_36_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; + let __invoking_marker = self.base.push_invoking_state(1052isize); + let __child = self.parse_generated_rule_34_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - match self.base.sync_decision(atn(), 1222, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 1222, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 1223, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_51_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(51) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_51(precedence, allow_fallback)) - } else { - self.parse_generated_rule_51(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(51); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_51(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(102isize, 51); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 1243, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1243) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(155, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(155, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1243, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1224isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(3, 1227, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 1227, !__ctx.has_matched_child(), false) { + let mut __loop_iter_1059 = false; + loop { + match self.base.sync_decision(atn(), 1059, !__ctx.has_matched_child(), __loop_iter_1059) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -24843,12 +21471,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1227) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1059) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(153, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(119, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -24858,7 +21486,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(153, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(119, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -24867,145 +21495,26 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 1227, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1226isize); - let __child = self.parse_generated_rule_53_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(4, 1230, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(1231isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(13, 1234, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 1234, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 1..=2 | 21 | 27 | 40..=41 | 47 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1234, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1059, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(1233isize); - let __child = self.parse_generated_rule_55_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_1059 = true; + let __match = self.base.match_token_recovering(16, 1056, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1056isize); + let __child = self.parse_generated_rule_36_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __match = self.base.match_token_recovering(14, 1237, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __invoking_marker = self.base.push_invoking_state(1238isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(25, 1240, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1240isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 4 => { - let __invoking_marker = self.base.push_invoking_state(1242isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_52_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(52) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_52(precedence, allow_fallback)) - } else { - self.parse_generated_rule_52(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(52); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_52(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(104isize, 52); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __loop_iter_1248 = false; - loop { - match self.base.sync_decision(atn(), 1248, !__ctx.has_matched_child(), __loop_iter_1248) { + match self.base.sync_decision(atn(), 1063, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -25016,93 +21525,75 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=6 | 9 | 11..=13 | 15..=16 | 18 | 20..=21 | 27 | 31 | 33..=34 | 36 | 40..=41 | 43..=45 | 48 | 50 | 52..=55 | 57 | 69 | 98..=100 | 102..=104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - self.base.record_generated_prediction_diagnostic(atn(), 1248, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1063, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1248 = true; - let __invoking_marker = self.base.push_invoking_state(1245isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(16, 1064, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __invoking_marker = self.base.push_invoking_state(1251isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_53_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_39_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(53) { - return Err(GeneratedRuleError::Fatal(error)); + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 39, GeneratedRuleError::Fatal; self.parse_generated_rule_39(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_39(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 78isize, 39, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(37, 1066, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1066isize); + let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + success {} + recovery {} } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_53(precedence, allow_fallback)) - } else { - self.parse_generated_rule_53(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(53); - __listener_result } #[allow(dead_code)] - fn parse_generated_rule_53(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_40_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 40, GeneratedRuleError::Fatal; self.parse_generated_rule_40(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_40(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(106isize, 53); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(1253isize); - let __child = self.parse_generated_rule_52_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_1258 = false; - loop { - match self.base.sync_decision(atn(), 1258, !__ctx.has_matched_child(), __loop_iter_1258) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 80isize, 40, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(37, 1072, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1072, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -25112,12 +21603,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1258) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1072) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(157, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(121, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -25127,7 +21618,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(157, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(121, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -25136,108 +21627,49 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 1258, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1072, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1258 = true; - let __match = self.base.match_token_recovering(16, 1255, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1255isize); - let __child = self.parse_generated_rule_52_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1069isize); + let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; + let __match = self.base.match_token_recovering(34, 1071, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1071isize); + let __child = self.parse_generated_rule_95_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - match self.base.sync_decision(atn(), 1262, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 1262, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 1263, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_54_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_41_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(54) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_54(precedence, allow_fallback)) - } else { - self.parse_generated_rule_54(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(54); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 41, GeneratedRuleError::Fatal; self.parse_generated_rule_41(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_54(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_41(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(108isize, 54); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __loop_iter_1267 = false; - loop { - match self.base.sync_decision(atn(), 1267, !__ctx.has_matched_child(), __loop_iter_1267) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 82isize, 41, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 1107, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -25247,164 +21679,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 1..=2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1267, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_1267 = true; - let __invoking_marker = self.base.push_invoking_state(1264isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - match self.base.sync_decision(atn(), 1271, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1271) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(160, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(160, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1271, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1270isize); - let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(1273isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(24, 1275, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1275isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_55_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(55) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_55(precedence, allow_fallback)) - } else { - self.parse_generated_rule_55(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(55); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_55(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(110isize, 55); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(1277isize); - let __child = self.parse_generated_rule_54_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_1282 = false; - loop { - match self.base.sync_decision(atn(), 1282, !__ctx.has_matched_child(), __loop_iter_1282) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1282) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1107) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(161, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(129, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -25414,7 +21694,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(161, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(129, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -25423,436 +21703,295 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 1282, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1107, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1282 = true; - let __match = self.base.match_token_recovering(16, 1279, atn())?; + let __match = self.base.match_token_recovering(26, 1075, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1075isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1077, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 25 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1077, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1076isize); + let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 1080, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1080, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1079isize); + let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(25, 1083, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1279isize); - let __child = self.parse_generated_rule_54_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1083isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(10, 1085, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } 2 => { - break; + let __match = self.base.match_token_recovering(26, 1087, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1087isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1089, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 | 24..=25 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1089, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1088isize); + let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 1092, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1092) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(125, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(125, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1092, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1091isize); + let __child = self.parse_generated_rule_94_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 1095, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 | 24..=25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1095, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1094isize); + let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 1099, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 | 25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1099, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(24, 1098, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1098isize); + let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 1103, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 25 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1103, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(25, 1102, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1102isize); + let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(10, 1106, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - match self.base.sync_decision(atn(), 1286, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 1286, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 1287, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_56_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(56) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_56(precedence, allow_fallback)) - } else { - self.parse_generated_rule_56(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(56); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_56(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(112isize, 56); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(40, 1289, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1289isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 1291, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1291, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1290isize); - let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 1294, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1294, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1293isize); - let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(13, 1297, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1297isize); - let __child = self.parse_generated_rule_47_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(14, 1299, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_57_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_42_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(57) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_57(precedence, allow_fallback)) - } else { - self.parse_generated_rule_57(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(57); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 42, GeneratedRuleError::Fatal; self.parse_generated_rule_42(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_57(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_42(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(114isize, 57); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 1301, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 20 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 41..=42 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1301, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(20, 1302, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 1304, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 41 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 42 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1304, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(41, 1305, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(42, 1307, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1307isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 1309, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 | 24 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1309, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1308isize); - let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 1312, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1312, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1311isize); - let __child = self.parse_generated_rule_94_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 1315, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1315, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1314isize); - let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(13, 1321, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_1321 = false; - loop { - match self.base.sync_decision(atn(), 1321, !__ctx.has_matched_child(), __loop_iter_1321) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1321) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(170, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(170, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1321, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_1321 = true; - let __invoking_marker = self.base.push_invoking_state(1318isize); - let __child = self.parse_generated_rule_67_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - let mut __loop_iter_1327 = false; - loop { - match self.base.sync_decision(atn(), 1327, !__ctx.has_matched_child(), __loop_iter_1327) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 84isize, 42, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(38, 1110, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1110isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1112, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -25863,307 +22002,95 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 1..=2 | 5..=6 | 9 | 12 | 20..=21 | 26..=28 | 30..=31 | 40..=41 | 47 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 3 | 10 | 13 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1327, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1112, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1327 = true; - let __invoking_marker = self.base.push_invoking_state(1324isize); - let __child = self.parse_generated_rule_59_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1111isize); + let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __invoking_marker = self.base.push_invoking_state(1114isize); + let __child = self.parse_generated_rule_43_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(14, 1331, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_58_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(58) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_58(precedence, allow_fallback)) - } else { - self.parse_generated_rule_58(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(58); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_58(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(116isize, 58); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(42, 1333, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1333isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 1335, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1335, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1334isize); - let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(25, 1343, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 1343, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1343) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(174, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(174, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1343, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1338isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 1340, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1340, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1339isize); - let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(1342isize); - let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(10, 1346, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_59_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_43_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(59) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_59(precedence, allow_fallback)) - } else { - self.parse_generated_rule_59(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(59); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 43, GeneratedRuleError::Fatal; self.parse_generated_rule_43(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_59(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_43(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(118isize, 59); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 26 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 9 | 20 | 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 5..=6 | 12 | 21 | 40..=41 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1429, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 86isize, 43, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 10 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 3 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1137, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1429) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(194, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(194, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1137) { __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(136, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(136, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1429, &__prediction); - match __prediction.alt { - 1 => { - let mut __loop_iter_1350 = false; - loop { - match self.base.sync_decision(atn(), 1350, !__ctx.has_matched_child(), __loop_iter_1350) { + }; + self.base.record_generated_prediction_diagnostic(atn(), 1137, &__prediction); + match __prediction.alt { + 1 => { + match self.base.sync_decision(atn(), 1117, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -26174,208 +22101,82 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 1..=2 | 26..=27 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1350, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1117, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1350 = true; - let __invoking_marker = self.base.push_invoking_state(1347isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1116isize); + let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(10, 1138, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - match self.base.sync_decision(atn(), 1354, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 27 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 1..=2 | 26 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1354, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(27, 1355, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 1357, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 1..=2 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 26 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1357, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1356isize); - let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(26, 1360, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1360isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 1362, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 | 24..=25 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1362, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1361isize); - let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 1365, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 | 25 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1365, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1364isize); - let __child = self.parse_generated_rule_94_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 1368, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 | 25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1368, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1367isize); - let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 1371, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 25 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1371, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1370isize); - let __child = self.parse_generated_rule_60_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 2 => { + let __match = self.base.match_token_recovering(3, 1122, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1122, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1122) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(132, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(132, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1122, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1121isize); + let __child = self.parse_generated_rule_45_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(10, 1374, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let mut __loop_iter_1378 = false; - loop { - match self.base.sync_decision(atn(), 1378, !__ctx.has_matched_child(), __loop_iter_1378) { + let __match = self.base.match_token_recovering(4, 1126, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1126, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -26386,104 +22187,29 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 27..=28 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1378, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1126, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1378 = true; - let __invoking_marker = self.base.push_invoking_state(1375isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1125isize); + let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(10, 1138, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - match self.base.sync_decision(atn(), 1382, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 27 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 28 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1382, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(27, 1383, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(28, 1385, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1385isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(24, 1387, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1387isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 1389, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 25 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1389, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1388isize); - let __child = self.parse_generated_rule_61_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(10, 1392, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let mut __loop_iter_1396 = false; - loop { - match self.base.sync_decision(atn(), 1396, !__ctx.has_matched_child(), __loop_iter_1396) { + 3 => { + match self.base.sync_decision(atn(), 1130, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -26494,53 +22220,84 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 1..=2 | 9 | 20 | 27..=28 | 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1396, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1130, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1396 = true; - let __invoking_marker = self.base.push_invoking_state(1393isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1129isize); + let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - match self.base.sync_decision(atn(), 1400, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 27 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 1..=2 | 9 | 20 | 28 | 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1400, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(27, 1401, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(13, 1134, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1134, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1..=2 | 21 | 27 | 40..=41 | 47 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1134, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1133isize); + let __child = self.parse_generated_rule_47_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __match = self.base.match_token_recovering(14, 1138, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - match self.base.sync_decision(atn(), 1403, !__ctx.has_matched_child(), false) { + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_44_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 44, GeneratedRuleError::Fatal; self.parse_generated_rule_44(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_44(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 88isize, 44, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __loop_iter_1142 = false; + loop { + match self.base.sync_decision(atn(), 1142, !__ctx.has_matched_child(), __loop_iter_1142) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -26551,64 +22308,107 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 1..=2 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 9 | 20 | 28 | 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 1..=6 | 9 | 11..=13 | 15..=16 | 18 | 20..=21 | 27 | 31 | 33..=34 | 36 | 40..=41 | 43..=45 | 48 | 50 | 52..=55 | 57 | 69 | 98..=100 | 102..=104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - self.base.record_generated_prediction_diagnostic(atn(), 1403, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1142, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(1402isize); - let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_1142 = true; + let __invoking_marker = self.base.push_invoking_state(1139isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __invoking_marker = self.base.push_invoking_state(1405isize); - let __child = self.parse_generated_rule_24_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); } - 4 => { - let mut __loop_iter_1409 = false; - loop { - match self.base.sync_decision(atn(), 1409, !__ctx.has_matched_child(), __loop_iter_1409) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 1..=2 | 5..=6 | 12 | 21 | 27 | 40..=41 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1409, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_1409 = true; - let __invoking_marker = self.base.push_invoking_state(1406isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } + match self.base.sync_decision(atn(), 1146, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1146) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(138, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(138, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1146, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1145isize); + let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { } - match self.base.sync_decision(atn(), 1413, !__ctx.has_matched_child(), false) { + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __invoking_marker = self.base.push_invoking_state(1148isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_45_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 45, GeneratedRuleError::Fatal; self.parse_generated_rule_45(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_45(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 90isize, 45, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(1150isize); + let __child = self.parse_generated_rule_44_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_1155 = false; + loop { + match self.base.sync_decision(atn(), 1155, !__ctx.has_matched_child(), __loop_iter_1155) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -26618,12 +22418,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1413) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1155) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(189, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(139, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -26633,7 +22433,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(189, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(139, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -26642,18 +22442,75 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 1413, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1155, &__prediction); match __prediction.alt { 1 => { - let __match = self.base.match_token_recovering(27, 1414, atn())?; + __loop_iter_1155 = true; + let __match = self.base.match_token_recovering(16, 1152, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1152isize); + let __child = self.parse_generated_rule_44_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - match self.base.sync_decision(atn(), 1416, !__ctx.has_matched_child(), false) { + } + match self.base.sync_decision(atn(), 1159, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 1159, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 1160, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_46_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 46, GeneratedRuleError::Fatal; self.parse_generated_rule_46(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_46(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 92isize, 46, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __loop_iter_1164 = false; + loop { + match self.base.sync_decision(atn(), 1164, !__ctx.has_matched_child(), __loop_iter_1164) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -26663,51 +22520,116 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1416) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(190, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(190, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 1..=2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1416, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1164, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(1415isize); - let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_1164 = true; + let __invoking_marker = self.base.push_invoking_state(1161isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __invoking_marker = self.base.push_invoking_state(1418isize); - let __child = self.parse_generated_rule_212_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); } - 5 => { - match self.base.sync_decision(atn(), 1420, !__ctx.has_matched_child(), false) { + match self.base.sync_decision(atn(), 1168, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1168) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(142, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(142, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1168, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1167isize); + let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __invoking_marker = self.base.push_invoking_state(1170isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(24, 1172, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1172isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_47_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 47, GeneratedRuleError::Fatal; self.parse_generated_rule_47(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_47(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 94isize, 47, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(1174isize); + let __child = self.parse_generated_rule_46_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_1179 = false; + loop { + match self.base.sync_decision(atn(), 1179, !__ctx.has_matched_child(), __loop_iter_1179) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -26717,12 +22639,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1420) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1179) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(191, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(143, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -26732,7 +22654,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(191, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(143, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -26741,496 +22663,225 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 1420, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1179, &__prediction); match __prediction.alt { 1 => { - let __match = self.base.match_token_recovering(27, 1421, atn())?; + __loop_iter_1179 = true; + let __match = self.base.match_token_recovering(16, 1176, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 1423, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 1..=2 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 27..=28 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1423, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1422isize); - let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1176isize); + let __child = self.parse_generated_rule_46_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 27 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1427, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1427) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(193, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(193, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1427, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1425isize); - let __child = self.parse_generated_rule_20_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(1426isize); - let __child = self.parse_generated_rule_21_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 1183, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_60_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(60) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_60(precedence, allow_fallback)) - } else { - self.parse_generated_rule_60(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(60); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_60(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(120isize, 60); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(25, 1432, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1432isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 1183, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 1184, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_61_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_48_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(61) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_61(precedence, allow_fallback)) - } else { - self.parse_generated_rule_61(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(61); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 48, GeneratedRuleError::Fatal; self.parse_generated_rule_48(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_61(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_48(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(122isize, 61); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(25, 1435, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1435isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 96isize, 48, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(39, 1186, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1186isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1188, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1188, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1187isize); + let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 1191, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1191, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1190isize); + let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(13, 1195, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1195, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1..=2 | 21 | 27 | 40..=41 | 47 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1195, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1194isize); + let __child = self.parse_generated_rule_50_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(14, 1198, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_62_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_49_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(62) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_62(precedence, allow_fallback)) - } else { - self.parse_generated_rule_62(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(62); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 49, GeneratedRuleError::Fatal; self.parse_generated_rule_49(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_62(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_49(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(124isize, 62); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 1438, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 27 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 20 | 34 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1438, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(27, 1439, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 1441, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 20 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 34 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1441, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(20, 1442, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(34, 1445, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 1445, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1445) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(197, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(197, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1445, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1444isize); - let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 1448, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1448) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(198, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(198, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1448, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(43, 1449, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 1451, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 28 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=6 | 9 | 11..=13 | 15 | 18 | 20..=21 | 27 | 31 | 33..=34 | 36 | 40..=41 | 43..=45 | 48 | 50 | 52..=57 | 69 | 98..=100 | 102..=104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1451, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(28, 1452, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(1453isize); - let __child = self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 1455, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1455, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1454isize); - let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 98isize, 49, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __loop_iter_1202 = false; + loop { + match self.base.sync_decision(atn(), 1202, !__ctx.has_matched_child(), __loop_iter_1202) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 1..=2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1202, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_1202 = true; + let __invoking_marker = self.base.push_invoking_state(1199isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(13, 1461, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_1461 = false; - loop { - match self.base.sync_decision(atn(), 1461, !__ctx.has_matched_child(), __loop_iter_1461) { + match self.base.sync_decision(atn(), 1206, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -27240,12 +22891,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1461) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1206) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(201, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(149, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -27255,7 +22906,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(201, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(149, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -27264,25 +22915,25 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 1461, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1206, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1461 = true; - let __invoking_marker = self.base.push_invoking_state(1458isize); - let __child = self.parse_generated_rule_67_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1205isize); + let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - let mut __loop_iter_1467 = false; - loop { - match self.base.sync_decision(atn(), 1467, !__ctx.has_matched_child(), __loop_iter_1467) { + let __invoking_marker = self.base.push_invoking_state(1208isize); + let __child = self.parse_generated_rule_51_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1211, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -27293,243 +22944,155 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 1..=2 | 5..=6 | 9 | 12 | 20..=21 | 26..=28 | 30..=31 | 40..=41 | 47 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 25 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 | 16 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - self.base.record_generated_prediction_diagnostic(atn(), 1467, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1211, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1467 = true; - let __invoking_marker = self.base.push_invoking_state(1464isize); - let __child = self.parse_generated_rule_64_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __match = self.base.match_token_recovering(25, 1210, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1210isize); + let __child = self.parse_generated_rule_157_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __match = self.base.match_token_recovering(14, 1471, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_63_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_50_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(63) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_63(precedence, allow_fallback)) - } else { - self.parse_generated_rule_63(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(63); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 50, GeneratedRuleError::Fatal; self.parse_generated_rule_50(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_63(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_50(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(126isize, 63); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 1489, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 100isize, 50, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(1213isize); + let __child = self.parse_generated_rule_49_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_1218 = false; + loop { + match self.base.sync_decision(atn(), 1218, !__ctx.has_matched_child(), __loop_iter_1218) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1218) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(151, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(151, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1218, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_1218 = true; + let __match = self.base.match_token_recovering(16, 1215, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1215isize); + let __child = self.parse_generated_rule_49_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + match self.base.sync_decision(atn(), 1222, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1489) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(203, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(203, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1489, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(44, 1473, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1473isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(45, 1475, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1475isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(1477isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(45, 1479, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1479isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 3 => { - let __invoking_marker = self.base.push_invoking_state(1481isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(45, 1483, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(46, 1484, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 4 => { - let __invoking_marker = self.base.push_invoking_state(1485isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __invoking_marker = self.base.push_invoking_state(1486isize); - let __child = self.parse_generated_rule_115_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 5 => { - let __invoking_marker = self.base.push_invoking_state(1488isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + self.base.record_generated_prediction_diagnostic(atn(), 1222, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 1223, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_64_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_51_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(64) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_64(precedence, allow_fallback)) - } else { - self.parse_generated_rule_64(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(64); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 51, GeneratedRuleError::Fatal; self.parse_generated_rule_51(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_64(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_51(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(128isize, 64); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __loop_iter_1495 = false; - loop { - match self.base.sync_decision(atn(), 1495, !__ctx.has_matched_child(), __loop_iter_1495) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 102isize, 51, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 1243, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -27539,16 +23102,42 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 1..=2 | 5..=6 | 9 | 12 | 20..=21 | 26..=28 | 30..=31 | 40..=41 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1243) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(155, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(155, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } }; - self.base.record_generated_prediction_diagnostic(atn(), 1495, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1243, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1495 = true; - match self.base.sync_decision(atn(), 1493, !__ctx.has_matched_child(), false) { + let __invoking_marker = self.base.push_invoking_state(1224isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(3, 1227, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1227, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -27558,12 +23147,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1493) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1227) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(204, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(153, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -27573,7 +23162,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(204, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(153, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -27582,143 +23171,176 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 1493, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1227, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(1491isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1226isize); + let __child = self.parse_generated_rule_53_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - let __invoking_marker = self.base.push_invoking_state(1492isize); - let __child = self.parse_generated_rule_67_dispatch(0, false).map_err(GeneratedRuleError::into_error); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(4, 1230, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(1231isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(13, 1234, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1234, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1..=2 | 21 | 27 | 40..=41 | 47 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1234, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1233isize); + let __child = self.parse_generated_rule_55_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } + 2 => { + } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(14, 1237, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - 2 => { - break; + 3 => { + let __invoking_marker = self.base.push_invoking_state(1238isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(25, 1240, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1240isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 4 => { + let __invoking_marker = self.base.push_invoking_state(1242isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - match self.base.sync_decision(atn(), 1499, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1499) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(206, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(206, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1499, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1498isize); - let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_52_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 52, GeneratedRuleError::Fatal; self.parse_generated_rule_52(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_52(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 104isize, 52, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __loop_iter_1248 = false; + loop { + match self.base.sync_decision(atn(), 1248, !__ctx.has_matched_child(), __loop_iter_1248) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=6 | 9 | 11..=13 | 15..=16 | 18 | 20..=21 | 27 | 31 | 33..=34 | 36 | 40..=41 | 43..=45 | 48 | 50 | 52..=55 | 57 | 69 | 98..=100 | 102..=104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 1248, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_1248 = true; + let __invoking_marker = self.base.push_invoking_state(1245isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(1501isize); - let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __invoking_marker = self.base.push_invoking_state(1251isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_65_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_53_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(65) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_65(precedence, allow_fallback)) - } else { - self.parse_generated_rule_65(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(65); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 53, GeneratedRuleError::Fatal; self.parse_generated_rule_53(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_65(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_53(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(130isize, 65); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 9 | 20 | 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 5..=6 | 12 | 21 | 40..=41 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1553, !__ctx.has_matched_child(), false) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 106isize, 53, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(1253isize); + let __child = self.parse_generated_rule_52_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_1258 = false; + loop { + match self.base.sync_decision(atn(), 1258, !__ctx.has_matched_child(), __loop_iter_1258) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -27727,13 +23349,13 @@ where return Err(__error); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1553) { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1258) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(218, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(157, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -27743,7 +23365,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(218, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(157, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -27751,13 +23373,76 @@ where } else { __prediction } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1258, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_1258 = true; + let __match = self.base.match_token_recovering(16, 1255, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1255isize); + let __child = self.parse_generated_rule_52_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1553, &__prediction); - match __prediction.alt { - 1 => { - match self.base.sync_decision(atn(), 1504, !__ctx.has_matched_child(), false) { + match self.base.sync_decision(atn(), 1262, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 1262, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 1263, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_54_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 54, GeneratedRuleError::Fatal; self.parse_generated_rule_54(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_54(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 108isize, 54, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __loop_iter_1267 = false; + loop { + match self.base.sync_decision(atn(), 1267, !__ctx.has_matched_child(), __loop_iter_1267) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -27768,228 +23453,115 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 27 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 9 | 20 | 28 | 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 1..=2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1504, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1267, &__prediction); match __prediction.alt { 1 => { - let __match = self.base.match_token_recovering(27, 1505, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(1506isize); - let __child = self.parse_generated_rule_23_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - match self.base.sync_decision(atn(), 1508, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 27 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 26 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1508, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(27, 1509, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(26, 1511, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1511isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 1513, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 25 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1513, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1512isize); - let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_1267 = true; + let __invoking_marker = self.base.push_invoking_state(1264isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - match self.base.sync_decision(atn(), 1516, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + } + match self.base.sync_decision(atn(), 1271, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1516, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1515isize); - let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } - let __match = self.base.match_token_recovering(25, 1519, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1519isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(10, 1521, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - 3 => { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 27 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1524, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1524) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(211, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(211, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - } - } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1271) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(160, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? }; - self.base.record_generated_prediction_diagnostic(atn(), 1524, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1522isize); - let __child = self.parse_generated_rule_20_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(1523isize); - let __child = self.parse_generated_rule_21_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(160, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction } - } - 4 => { - let __match = self.base.match_token_recovering(26, 1527, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1527isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 1529, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1271, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1270isize); + let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 | 24..=25 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1529, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1528isize); - let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 2 => { } - match self.base.sync_decision(atn(), 1532, !__ctx.has_matched_child(), false) { + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __invoking_marker = self.base.push_invoking_state(1273isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(24, 1275, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1275isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_55_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 55, GeneratedRuleError::Fatal; self.parse_generated_rule_55(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_55(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 110isize, 55, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(1277isize); + let __child = self.parse_generated_rule_54_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_1282 = false; + loop { + match self.base.sync_decision(atn(), 1282, !__ctx.has_matched_child(), __loop_iter_1282) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -27999,12 +23571,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1532) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1282) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(213, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(161, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -28014,7 +23586,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(213, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(161, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -28023,232 +23595,81 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 1532, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1531isize); - let __child = self.parse_generated_rule_94_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 1535, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 | 24..=25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1535, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1534isize); - let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 1539, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 | 25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1539, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1282, &__prediction); match __prediction.alt { 1 => { - let __match = self.base.match_token_recovering(24, 1538, atn())?; + __loop_iter_1282 = true; + let __match = self.base.match_token_recovering(16, 1279, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1538isize); - let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1279isize); + let __child = self.parse_generated_rule_54_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - match self.base.sync_decision(atn(), 1548, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + } + match self.base.sync_decision(atn(), 1286, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 25 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1548, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(25, 1545, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_1545 = false; - loop { - match self.base.sync_decision(atn(), 1545, !__ctx.has_matched_child(), __loop_iter_1545) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1545) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(216, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(216, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1545, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_1545 = true; - let __invoking_marker = self.base.push_invoking_state(1542isize); - let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } - let __match = self.base.match_token_recovering(10, 1551, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - 5 => { - let __invoking_marker = self.base.push_invoking_state(1552isize); - let __child = self.parse_generated_rule_212_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 1286, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 1287, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_66_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_56_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(66) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_66(precedence, allow_fallback)) - } else { - self.parse_generated_rule_66(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(66); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 56, GeneratedRuleError::Fatal; self.parse_generated_rule_56(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_66(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_56(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(132isize, 66); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(47, 1556, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(48, 1560, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_1560 = false; - loop { - match self.base.sync_decision(atn(), 1560, !__ctx.has_matched_child(), __loop_iter_1560) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 112isize, 56, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(40, 1289, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1289isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1291, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -28259,95 +23680,24 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1560, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1291, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1560 = true; - let __invoking_marker = self.base.push_invoking_state(1557isize); - let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1290isize); + let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - let __match = self.base.match_token_recovering(49, 1564, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_67_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(67) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_67(precedence, allow_fallback)) - } else { - self.parse_generated_rule_67(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(67); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_67(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(134isize, 67); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(47, 1566, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(44, 1567, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(48, 1571, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_1571 = false; - loop { - match self.base.sync_decision(atn(), 1571, !__ctx.has_matched_child(), __loop_iter_1571) { + match self.base.sync_decision(atn(), 1294, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -28358,284 +23708,116 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1571, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1294, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1571 = true; - let __invoking_marker = self.base.push_invoking_state(1568isize); - let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1293isize); + let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(13, 1297, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1297isize); + let __child = self.parse_generated_rule_47_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(14, 1299, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __match = self.base.match_token_recovering(49, 1575, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_68_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_57_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(68) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_68(precedence, allow_fallback)) - } else { - self.parse_generated_rule_68(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(68); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 57, GeneratedRuleError::Fatal; self.parse_generated_rule_57(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_68(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_57(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(136isize, 68); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 1..=2 | 5..=12 | 15..=47 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 3 | 13 | 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1578, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 114isize, 57, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 1301, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 1..=2 | 5..=12 | 15..=47 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 3 | 13 | 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1578, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_not_set_recovering(&[(3, 4), (13, 14), (48, 49)], 1, atn().max_token_type(), 1579, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(1577isize); - let __child = self.parse_generated_rule_69_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_69_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(69) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_69(precedence, allow_fallback)) - } else { - self.parse_generated_rule_69(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(69); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_69(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(138isize, 69); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1583, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 20 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 41..=42 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1301, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(20, 1302, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 2 => { } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1583, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1580isize); - let __child = self.parse_generated_rule_70_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(1581isize); - let __child = self.parse_generated_rule_71_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1304, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 3 => { - let __invoking_marker = self.base.push_invoking_state(1582isize); - let __child = self.parse_generated_rule_72_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 41 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 42 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1304, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(41, 1305, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_70_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(70) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_70(precedence, allow_fallback)) - } else { - self.parse_generated_rule_70(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(70); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_70(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(140isize, 70); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(3, 1589, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_1589 = false; - loop { - match self.base.sync_decision(atn(), 1589, !__ctx.has_matched_child(), __loop_iter_1589) { + let __match = self.base.match_token_recovering(42, 1307, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1307isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1309, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -28646,89 +23828,24 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 | 24 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1589, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1309, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1589 = true; - let __invoking_marker = self.base.push_invoking_state(1586isize); - let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1308isize); + let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - let __match = self.base.match_token_recovering(4, 1593, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_71_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(71) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_71(precedence, allow_fallback)) - } else { - self.parse_generated_rule_71(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(71); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_71(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(142isize, 71); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(48, 1598, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_1598 = false; - loop { - match self.base.sync_decision(atn(), 1598, !__ctx.has_matched_child(), __loop_iter_1598) { + match self.base.sync_decision(atn(), 1312, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -28739,89 +23856,24 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1598, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1312, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1598 = true; - let __invoking_marker = self.base.push_invoking_state(1595isize); - let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1311isize); + let __child = self.parse_generated_rule_94_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - let __match = self.base.match_token_recovering(49, 1602, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_72_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(72) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_72(precedence, allow_fallback)) - } else { - self.parse_generated_rule_72(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(72); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_72(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(144isize, 72); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(13, 1607, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_1607 = false; - loop { - match self.base.sync_decision(atn(), 1607, !__ctx.has_matched_child(), __loop_iter_1607) { + match self.base.sync_decision(atn(), 1315, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -28832,196 +23884,29 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1607, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1315, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1607 = true; - let __invoking_marker = self.base.push_invoking_state(1604isize); - let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1314isize); + let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - let __match = self.base.match_token_recovering(14, 1611, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_73_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(73) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_73(precedence, allow_fallback)) - } else { - self.parse_generated_rule_73(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(73); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_73(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(146isize, 73); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(44, 1613, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1613isize); - let __child = self.parse_generated_rule_69_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_74_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(74) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_74(precedence, allow_fallback)) - } else { - self.parse_generated_rule_74(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(74); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_74(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(148isize, 74); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 12 | 50 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1621, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1621) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(227, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(227, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1621, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1615isize); - let __child = self.parse_generated_rule_78_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - match self.base.sync_decision(atn(), 1617, !__ctx.has_matched_child(), false) { + let __match = self.base.match_token_recovering(13, 1321, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_1321 = false; + loop { + match self.base.sync_decision(atn(), 1321, !__ctx.has_matched_child(), __loop_iter_1321) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -29031,12 +23916,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1617) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1321) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(226, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(170, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -29046,7 +23931,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(226, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(170, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -29055,148 +23940,25 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 1617, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1321, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(1616isize); - let __child = self.parse_generated_rule_75_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_1321 = true; + let __invoking_marker = self.base.push_invoking_state(1318isize); + let __child = self.parse_generated_rule_67_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __match = self.base.match_token_recovering(12, 1620, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1620isize); - let __child = self.parse_generated_rule_78_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_75_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(75) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_75_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_75_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(75); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_75(&mut self, allow_fallback: bool) -> Result { - self.parse_generated_rule_75_precedence(0, allow_fallback) - } - - #[allow(dead_code)] - fn parse_generated_rule_75_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(150isize, 75, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 50 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 6 | 21 | 27 | 40..=41 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 12 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1635, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1635) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(229, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(229, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1635, &__prediction); - match __prediction.alt { - 1 => { - let action = self.base.parser_action_at_current_indexed(1623, 75, 0, __rule_start, __consumed_eof); - let _ = action; - let __match = self.base.match_token_recovering(5, 1636, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - 2 => { - let __match = self.base.match_token_recovering(50, 1626, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1626isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 1628, !__ctx.has_matched_child(), false) { + let mut __loop_iter_1327 = false; + loop { + match self.base.sync_decision(atn(), 1327, !__ctx.has_matched_child(), __loop_iter_1327) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -29207,469 +23969,59 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 17 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 1..=2 | 5..=6 | 9 | 12 | 20..=21 | 26..=28 | 30..=31 | 40..=41 | 47 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1628, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1327, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(1627isize); - let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_1327 = true; + let __invoking_marker = self.base.push_invoking_state(1324isize); + let __child = self.parse_generated_rule_59_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __match = self.base.match_token_recovering(51, 1631, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __invoking_marker = self.base.push_invoking_state(1632isize); - let __child = self.parse_generated_rule_77_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 4 => { - let __match = self.base.match_token_recovering(12, 1634, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1634isize); - let __child = self.parse_generated_rule_77_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 1642, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(230, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - let __prediction = if __prediction.alt == 1 { - let __semantic_la = self.base.la(1); - if __semantic_la == 12 { - __prediction - } else { - antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } - } - } else { - __prediction - }; - self.base.record_generated_prediction_diagnostic(atn(), 1642, &__prediction); - match __prediction.alt { - 1 => { - self.base.parse_listener_exit_rule(75); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); - } - self.base.push_new_recursion_context_with_previous(150isize, 75, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(75) { - return Err(__listener_error); - } - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); - } - let __match = self.base.match_token_recovering(12, 1639, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1639isize); - let __child = self.parse_generated_rule_77_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => break, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_76_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(76) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_76(precedence, allow_fallback)) - } else { - self.parse_generated_rule_76(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(76); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_76(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(152isize, 76); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(17, 1646, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1646isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_77_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(77) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_77(precedence, allow_fallback)) - } else { - self.parse_generated_rule_77(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(77); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_77(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(154isize, 77); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2 | 5 | 21 | 27 | 40..=41 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1650, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1650) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(231, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(231, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1650, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1648isize); - let __child = self.parse_generated_rule_78_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(6, 1651, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_78_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(78) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_78(precedence, allow_fallback)) - } else { - self.parse_generated_rule_78(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(78); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_78(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(156isize, 78); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(1652isize); - let __child = self.parse_generated_rule_80_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 1655, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1655) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(232, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(232, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1655, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(12, 1654, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1654isize); - let __child = self.parse_generated_rule_115_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __match = self.base.match_token_recovering(14, 1331, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_79_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_58_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(79) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_79(precedence, allow_fallback)) - } else { - self.parse_generated_rule_79(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(79); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 58, GeneratedRuleError::Fatal; self.parse_generated_rule_58(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_79(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_58(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(158isize, 79); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 1658, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 5..=6 | 21 | 27 | 40..=41 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1658, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(12, 1659, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(1660isize); - let __child = self.parse_generated_rule_80_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_1665 = false; - loop { - match self.base.sync_decision(atn(), 1665, !__ctx.has_matched_child(), __loop_iter_1665) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 116isize, 58, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(42, 1333, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1333isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1335, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -29680,316 +24032,27 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 44 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1665, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1335, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1665 = true; - let __match = self.base.match_token_recovering(12, 1662, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1662isize); - let __child = self.parse_generated_rule_80_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1334isize); + let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_80_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(80) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_80(precedence, allow_fallback)) - } else { - self.parse_generated_rule_80(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(80); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_80(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(160isize, 80); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 5 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 6 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 52 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 53 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1674, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1674) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(235, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(235, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1674, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1668isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(5, 1675, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __match = self.base.match_token_recovering(6, 1675, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 4 => { - let __match = self.base.match_token_recovering(52, 1675, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 5 => { - let __match = self.base.match_token_recovering(2, 1675, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 6 => { - let __match = self.base.match_token_recovering(53, 1675, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_81_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(81) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_81(precedence, allow_fallback)) - } else { - self.parse_generated_rule_81(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(81); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_81(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(162isize, 81); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(45, 1677, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(50, 1679, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 1679, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 | 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1679, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1678isize); - let __child = self.parse_generated_rule_82_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(51, 1682, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_82_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(82) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_82(precedence, allow_fallback)) - } else { - self.parse_generated_rule_82(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(82); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_82(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(164isize, 82); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(1683isize); - let __child = self.parse_generated_rule_83_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_1688 = false; - loop { - match self.base.sync_decision(atn(), 1688, !__ctx.has_matched_child(), __loop_iter_1688) { + let __match = self.base.match_token_recovering(25, 1343, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1343, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -29999,12 +24062,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1688) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1343) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(237, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(174, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -30014,7 +24077,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(237, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(174, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -30023,557 +24086,336 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 1688, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1343, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1688 = true; - let __match = self.base.match_token_recovering(16, 1685, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1685isize); - let __child = self.parse_generated_rule_83_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1338isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1340, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1340, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1339isize); + let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - match self.base.sync_decision(atn(), 1692, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 1692, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 1693, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_83_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(83) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_83(precedence, allow_fallback)) - } else { - self.parse_generated_rule_83(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(83); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_83(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(166isize, 83); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __loop_iter_1697 = false; - loop { - match self.base.sync_decision(atn(), 1697, !__ctx.has_matched_child(), __loop_iter_1697) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1697, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_1697 = true; - let __invoking_marker = self.base.push_invoking_state(1694isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1342isize); + let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } - 2 => { - break; - } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(10, 1346, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __invoking_marker = self.base.push_invoking_state(1700isize); - let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 1703, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 16 | 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 1703, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(24, 1702, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1702isize); - let __child = self.parse_generated_rule_84_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_84_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(84) { - return Err(GeneratedRuleError::Fatal(error)); + success {} + recovery {} } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_84_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_84_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(84); - __listener_result } #[allow(dead_code)] - fn parse_generated_rule_84(&mut self, allow_fallback: bool) -> Result { - self.parse_generated_rule_84_precedence(0, allow_fallback) + fn parse_generated_rule_59_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 59, GeneratedRuleError::Fatal; self.parse_generated_rule_59(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_84_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(168isize, 84, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let action = self.base.parser_action_at_current_indexed(1705, 84, 1, __rule_start, __consumed_eof); - let _ = action; - let __invoking_marker = self.base.push_invoking_state(1706isize); - let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 1713, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(241, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), + fn parse_generated_rule_59(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 118isize, 59, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 26 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 9 | 20 | 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 5..=6 | 12 | 21 | 40..=41 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1429, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1429) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(194, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(194, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } } }; - let __prediction = if __prediction.alt == 1 { - let __semantic_la = self.base.la(1); - if __semantic_la == 54 { - __prediction - } else { - antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } - } - } else { - __prediction - }; - self.base.record_generated_prediction_diagnostic(atn(), 1713, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1429, &__prediction); match __prediction.alt { 1 => { - self.base.parse_listener_exit_rule(84); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); - } - self.base.push_new_recursion_context_with_previous(168isize, 84, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(84) { - return Err(__listener_error); - } - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); - } - let __match = self.base.match_token_recovering(54, 1710, atn())?; + let mut __loop_iter_1350 = false; + loop { + match self.base.sync_decision(atn(), 1350, !__ctx.has_matched_child(), __loop_iter_1350) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 1..=2 | 26..=27 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1350, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_1350 = true; + let __invoking_marker = self.base.push_invoking_state(1347isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + match self.base.sync_decision(atn(), 1354, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 27 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 1..=2 | 26 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1354, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(27, 1355, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 1357, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1..=2 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 26 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1357, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1356isize); + let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(26, 1360, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1710isize); - let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1360isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); - } - 2 => break, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_85_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(85) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_85(precedence, allow_fallback)) - } else { - self.parse_generated_rule_85(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(85); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_85(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(170isize, 85); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 5..=6 | 12 | 50 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1722, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + match self.base.sync_decision(atn(), 1362, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1722) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(243, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 | 24..=25 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(243, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1722, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1716isize); - let __child = self.parse_generated_rule_86_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - match self.base.sync_decision(atn(), 1718, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + self.base.record_generated_prediction_diagnostic(atn(), 1362, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1361isize); + let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + match self.base.sync_decision(atn(), 1365, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1718) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(242, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 | 25 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(242, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1718, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1717isize); - let __child = self.parse_generated_rule_87_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + self.base.record_generated_prediction_diagnostic(atn(), 1365, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1364isize); + let __child = self.parse_generated_rule_94_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => { + match self.base.sync_decision(atn(), 1368, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(12, 1721, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1721isize); - let __child = self.parse_generated_rule_86_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_86_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(86) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_86(precedence, allow_fallback)) - } else { - self.parse_generated_rule_86(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(86); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_86(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(172isize, 86); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 3 | 33 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1737, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 | 25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1368, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1367isize); + let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + match self.base.sync_decision(atn(), 1371, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1737) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(247, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 25 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(247, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + self.base.record_generated_prediction_diagnostic(atn(), 1371, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1370isize); + let __child = self.parse_generated_rule_60_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(10, 1374, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1737, &__prediction); - match __prediction.alt { - 1 => { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1726, !__ctx.has_matched_child(), false) { + 2 => { + let mut __loop_iter_1378 = false; + loop { + match self.base.sync_decision(atn(), 1378, !__ctx.has_matched_child(), __loop_iter_1378) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -30582,558 +24424,754 @@ where return Err(__error); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 27..=28 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1378, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_1378 = true; + let __invoking_marker = self.base.push_invoking_state(1375isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1726, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1724isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(52, 1727, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(3, 1730, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 1730, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + match self.base.sync_decision(atn(), 1382, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1730) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(245, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 27 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 28 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(245, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + self.base.record_generated_prediction_diagnostic(atn(), 1382, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(27, 1383, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1730, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1729isize); - let __child = self.parse_generated_rule_118_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(28, 1385, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1385isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(24, 1387, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1387isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1389, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 25 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1389, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1388isize); + let __child = self.parse_generated_rule_61_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __match = self.base.match_token_recovering(10, 1392, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __match = self.base.match_token_recovering(4, 1734, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 1734, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + 3 => { + let mut __loop_iter_1396 = false; + loop { + match self.base.sync_decision(atn(), 1396, !__ctx.has_matched_child(), __loop_iter_1396) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 1..=2 | 9 | 20 | 27..=28 | 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1396, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_1396 = true; + let __invoking_marker = self.base.push_invoking_state(1393isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + match self.base.sync_decision(atn(), 1400, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1734) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(246, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 27 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 1..=2 | 9 | 20 | 28 | 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(246, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + self.base.record_generated_prediction_diagnostic(atn(), 1400, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(27, 1401, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1734, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1733isize); - let __child = self.parse_generated_rule_39_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1403, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1..=2 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 9 | 20 | 28 | 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1403, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1402isize); + let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __invoking_marker = self.base.push_invoking_state(1405isize); + let __child = self.parse_generated_rule_24_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(1736isize); - let __child = self.parse_generated_rule_89_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_87_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(87) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_87_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_87_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(87); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_87(&mut self, allow_fallback: bool) -> Result { - self.parse_generated_rule_87_precedence(0, allow_fallback) - } - - #[allow(dead_code)] - fn parse_generated_rule_87_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(174isize, 87, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 5 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 50 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 6 | 21 | 27 | 33 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 12 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1751, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + 4 => { + let mut __loop_iter_1409 = false; + loop { + match self.base.sync_decision(atn(), 1409, !__ctx.has_matched_child(), __loop_iter_1409) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 1..=2 | 5..=6 | 12 | 21 | 27 | 40..=41 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1409, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_1409 = true; + let __invoking_marker = self.base.push_invoking_state(1406isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 5 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 50 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 6 | 21 | 27 | 33 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 12 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1751, &__prediction); - match __prediction.alt { - 1 => { - let action = self.base.parser_action_at_current_indexed(1739, 87, 2, __rule_start, __consumed_eof); - let _ = action; - let __match = self.base.match_token_recovering(5, 1752, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __match = self.base.match_token_recovering(50, 1742, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1742isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 1744, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1413, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1413) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(189, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(189, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1413, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(27, 1414, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 17 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1744, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1743isize); - let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1416, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1416) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(190, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(190, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1416, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1415isize); + let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __invoking_marker = self.base.push_invoking_state(1418isize); + let __child = self.parse_generated_rule_212_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(51, 1747, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __invoking_marker = self.base.push_invoking_state(1748isize); - let __child = self.parse_generated_rule_88_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 4 => { - let __match = self.base.match_token_recovering(12, 1750, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1750isize); - let __child = self.parse_generated_rule_88_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 1758, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(250, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), + 5 => { + match self.base.sync_decision(atn(), 1420, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - }; - let __prediction = if __prediction.alt == 1 { - let __semantic_la = self.base.la(1); - if __semantic_la == 12 { - __prediction - } else { - antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } - } - } else { - __prediction - }; - self.base.record_generated_prediction_diagnostic(atn(), 1758, &__prediction); - match __prediction.alt { - 1 => { - self.base.parse_listener_exit_rule(87); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1420) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(191, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(191, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1420, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(27, 1421, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - self.base.push_new_recursion_context_with_previous(174isize, 87, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(87) { - return Err(__listener_error); + match self.base.sync_decision(atn(), 1423, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1..=2 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 27..=28 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1423, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1422isize); + let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 27 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1427, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1427) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(193, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(193, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1427, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1425isize); + let __child = self.parse_generated_rule_20_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(1426isize); + let __child = self.parse_generated_rule_21_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __match = self.base.match_token_recovering(12, 1755, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1755isize); - let __child = self.parse_generated_rule_88_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); } - 2 => break, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_88_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_60_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(88) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_88(precedence, allow_fallback)) - } else { - self.parse_generated_rule_88(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(88); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 60, GeneratedRuleError::Fatal; self.parse_generated_rule_60(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_88(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_60(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(176isize, 88); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2..=3 | 21 | 27 | 33 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 6 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1763, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 2..=3 | 21 | 27 | 33 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 6 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1763, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1761isize); - let __child = self.parse_generated_rule_89_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(6, 1764, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 120isize, 60, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(25, 1432, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1432isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_89_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_61_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(89) { - return Err(GeneratedRuleError::Fatal(error)); + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 61, GeneratedRuleError::Fatal; self.parse_generated_rule_61(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_61(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 122isize, 61, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(25, 1435, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1435isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + success {} + recovery {} } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_89(precedence, allow_fallback)) - } else { - self.parse_generated_rule_89(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(89); - __listener_result } #[allow(dead_code)] - fn parse_generated_rule_89(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_62_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 62, GeneratedRuleError::Fatal; self.parse_generated_rule_62(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_62(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(178isize, 89); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 27 | 33 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1783, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 124isize, 62, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 1438, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 27 | 33 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1783, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(3, 1768, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 1768, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 27 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 20 | 34 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1438, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(27, 1439, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 1441, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 20 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 34 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1441, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(20, 1442, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(34, 1445, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1445, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1445) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(197, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? }; - self.base.record_generated_prediction_diagnostic(atn(), 1768, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1766isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(52, 1769, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(197, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1445, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1444isize); + let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 1448, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1448) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(198, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(198, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction } - let __match = self.base.match_token_recovering(4, 1772, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 1772, !__ctx.has_matched_child(), false) { + }; + self.base.record_generated_prediction_diagnostic(atn(), 1448, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(43, 1449, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 1451, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 28 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=6 | 9 | 11..=13 | 15 | 18 | 20..=21 | 27 | 31 | 33..=34 | 36 | 40..=41 | 43..=45 | 48 | 50 | 52..=57 | 69 | 98..=100 | 102..=104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1451, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(28, 1452, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __invoking_marker = self.base.push_invoking_state(1453isize); + let __child = self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1455, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1455, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1454isize); + let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(13, 1461, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_1461 = false; + loop { + match self.base.sync_decision(atn(), 1461, !__ctx.has_matched_child(), __loop_iter_1461) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -31143,12 +25181,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1772) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1461) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(253, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(201, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -31158,7 +25196,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(253, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(201, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -31167,285 +25205,80 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 1772, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1461, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(1771isize); - let __child = self.parse_generated_rule_115_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_1461 = true; + let __invoking_marker = self.base.push_invoking_state(1458isize); + let __child = self.parse_generated_rule_67_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - 2 => { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let mut __loop_iter_1467 = false; + loop { + match self.base.sync_decision(atn(), 1467, !__ctx.has_matched_child(), __loop_iter_1467) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 33 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1778, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 33 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1778, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1774isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(52, 1779, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __match = self.base.match_token_recovering(33, 1777, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(55, 1779, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } + 1..=2 | 5..=6 | 9 | 12 | 20..=21 | 26..=28 | 30..=31 | 40..=41 | 47 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 1781, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1781) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(255, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(255, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } }; - self.base.record_generated_prediction_diagnostic(atn(), 1781, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1467, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(1780isize); - let __child = self.parse_generated_rule_115_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_1467 = true; + let __invoking_marker = self.base.push_invoking_state(1464isize); + let __child = self.parse_generated_rule_64_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_90_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(90) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_90(precedence, allow_fallback)) - } else { - self.parse_generated_rule_90(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(90); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_90(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(180isize, 90); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(56, 1787, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 1787, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1787) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(257, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(257, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1787, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1786isize); - let __child = self.parse_generated_rule_91_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __match = self.base.match_token_recovering(14, 1471, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_91_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_63_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(91) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_91(precedence, allow_fallback)) - } else { - self.parse_generated_rule_91(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(91); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 63, GeneratedRuleError::Fatal; self.parse_generated_rule_63(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_91(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_63(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(182isize, 91); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(1789isize); - let __child = self.parse_generated_rule_92_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_1794 = false; - loop { - match self.base.sync_decision(atn(), 1794, !__ctx.has_matched_child(), __loop_iter_1794) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 126isize, 63, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 1489, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -31455,12 +25288,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1794) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1489) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(258, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(203, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -31470,7 +25303,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(258, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(203, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -31479,177 +25312,99 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 1794, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1489, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1794 = true; - let __match = self.base.match_token_recovering(16, 1791, atn())?; + let __match = self.base.match_token_recovering(44, 1473, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1473isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(45, 1475, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1791isize); - let __child = self.parse_generated_rule_92_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1475isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; + let __invoking_marker = self.base.push_invoking_state(1477isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(45, 1479, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1479isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 3 => { + let __invoking_marker = self.base.push_invoking_state(1481isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(45, 1483, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(46, 1484, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 4 => { + let __invoking_marker = self.base.push_invoking_state(1485isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(1486isize); + let __child = self.parse_generated_rule_115_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 5 => { + let __invoking_marker = self.base.push_invoking_state(1488isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - match self.base.sync_decision(atn(), 1798, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1798) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(259, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(259, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1798, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 1799, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_92_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_64_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(92) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_92(precedence, allow_fallback)) - } else { - self.parse_generated_rule_92(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(92); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 64, GeneratedRuleError::Fatal; self.parse_generated_rule_64(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_92(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_64(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(184isize, 92); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 1811, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1811) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(262, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(262, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1811, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1800isize); - let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(24, 1802, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1802isize); - let __child = self.parse_generated_rule_84_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - match self.base.sync_decision(atn(), 1805, !__ctx.has_matched_child(), false) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 128isize, 64, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __loop_iter_1495 = false; + loop { + match self.base.sync_decision(atn(), 1495, !__ctx.has_matched_child(), __loop_iter_1495) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -31659,576 +25414,650 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1805) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(260, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(260, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1805, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1804isize); - let __child = self.parse_generated_rule_81_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 1..=2 | 5..=6 | 9 | 12 | 20..=21 | 26..=28 | 30..=31 | 40..=41 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(1807isize); - let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 1809, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1809) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(261, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(261, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } }; - self.base.record_generated_prediction_diagnostic(atn(), 1809, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1495, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(1808isize); - let __child = self.parse_generated_rule_93_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + __loop_iter_1495 = true; + match self.base.sync_decision(atn(), 1493, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1493) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(204, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(204, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1493, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1491isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(1492isize); + let __child = self.parse_generated_rule_67_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_93_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(93) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_93(precedence, allow_fallback)) - } else { - self.parse_generated_rule_93(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(93); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_93(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(186isize, 93); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(24, 1815, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 1815, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + match self.base.sync_decision(atn(), 1499, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1815) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(263, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(263, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1499) { __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(206, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(206, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1499, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1498isize); + let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1815, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1814isize); - let __child = self.parse_generated_rule_95_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __invoking_marker = self.base.push_invoking_state(1501isize); + let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_94_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_65_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(94) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_94(precedence, allow_fallback)) - } else { - self.parse_generated_rule_94(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(94); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 65, GeneratedRuleError::Fatal; self.parse_generated_rule_65(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_94(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_65(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(188isize, 94); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(24, 1818, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1818isize); - let __child = self.parse_generated_rule_95_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_95_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(95) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_95_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_95_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(95); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_95(&mut self, allow_fallback: bool) -> Result { - self.parse_generated_rule_95_precedence(0, allow_fallback) - } - - #[allow(dead_code)] - fn parse_generated_rule_95_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(190isize, 95, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let action = self.base.parser_action_at_current_indexed(1820, 95, 3, __rule_start, __consumed_eof); - let _ = action; - let __invoking_marker = self.base.push_invoking_state(1821isize); - let __child = self.parse_generated_rule_96_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 1841, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(266, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 130isize, 65, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 9 | 20 | 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 5..=6 | 12 | 21 | 40..=41 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1553, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1553) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(218, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(218, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } } }; - self.base.record_generated_prediction_diagnostic(atn(), 1841, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1553, &__prediction); match __prediction.alt { 1 => { - self.base.parse_listener_exit_rule(95); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); - } - self.base.push_new_recursion_context_with_previous(190isize, 95, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(95) { - return Err(__listener_error); + match self.base.sync_decision(atn(), 1504, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(265, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __prediction = match self.base.la(1) { + 27 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 9 | 20 | 28 | 30..=31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if self.base.report_diagnostic_errors() { - let __diagnostic_la = self.base.la(1); - let mut __diagnostic_alts = Vec::new(); - if __diagnostic_la == 54 { - __diagnostic_alts.push(1); + self.base.record_generated_prediction_diagnostic(atn(), 1504, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(27, 1505, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - if __diagnostic_la == 50 { - __diagnostic_alts.push(2); + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __invoking_marker = self.base.push_invoking_state(1506isize); + let __child = self.parse_generated_rule_23_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + match self.base.sync_decision(atn(), 1508, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } - self.base.record_generated_ambiguity_diagnostic(atn(), 1839, __decision_start, __decision_start, &__diagnostic_alts); } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 27 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 26 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1508, &__prediction); match __prediction.alt { 1 => { - if !self.base.precpred(2) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 2)")); - } - let __match = self.base.match_token_recovering(54, 1825, atn())?; + let __match = self.base.match_token_recovering(27, 1509, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1825isize); - let __child = self.parse_generated_rule_96_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); } 2 => { - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); - } - let __match = self.base.match_token_recovering(50, 1833, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_1833 = false; - loop { - match self.base.sync_decision(atn(), 1833, !__ctx.has_matched_child(), __loop_iter_1833) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(264, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - self.base.record_generated_prediction_diagnostic(atn(), 1833, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_1833 = true; - let __invoking_marker = self.base.push_invoking_state(1828isize); - let __child = self.parse_generated_rule_120_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(16, 1830, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - let __invoking_marker = self.base.push_invoking_state(1836isize); - let __child = self.parse_generated_rule_123_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(51, 1838, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - 2 => break, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_96_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(96) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_96(precedence, allow_fallback)) - } else { - self.parse_generated_rule_96(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(96); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_96(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(192isize, 96); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 1856, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1856) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(270, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(270, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1856, &__prediction); - match __prediction.alt { - 1 => { - } - 2 => { - match self.base.sync_decision(atn(), 1846, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(26, 1511, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1511isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1513, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 25 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1513, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1512isize); + let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 1516, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1516, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1515isize); + let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(25, 1519, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1519isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(10, 1521, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 43 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=6 | 12 | 21 | 27 | 33..=34 | 40..=41 | 45 | 50 | 52 | 55 | 57 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1846, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(43, 1847, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + 3 => { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 27 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1524, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1524) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(211, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(211, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1524, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1522isize); + let __child = self.parse_generated_rule_20_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(1523isize); + let __child = self.parse_generated_rule_21_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => { + } + 4 => { + let __match = self.base.match_token_recovering(26, 1527, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1527isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1529, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 | 24..=25 | 56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1529, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1528isize); + let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 1532, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1532) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(213, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(213, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1532, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1531isize); + let __child = self.parse_generated_rule_94_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 1535, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 | 24..=25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1535, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1534isize); + let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 1539, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 | 25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1539, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(24, 1538, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1538isize); + let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 1548, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 25 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1548, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(25, 1545, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_1545 = false; + loop { + match self.base.sync_decision(atn(), 1545, !__ctx.has_matched_child(), __loop_iter_1545) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1545) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(216, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(216, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1545, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_1545 = true; + let __invoking_marker = self.base.push_invoking_state(1542isize); + let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(10, 1551, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 5 => { + let __invoking_marker = self.base.push_invoking_state(1552isize); + let __child = self.parse_generated_rule_212_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 1849, !__ctx.has_matched_child(), false) { + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_66_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 66, GeneratedRuleError::Fatal; self.parse_generated_rule_66(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_66(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 132isize, 66, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(47, 1556, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(48, 1560, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_1560 = false; + loop { + match self.base.sync_decision(atn(), 1560, !__ctx.has_matched_child(), __loop_iter_1560) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -32239,24 +26068,62 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 45 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=6 | 12 | 21 | 27 | 33..=34 | 40..=41 | 50 | 52 | 55 | 57 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1849, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1560, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(1848isize); - let __child = self.parse_generated_rule_81_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_1560 = true; + let __invoking_marker = self.base.push_invoking_state(1557isize); + let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - match self.base.sync_decision(atn(), 1852, !__ctx.has_matched_child(), false) { + } + let __match = self.base.match_token_recovering(49, 1564, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_67_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 67, GeneratedRuleError::Fatal; self.parse_generated_rule_67(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_67(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 134isize, 67, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(47, 1566, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(44, 1567, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(48, 1571, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_1571 = false; + loop { + match self.base.sync_decision(atn(), 1571, !__ctx.has_matched_child(), __loop_iter_1571) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -32267,138 +26134,185 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 34 | 57 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=6 | 12 | 21 | 27 | 33 | 40..=41 | 50 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1852, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1571, &__prediction); match __prediction.alt { 1 => { - let __match = self.base.match_set_recovering(&[(34, 34), (57, 57)], 1853, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + __loop_iter_1571 = true; + let __invoking_marker = self.base.push_invoking_state(1568isize); + let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __invoking_marker = self.base.push_invoking_state(1854isize); - let __child = self.parse_generated_rule_85_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 3 => { - let __invoking_marker = self.base.push_invoking_state(1855isize); - let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __match = self.base.match_token_recovering(49, 1575, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_97_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_68_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(97) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_97(precedence, allow_fallback)) - } else { - self.parse_generated_rule_97(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(97); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 68, GeneratedRuleError::Fatal; self.parse_generated_rule_68(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_97(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_68(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(194isize, 97); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 1873, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 136isize, 68, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1..=2 | 5..=12 | 15..=47 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 3 | 13 | 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1578, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 1..=2 | 5..=12 | 15..=47 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 3 | 13 | 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1578, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_not_set_recovering(&[(3, 4), (13, 14), (48, 49)], 1, atn().max_token_type(), 1579, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(1577isize); + let __child = self.parse_generated_rule_69_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1873) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(273, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_69_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 69, GeneratedRuleError::Fatal; self.parse_generated_rule_69(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_69(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 138isize, 69, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1583, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(273, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1873, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1858isize); - let __child = self.parse_generated_rule_98_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + self.base.record_generated_prediction_diagnostic(atn(), 1583, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1580isize); + let __child = self.parse_generated_rule_70_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(1581isize); + let __child = self.parse_generated_rule_71_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 3 => { + let __invoking_marker = self.base.push_invoking_state(1582isize); + let __child = self.parse_generated_rule_72_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => { - let __match = self.base.match_token_recovering(36, 1861, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 1861, !__ctx.has_matched_child(), false) { + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_70_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 70, GeneratedRuleError::Fatal; self.parse_generated_rule_70(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_70(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 140isize, 70, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(3, 1589, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_1589 = false; + loop { + match self.base.sync_decision(atn(), 1589, !__ctx.has_matched_child(), __loop_iter_1589) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -32408,44 +26322,57 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1861) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(271, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(271, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } + let __prediction = match self.base.la(1) { + 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1861, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1589, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(1860isize); - let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_1589 = true; + let __invoking_marker = self.base.push_invoking_state(1586isize); + let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - match self.base.sync_decision(atn(), 1864, !__ctx.has_matched_child(), false) { + } + let __match = self.base.match_token_recovering(4, 1593, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_71_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 71, GeneratedRuleError::Fatal; self.parse_generated_rule_71(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_71(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 142isize, 71, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(48, 1598, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_1598 = false; + loop { + match self.base.sync_decision(atn(), 1598, !__ctx.has_matched_child(), __loop_iter_1598) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -32455,142 +26382,57 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1864) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(272, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(272, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } + let __prediction = match self.base.la(1) { + 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1864, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1598, &__prediction); match __prediction.alt { 1 => { - let __match = self.base.match_token_recovering(23, 1865, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + __loop_iter_1598 = true; + let __invoking_marker = self.base.push_invoking_state(1595isize); + let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __invoking_marker = self.base.push_invoking_state(1866isize); - let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 3 => { - let __invoking_marker = self.base.push_invoking_state(1867isize); - let __child = self.parse_generated_rule_105_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 4 => { - let __invoking_marker = self.base.push_invoking_state(1868isize); - let __child = self.parse_generated_rule_110_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); } - 5 => { - let __match = self.base.match_token_recovering(13, 1870, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1870isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(14, 1872, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __match = self.base.match_token_recovering(49, 1602, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_98_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_72_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(98) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_98(precedence, allow_fallback)) - } else { - self.parse_generated_rule_98(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(98); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 72, GeneratedRuleError::Fatal; self.parse_generated_rule_72(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_98(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_72(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(196isize, 98); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 34 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 43 | 50 | 57 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 44 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 15 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 48 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 18 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 9 | 20 | 31 => antlr4_runtime::ParserAtnPrediction { alt: 10, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 53 => antlr4_runtime::ParserAtnPrediction { alt: 11, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1889, !__ctx.has_matched_child(), false) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 144isize, 72, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(13, 1607, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_1607 = false; + loop { + match self.base.sync_decision(atn(), 1607, !__ctx.has_matched_child(), __loop_iter_1607) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -32599,985 +26441,511 @@ where return Err(__error); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1889) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(274, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(274, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1607, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_1607 = true; + let __invoking_marker = self.base.push_invoking_state(1604isize); + let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1889, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1875isize); - let __child = self.parse_generated_rule_106_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(1876isize); - let __child = self.parse_generated_rule_107_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 3 => { - let __match = self.base.match_token_recovering(3, 1878, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1878isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(4, 1880, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 4 => { - let __invoking_marker = self.base.push_invoking_state(1881isize); - let __child = self.parse_generated_rule_104_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 5 => { - let __invoking_marker = self.base.push_invoking_state(1882isize); - let __child = self.parse_generated_rule_103_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 6 => { - let __invoking_marker = self.base.push_invoking_state(1883isize); - let __child = self.parse_generated_rule_102_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 7 => { - let __invoking_marker = self.base.push_invoking_state(1884isize); - let __child = self.parse_generated_rule_101_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 8 => { - let __invoking_marker = self.base.push_invoking_state(1885isize); - let __child = self.parse_generated_rule_100_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 9 => { - let __invoking_marker = self.base.push_invoking_state(1886isize); - let __child = self.parse_generated_rule_99_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 10 => { - let __invoking_marker = self.base.push_invoking_state(1887isize); - let __child = self.parse_generated_rule_112_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 11 => { - let __invoking_marker = self.base.push_invoking_state(1888isize); - let __child = self.parse_generated_rule_213_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_99_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(99) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_99(precedence, allow_fallback)) - } else { - self.parse_generated_rule_99(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(99); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_99(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(198isize, 99); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(18, 1892, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __match = self.base.match_token_recovering(14, 1611, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_100_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_73_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(100) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_100(precedence, allow_fallback)) - } else { - self.parse_generated_rule_100(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(100); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 73, GeneratedRuleError::Fatal; self.parse_generated_rule_73(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_100(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_73(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(200isize, 100); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(48, 1894, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1894isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 1897, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 10 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1897, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(10, 1896, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1896isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(49, 1900, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 146isize, 73, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(44, 1613, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1613isize); + let __child = self.parse_generated_rule_69_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_101_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_74_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(101) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_101(precedence, allow_fallback)) - } else { - self.parse_generated_rule_101(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(101); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 74, GeneratedRuleError::Fatal; self.parse_generated_rule_74(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_101(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_74(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(202isize, 101); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(33, 1903, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 1903, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1903) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(276, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(276, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1903, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1902isize); - let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 1906, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1906) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(277, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 148isize, 74, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 12 | 50 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1621, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1621) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(227, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(227, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } + } }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(277, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1906, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(23, 1907, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { + self.base.record_generated_prediction_diagnostic(atn(), 1621, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1615isize); + let __child = self.parse_generated_rule_78_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + match self.base.sync_decision(atn(), 1617, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1617) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(226, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(226, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1617, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1616isize); + let __child = self.parse_generated_rule_75_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(12, 1620, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1620isize); + let __child = self.parse_generated_rule_78_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(1908isize); - let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_102_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(102) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_102(precedence, allow_fallback)) - } else { - self.parse_generated_rule_102(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(102); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_102(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(204isize, 102); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(15, 1911, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1911isize); - let __child = self.parse_generated_rule_113_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __invoking_marker = self.base.push_invoking_state(1912isize); - let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_103_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(103) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_103(precedence, allow_fallback)) - } else { - self.parse_generated_rule_103(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(103); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_103(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(206isize, 103); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(44, 1915, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } + fn parse_generated_rule_75_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 75, GeneratedRuleError::Fatal; self.parse_generated_rule_75_precedence(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_104_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(104) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_104(precedence, allow_fallback)) - } else { - self.parse_generated_rule_104(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(104); - __listener_result + fn parse_generated_rule_75(&mut self, allow_fallback: bool) -> Result { + self.parse_generated_rule_75_precedence(0, allow_fallback) } #[allow(dead_code)] - fn parse_generated_rule_104(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(208isize, 104); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 1926, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1926) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(279, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + fn parse_generated_rule_75_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 150isize, 75, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 50 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 6 | 21 | 27 | 40..=41 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 12 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1635, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1635) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(229, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(229, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } + } }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(279, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1926, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(3, 1917, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(4, 1927, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __match = self.base.match_token_recovering(3, 1919, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1919isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(16, 1922, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 1922, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + self.base.record_generated_prediction_diagnostic(atn(), 1635, &__prediction); + match __prediction.alt { + 1 => { + let action = self.base.parser_action_at_current_indexed(1623, 75, 0, __rule_start, __consumed_eof); + let _ = action; + let __match = self.base.match_token_recovering(5, 1636, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + let __match = self.base.match_token_recovering(50, 1626, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1626isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1628, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 17 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1628, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1627isize); + let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(51, 1631, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 3 => { + let __invoking_marker = self.base.push_invoking_state(1632isize); + let __child = self.parse_generated_rule_77_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 4 => { + let __match = self.base.match_token_recovering(12, 1634, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1634isize); + let __child = self.parse_generated_rule_77_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + loop { let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1922) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(278, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 1642, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(278, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + match __simulator.adaptive_predict_stream_info_with_context(230, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + }; + let __prediction = if __prediction.alt == 1 { + let __semantic_la = self.base.la(1); + if __semantic_la == 12 { __prediction + } else { + antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } } + } else { + __prediction }; - self.base.record_generated_prediction_diagnostic(atn(), 1922, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1642, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(1921isize); - let __child = self.parse_generated_rule_118_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.parse_listener_exit_rule(75); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); + } + self.base.push_new_recursion_context_with_previous(150isize, 75, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(75) { + return Err(__listener_error); + } + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __match = self.base.match_token_recovering(12, 1639, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1639isize); + let __child = self.parse_generated_rule_77_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } - 2 => { - } + 2 => break, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __match = self.base.match_token_recovering(4, 1925, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_105_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(105) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_105(precedence, allow_fallback)) - } else { - self.parse_generated_rule_105(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(105); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_105(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(210isize, 105); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(34, 1929, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1929isize); - let __child = self.parse_generated_rule_108_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_106_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_76_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(106) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_106(precedence, allow_fallback)) - } else { - self.parse_generated_rule_106(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(106); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 76, GeneratedRuleError::Fatal; self.parse_generated_rule_76(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_106(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_76(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(212isize, 106); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(34, 1932, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1932isize); - let __child = self.parse_generated_rule_111_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 152isize, 76, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(17, 1646, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1646isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_107_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_77_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(107) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_107(precedence, allow_fallback)) - } else { - self.parse_generated_rule_107(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(107); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 77, GeneratedRuleError::Fatal; self.parse_generated_rule_77(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_107(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_77(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(214isize, 107); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 1935, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 57 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=6 | 12 | 21 | 27 | 33 | 40..=41 | 43 | 45 | 50 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1935, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(57, 1936, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 154isize, 77, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2 | 5 | 21 | 27 | 40..=41 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1650, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1650) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(231, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(231, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1650, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1648isize); + let __child = self.parse_generated_rule_78_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __match = self.base.match_token_recovering(6, 1651, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(1937isize); - let __child = self.parse_generated_rule_111_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_108_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_78_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(108) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_108(precedence, allow_fallback)) - } else { - self.parse_generated_rule_108(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(108); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 78, GeneratedRuleError::Fatal; self.parse_generated_rule_78(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_108(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_78(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(216isize, 108); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(1939isize); - let __child = self.parse_generated_rule_109_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_1944 = false; - loop { - match self.base.sync_decision(atn(), 1944, !__ctx.has_matched_child(), __loop_iter_1944) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 156isize, 78, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(1652isize); + let __child = self.parse_generated_rule_80_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1655, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -33587,12 +26955,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1944) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1655) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(281, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(232, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -33602,7 +26970,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(281, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(232, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -33611,172 +26979,77 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 1944, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1655, &__prediction); match __prediction.alt { 1 => { - __loop_iter_1944 = true; - let __match = self.base.match_token_recovering(54, 1941, atn())?; + let __match = self.base.match_token_recovering(12, 1654, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(1941isize); - let __child = self.parse_generated_rule_109_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1654isize); + let __child = self.parse_generated_rule_115_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - match self.base.sync_decision(atn(), 1948, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1948) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(282, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(282, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1948, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(54, 1949, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_109_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_79_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(109) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_109(precedence, allow_fallback)) - } else { - self.parse_generated_rule_109(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(109); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 79, GeneratedRuleError::Fatal; self.parse_generated_rule_79(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_109(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_79(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(218isize, 109); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=6 | 12 | 21 | 27 | 33 | 40..=41 | 43 | 45 | 50 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 11 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1976, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 158isize, 79, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 1658, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=6 | 12 | 21 | 27 | 33 | 40..=41 | 43 | 45 | 50 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 11 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1976, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1950isize); - let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(1951isize); - let __child = self.parse_generated_rule_111_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 5..=6 | 21 | 27 | 40..=41 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1658, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(12, 1659, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 3 => { - let __match = self.base.match_token_recovering(11, 1953, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(50, 1973, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 1973, !__ctx.has_matched_child(), false) { + let __invoking_marker = self.base.push_invoking_state(1660isize); + let __child = self.parse_generated_rule_80_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_1665 = false; + loop { + match self.base.sync_decision(atn(), 1665, !__ctx.has_matched_child(), __loop_iter_1665) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -33787,399 +27060,217 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 2 | 21 | 27 | 40..=41 | 52 | 55 | 69 | 98..=100 | 102..=104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 44 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - self.base.record_generated_prediction_diagnostic(atn(), 1973, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1665, &__prediction); match __prediction.alt { 1 => { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 52 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1957, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 52 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1957, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1954isize); - let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(1955isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 3 => { - let __match = self.base.match_token_recovering(52, 1958, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let mut __loop_iter_1967 = false; - loop { - match self.base.sync_decision(atn(), 1967, !__ctx.has_matched_child(), __loop_iter_1967) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1967) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(285, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(285, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1967, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_1967 = true; - let __match = self.base.match_token_recovering(16, 1963, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 52 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 1963, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 52 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1963, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1960isize); - let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(1961isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 3 => { - let __match = self.base.match_token_recovering(52, 1964, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - match self.base.sync_decision(atn(), 1971, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1971, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 1972, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } + __loop_iter_1665 = true; + let __match = self.base.match_token_recovering(12, 1662, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1662isize); + let __child = self.parse_generated_rule_80_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __match = self.base.match_token_recovering(51, 1977, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_110_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_80_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(110) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_110(precedence, allow_fallback)) - } else { - self.parse_generated_rule_110(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(110); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 80, GeneratedRuleError::Fatal; self.parse_generated_rule_80(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_110(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_80(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(220isize, 110); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 1979, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1979) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(289, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 160isize, 80, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 5 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 6 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 52 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 53 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1674, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1674) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(235, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(235, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } + } }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(289, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1979, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(57, 1980, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { + self.base.record_generated_prediction_diagnostic(atn(), 1674, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1668isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __match = self.base.match_token_recovering(5, 1675, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 3 => { + let __match = self.base.match_token_recovering(6, 1675, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 4 => { + let __match = self.base.match_token_recovering(52, 1675, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 5 => { + let __match = self.base.match_token_recovering(2, 1675, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 6 => { + let __match = self.base.match_token_recovering(53, 1675, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - match self.base.sync_decision(atn(), 1982, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_81_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 81, GeneratedRuleError::Fatal; self.parse_generated_rule_81(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_81(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 162isize, 81, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(45, 1677, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(50, 1679, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1679, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1982) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(290, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 | 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(290, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 1982, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1981isize); - let __child = self.parse_generated_rule_108_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { + self.base.record_generated_prediction_diagnostic(atn(), 1679, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1678isize); + let __child = self.parse_generated_rule_82_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __match = self.base.match_token_recovering(51, 1682, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_111_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_82_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(111) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_111(precedence, allow_fallback)) - } else { - self.parse_generated_rule_111(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(111); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 82, GeneratedRuleError::Fatal; self.parse_generated_rule_82(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_111(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_82(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(222isize, 111); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2 | 5..=6 | 12 | 21 | 27 | 33 | 40..=41 | 43 | 45 | 50 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2001, !__ctx.has_matched_child(), false) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 164isize, 82, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(1683isize); + let __child = self.parse_generated_rule_83_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_1688 = false; + loop { + match self.base.sync_decision(atn(), 1688, !__ctx.has_matched_child(), __loop_iter_1688) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -34188,13 +27279,13 @@ where return Err(__error); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2001) { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1688) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(295, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(237, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -34204,7 +27295,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(295, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(237, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -34212,103 +27303,76 @@ where } else { __prediction } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2001, &__prediction); - match __prediction.alt { - 1 => { - match self.base.sync_decision(atn(), 1985, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 43 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=6 | 12 | 21 | 27 | 33 | 40..=41 | 45 | 50 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1985, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1688, &__prediction); match __prediction.alt { 1 => { - let __match = self.base.match_token_recovering(43, 1986, atn())?; + __loop_iter_1688 = true; + let __match = self.base.match_token_recovering(16, 1685, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 1988, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 45 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=6 | 12 | 21 | 27 | 33 | 40..=41 | 50 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1988, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(1987isize); - let __child = self.parse_generated_rule_81_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1685isize); + let __child = self.parse_generated_rule_83_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __invoking_marker = self.base.push_invoking_state(1990isize); - let __child = self.parse_generated_rule_85_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); } - 2 => { - let __match = self.base.match_token_recovering(3, 1993, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 1993, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + match self.base.sync_decision(atn(), 1692, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 43 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=6 | 12 | 21 | 27 | 33 | 40..=41 | 45 | 50 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 1993, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(43, 1994, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 1692, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 1693, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { } - match self.base.sync_decision(atn(), 1996, !__ctx.has_matched_child(), false) { + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_83_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 83, GeneratedRuleError::Fatal; self.parse_generated_rule_83(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_83(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 166isize, 83, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __loop_iter_1697 = false; + loop { + match self.base.sync_decision(atn(), 1697, !__ctx.has_matched_child(), __loop_iter_1697) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -34319,523 +27383,302 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 45 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=6 | 12 | 21 | 27 | 33 | 40..=41 | 50 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 1996, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1697, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(1995isize); - let __child = self.parse_generated_rule_81_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_1697 = true; + let __invoking_marker = self.base.push_invoking_state(1694isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __invoking_marker = self.base.push_invoking_state(1998isize); - let __child = self.parse_generated_rule_85_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(4, 2000, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_112_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(112) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_112(precedence, allow_fallback)) - } else { - self.parse_generated_rule_112(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(112); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_112(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(224isize, 112); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 2004, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 45 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 9 | 20 | 31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2004, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2003isize); - let __child = self.parse_generated_rule_81_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 2007, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 20 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 9 | 31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2007, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(20, 2008, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 2010, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 9 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2010, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2009isize); - let __child = self.parse_generated_rule_114_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(31, 2013, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(3, 2015, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2015, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2015) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(299, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(299, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2015, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2014isize); - let __child = self.parse_generated_rule_33_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(4, 2019, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2019, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __invoking_marker = self.base.push_invoking_state(1700isize); + let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1703, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2019) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(300, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 16 | 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(300, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2019, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2018isize); - let __child = self.parse_generated_rule_39_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { + self.base.record_generated_prediction_diagnostic(atn(), 1703, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(24, 1702, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1702isize); + let __child = self.parse_generated_rule_84_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_113_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(113) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_113(precedence, allow_fallback)) - } else { - self.parse_generated_rule_113(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(113); - __listener_result + fn parse_generated_rule_84_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 84, GeneratedRuleError::Fatal; self.parse_generated_rule_84_precedence(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_113(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(226isize, 113); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_set_recovering(&[(23, 23), (28, 28)], 2022, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + fn parse_generated_rule_84(&mut self, allow_fallback: bool) -> Result { + self.parse_generated_rule_84_precedence(0, allow_fallback) + } + + #[allow(dead_code)] + fn parse_generated_rule_84_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 168isize, 84, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let action = self.base.parser_action_at_current_indexed(1705, 84, 1, __rule_start, __consumed_eof); + let _ = action; + let __invoking_marker = self.base.push_invoking_state(1706isize); + let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + loop { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 1713, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + match __simulator.adaptive_predict_stream_info_with_context(241, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + }; + let __prediction = if __prediction.alt == 1 { + let __semantic_la = self.base.la(1); + if __semantic_la == 54 { + __prediction + } else { + antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } + } + } else { + __prediction + }; + self.base.record_generated_prediction_diagnostic(atn(), 1713, &__prediction); + match __prediction.alt { + 1 => { + self.base.parse_listener_exit_rule(84); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); + } + self.base.push_new_recursion_context_with_previous(168isize, 84, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(84) { + return Err(__listener_error); + } + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __match = self.base.match_token_recovering(54, 1710, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1710isize); + let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => break, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_114_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_85_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(114) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_114(precedence, allow_fallback)) - } else { - self.parse_generated_rule_114(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(114); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 85, GeneratedRuleError::Fatal; self.parse_generated_rule_85(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_114(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_85(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(228isize, 114); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(9, 2025, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2025, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 106 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 | 31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 2025, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(106, 2026, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 170isize, 85, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 5..=6 | 12 | 50 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1722, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1722) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(243, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(243, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1722, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1716isize); + let __child = self.parse_generated_rule_86_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + match self.base.sync_decision(atn(), 1718, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1718) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(242, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(242, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1718, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1717isize); + let __child = self.parse_generated_rule_87_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(12, 1721, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1721isize); + let __child = self.parse_generated_rule_86_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_115_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_86_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(115) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_115(precedence, allow_fallback)) - } else { - self.parse_generated_rule_115(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(115); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 86, GeneratedRuleError::Fatal; self.parse_generated_rule_86(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_115(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_86(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(230isize, 115); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 2068, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2068) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(308, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(308, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2068, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(50, 2028, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(51, 2069, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __match = self.base.match_token_recovering(50, 2030, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2030isize); - let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_2038 = false; - loop { - match self.base.sync_decision(atn(), 2038, !__ctx.has_matched_child(), __loop_iter_2038) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 172isize, 86, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 3 | 33 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1737, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -34844,13 +27687,13 @@ where return Err(__error); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2038) { + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1737) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(303, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(247, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -34860,7 +27703,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(303, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(247, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -34868,15 +27711,18 @@ where } else { __prediction } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2038, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_2038 = true; - let __match = self.base.match_token_recovering(16, 2034, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2034, !__ctx.has_matched_child(), false) { + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1737, &__prediction); + match __prediction.alt { + 1 => { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1726, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -34885,93 +27731,34 @@ where return Err(__error); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2034) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(302, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(302, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2034, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2032isize); - let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(2033isize); - let __child = self.parse_generated_rule_116_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1726, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1724isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } 2 => { - break; + let __match = self.base.match_token_recovering(52, 1727, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - match self.base.sync_decision(atn(), 2042, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2042, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 2043, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(51, 2045, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __match = self.base.match_token_recovering(50, 2052, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_2052 = false; - loop { - match self.base.sync_decision(atn(), 2052, !__ctx.has_matched_child(), __loop_iter_2052) { + let __match = self.base.match_token_recovering(3, 1730, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1730, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -34981,12 +27768,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2052) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1730) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(305, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(245, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -34996,7 +27783,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(305, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(245, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -35005,33 +27792,23 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 2052, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1730, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2052 = true; - let __invoking_marker = self.base.push_invoking_state(2047isize); - let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1729isize); + let __child = self.parse_generated_rule_118_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(16, 2049, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - let __invoking_marker = self.base.push_invoking_state(2055isize); - let __child = self.parse_generated_rule_116_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_2060 = false; - loop { - match self.base.sync_decision(atn(), 2060, !__ctx.has_matched_child(), __loop_iter_2060) { + let __match = self.base.match_token_recovering(4, 1734, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1734, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -35041,12 +27818,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2060) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1734) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(306, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(246, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -35056,7 +27833,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(306, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(246, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -35065,669 +27842,311 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 2060, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1734, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2060 = true; - let __match = self.base.match_token_recovering(16, 2057, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2057isize); - let __child = self.parse_generated_rule_116_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1733isize); + let __child = self.parse_generated_rule_39_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - match self.base.sync_decision(atn(), 2064, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2064, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 2065, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 2 => { + let __invoking_marker = self.base.push_invoking_state(1736isize); + let __child = self.parse_generated_rule_89_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(51, 2067, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_116_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(116) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_116(precedence, allow_fallback)) - } else { - self.parse_generated_rule_116(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(116); - __listener_result + fn parse_generated_rule_87_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 87, GeneratedRuleError::Fatal; self.parse_generated_rule_87_precedence(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_116(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(232isize, 116); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 2093, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2093) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(310, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + fn parse_generated_rule_87(&mut self, allow_fallback: bool) -> Result { + self.parse_generated_rule_87_precedence(0, allow_fallback) + } + + #[allow(dead_code)] + fn parse_generated_rule_87_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 174isize, 87, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 5 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 50 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 6 | 21 | 27 | 33 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 12 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1751, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 5 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 50 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 6 | 21 | 27 | 33 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 12 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(310, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2093, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2070isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(25, 2072, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2072isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(2074isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(24, 2076, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2076isize); - let __child = self.parse_generated_rule_108_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 3 => { - let __invoking_marker = self.base.push_invoking_state(2078isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 4 => { - let __match = self.base.match_token_recovering(110, 2094, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 5 => { - let __match = self.base.match_token_recovering(58, 2094, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 6 => { - let __match = self.base.match_token_recovering(59, 2094, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 7 => { - let __match = self.base.match_token_recovering(60, 2083, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(110, 2094, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 8 => { - match self.base.sync_decision(atn(), 2085, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + self.base.record_generated_prediction_diagnostic(atn(), 1751, &__prediction); + match __prediction.alt { + 1 => { + let action = self.base.parser_action_at_current_indexed(1739, 87, 2, __rule_start, __consumed_eof); + let _ = action; + let __match = self.base.match_token_recovering(5, 1752, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + let __match = self.base.match_token_recovering(50, 1742, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1742isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1744, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 17 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1744, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1743isize); + let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(51, 1747, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 3 => { + let __invoking_marker = self.base.push_invoking_state(1748isize); + let __child = self.parse_generated_rule_88_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 4 => { + let __match = self.base.match_token_recovering(12, 1750, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1750isize); + let __child = self.parse_generated_rule_88_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + loop { let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 60 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 111..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 1758, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + match __simulator.adaptive_predict_stream_info_with_context(250, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + }; + let __prediction = if __prediction.alt == 1 { + let __semantic_la = self.base.la(1); + if __semantic_la == 12 { + __prediction + } else { + antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } + } + } else { + __prediction }; - self.base.record_generated_prediction_diagnostic(atn(), 2085, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1758, &__prediction); match __prediction.alt { 1 => { - let __match = self.base.match_token_recovering(60, 2086, atn())?; + self.base.parse_listener_exit_rule(87); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); + } + self.base.push_new_recursion_context_with_previous(174isize, 87, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(87) { + return Err(__listener_error); + } + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __match = self.base.match_token_recovering(12, 1755, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1755isize); + let __child = self.parse_generated_rule_88_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - 2 => { - } + 2 => break, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __match = self.base.match_set_recovering(&[(111, 112)], 2094, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 9 => { - let __match = self.base.match_token_recovering(108, 2094, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 10 => { - let __match = self.base.match_token_recovering(109, 2094, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 11 => { - let __match = self.base.match_token_recovering(105, 2094, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 12 => { - let __match = self.base.match_token_recovering(106, 2094, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 13 => { - let __match = self.base.match_token_recovering(107, 2094, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_117_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(117) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_117(precedence, allow_fallback)) - } else { - self.parse_generated_rule_117(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(117); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_117(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(234isize, 117); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 2096, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2096) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(311, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(311, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2096, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(57, 2097, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(2098isize); - let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 2101, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2101) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(312, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(312, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2101, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(54, 2100, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2100isize); - let __child = self.parse_generated_rule_95_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_118_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_88_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(118) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_118(precedence, allow_fallback)) - } else { - self.parse_generated_rule_118(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(118); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 88, GeneratedRuleError::Fatal; self.parse_generated_rule_88(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_118(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_88(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(236isize, 118); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(2103isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_2108 = false; - loop { - match self.base.sync_decision(atn(), 2108, !__ctx.has_matched_child(), __loop_iter_2108) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2108) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(313, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(313, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 176isize, 88, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2..=3 | 21 | 27 | 33 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 6 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1763, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 2..=3 | 21 | 27 | 33 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 6 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } }; - self.base.record_generated_prediction_diagnostic(atn(), 2108, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1763, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2108 = true; - let __match = self.base.match_token_recovering(16, 2105, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2105isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1761isize); + let __child = self.parse_generated_rule_89_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; + let __match = self.base.match_token_recovering(6, 1764, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - match self.base.sync_decision(atn(), 2112, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 2112, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 2113, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_119_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_89_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(119) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_119(precedence, allow_fallback)) - } else { - self.parse_generated_rule_119(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(119); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 89, GeneratedRuleError::Fatal; self.parse_generated_rule_89(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_119(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_89(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(238isize, 119); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 2131, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2131) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(317, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 178isize, 89, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 27 | 33 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1783, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 27 | 33 | 40..=41 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(317, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2131, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(50, 2115, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2115isize); - let __child = self.parse_generated_rule_121_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(51, 2117, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __match = self.base.match_token_recovering(50, 2124, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_2124 = false; - loop { - match self.base.sync_decision(atn(), 2124, !__ctx.has_matched_child(), __loop_iter_2124) { + self.base.record_generated_prediction_diagnostic(atn(), 1783, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(3, 1768, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1768, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -35737,12 +28156,49 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2124) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(315, 0, self.base.input()) + let __prediction = match self.base.la(1) { + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1768, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1766isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __match = self.base.match_token_recovering(52, 1769, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 3 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(4, 1772, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1772, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1772) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(253, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -35752,7 +28208,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(315, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(253, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -35761,26 +28217,219 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 2124, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1772, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2124 = true; - let __invoking_marker = self.base.push_invoking_state(2119isize); - let __child = self.parse_generated_rule_120_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1771isize); + let __child = self.parse_generated_rule_115_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(16, 2121, atn())?; + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + 2 => { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 33 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1778, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 33 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1778, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1774isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __match = self.base.match_token_recovering(52, 1779, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 3 => { + let __match = self.base.match_token_recovering(33, 1777, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(55, 1779, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 1781, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1781) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(255, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(255, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1781, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1780isize); + let __child = self.parse_generated_rule_115_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - match self.base.sync_decision(atn(), 2128, !__ctx.has_matched_child(), false) { + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_90_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 90, GeneratedRuleError::Fatal; self.parse_generated_rule_90(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_90(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 180isize, 90, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(56, 1787, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1787, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1787) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(257, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(257, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1787, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1786isize); + let __child = self.parse_generated_rule_91_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_91_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 91, GeneratedRuleError::Fatal; self.parse_generated_rule_91(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_91(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 182isize, 91, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(1789isize); + let __child = self.parse_generated_rule_92_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_1794 = false; + loop { + match self.base.sync_decision(atn(), 1794, !__ctx.has_matched_child(), __loop_iter_1794) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -35790,12 +28439,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2128) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1794) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(316, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(258, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -35805,7 +28454,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(316, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(258, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -35814,82 +28463,26 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 2128, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1794, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(2127isize); - let __child = self.parse_generated_rule_123_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_1794 = true; + let __match = self.base.match_token_recovering(16, 1791, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1791isize); + let __child = self.parse_generated_rule_92_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __match = self.base.match_token_recovering(51, 2132, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_120_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(120) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_120(precedence, allow_fallback)) - } else { - self.parse_generated_rule_120(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(120); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_120(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(240isize, 120); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __loop_iter_2136 = false; - loop { - match self.base.sync_decision(atn(), 2136, !__ctx.has_matched_child(), __loop_iter_2136) { + match self.base.sync_decision(atn(), 1798, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -35899,151 +28492,63 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 28 | 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1798) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(259, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(259, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } }; - self.base.record_generated_prediction_diagnostic(atn(), 2136, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1798, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2136 = true; - let __invoking_marker = self.base.push_invoking_state(2133isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(16, 1799, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - match self.base.sync_decision(atn(), 2140, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 28 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2140, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(28, 2141, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(2142isize); - let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 2145, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 16 | 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 2145, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(24, 2144, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2144isize); - let __child = self.parse_generated_rule_84_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_121_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_92_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(121) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_121(precedence, allow_fallback)) - } else { - self.parse_generated_rule_121(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(121); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 92, GeneratedRuleError::Fatal; self.parse_generated_rule_92(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_121(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_92(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(242isize, 121); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(2147isize); - let __child = self.parse_generated_rule_120_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_2152 = false; - loop { - match self.base.sync_decision(atn(), 2152, !__ctx.has_matched_child(), __loop_iter_2152) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 184isize, 92, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 1811, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -36053,12 +28558,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2152) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1811) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(321, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(262, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -36068,7 +28573,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(321, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(262, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -36077,145 +28582,25 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 2152, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1811, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2152 = true; - let __match = self.base.match_token_recovering(16, 2149, atn())?; + let __invoking_marker = self.base.push_invoking_state(1800isize); + let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(24, 1802, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2149isize); - let __child = self.parse_generated_rule_120_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1802isize); + let __child = self.parse_generated_rule_84_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - match self.base.sync_decision(atn(), 2156, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 2156, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 2157, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_122_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(122) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_122(precedence, allow_fallback)) - } else { - self.parse_generated_rule_122(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(122); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_122(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(244isize, 122); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 2185, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2185) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(328, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(328, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2185, &__prediction); - match __prediction.alt { - 1 => { - let mut __loop_iter_2161 = false; - loop { - match self.base.sync_decision(atn(), 2161, !__ctx.has_matched_child(), __loop_iter_2161) { + match self.base.sync_decision(atn(), 1805, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -36225,95 +28610,49 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 28 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1805) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(260, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(260, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } }; - self.base.record_generated_prediction_diagnostic(atn(), 2161, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1805, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2161 = true; - let __invoking_marker = self.base.push_invoking_state(2158isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1804isize); + let __child = self.parse_generated_rule_81_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - let __match = self.base.match_token_recovering(28, 2165, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2165isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(24, 2167, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2167isize); - let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 2169, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2169) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(324, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(324, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2169, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2168isize); - let __child = self.parse_generated_rule_61_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - 2 => { - let mut __loop_iter_2174 = false; - loop { - match self.base.sync_decision(atn(), 2174, !__ctx.has_matched_child(), __loop_iter_2174) { + let __invoking_marker = self.base.push_invoking_state(1807isize); + let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1809, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -36323,198 +28662,71 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1809) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(261, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(261, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } }; - self.base.record_generated_prediction_diagnostic(atn(), 2174, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1809, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2174 = true; - let __invoking_marker = self.base.push_invoking_state(2171isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1808isize); + let __child = self.parse_generated_rule_93_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __invoking_marker = self.base.push_invoking_state(2177isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 2179, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2179) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(326, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(326, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2179, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2178isize); - let __child = self.parse_generated_rule_94_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 2182, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2182) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(327, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(327, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2182, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2181isize); - let __child = self.parse_generated_rule_60_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - 3 => { - let __invoking_marker = self.base.push_invoking_state(2184isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_123_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_93_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(123) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_123(precedence, allow_fallback)) - } else { - self.parse_generated_rule_123(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(123); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 93, GeneratedRuleError::Fatal; self.parse_generated_rule_93(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_123(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_93(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(246isize, 123); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(2187isize); - let __child = self.parse_generated_rule_122_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_2192 = false; - loop { - match self.base.sync_decision(atn(), 2192, !__ctx.has_matched_child(), __loop_iter_2192) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 186isize, 93, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(24, 1815, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1815, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -36524,12 +28736,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2192) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1815) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(329, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(263, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -36539,7 +28751,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(329, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(263, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -36548,154 +28760,244 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 2192, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1815, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2192 = true; - let __match = self.base.match_token_recovering(16, 2189, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2189isize); - let __child = self.parse_generated_rule_122_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1814isize); + let __child = self.parse_generated_rule_95_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - match self.base.sync_decision(atn(), 2196, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 2196, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 2197, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_124_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_94_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(124) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_124(precedence, allow_fallback)) - } else { - self.parse_generated_rule_124(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(124); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 94, GeneratedRuleError::Fatal; self.parse_generated_rule_94(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_124(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_94(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(248isize, 124); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 2199, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=6 | 12 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 46 | 48 | 50 | 52..=53 | 55 | 58..=60 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2199, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(61, 2200, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 188isize, 94, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(24, 1818, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1818isize); + let __child = self.parse_generated_rule_95_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2201isize); - let __child = self.parse_generated_rule_125_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_2206 = false; - loop { - match self.base.sync_decision(atn(), 2206, !__ctx.has_matched_child(), __loop_iter_2206) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_95_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 95, GeneratedRuleError::Fatal; self.parse_generated_rule_95_precedence(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_95(&mut self, allow_fallback: bool) -> Result { + self.parse_generated_rule_95_precedence(0, allow_fallback) + } + + #[allow(dead_code)] + fn parse_generated_rule_95_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 190isize, 95, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let action = self.base.parser_action_at_current_indexed(1820, 95, 3, __rule_start, __consumed_eof); + let _ = action; + let __invoking_marker = self.base.push_invoking_state(1821isize); + let __child = self.parse_generated_rule_96_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + loop { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 1841, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + match __simulator.adaptive_predict_stream_info_with_context(266, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1841, &__prediction); + match __prediction.alt { + 1 => { + self.base.parse_listener_exit_rule(95); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); + } + self.base.push_new_recursion_context_with_previous(190isize, 95, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(95) { + return Err(__listener_error); + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(265, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if self.base.report_diagnostic_errors() { + let __diagnostic_la = self.base.la(1); + let mut __diagnostic_alts = Vec::new(); + if __diagnostic_la == 54 { + __diagnostic_alts.push(1); + } + if __diagnostic_la == 50 { + __diagnostic_alts.push(2); + } + self.base.record_generated_ambiguity_diagnostic(atn(), 1839, __decision_start, __decision_start, &__diagnostic_alts); + } + match __prediction.alt { + 1 => { + if !self.base.precpred(2) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 2)")); + } + let __match = self.base.match_token_recovering(54, 1825, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1825isize); + let __child = self.parse_generated_rule_96_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __match = self.base.match_token_recovering(50, 1833, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_1833 = false; + loop { + match self.base.sync_decision(atn(), 1833, !__ctx.has_matched_child(), __loop_iter_1833) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(264, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + self.base.record_generated_prediction_diagnostic(atn(), 1833, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_1833 = true; + let __invoking_marker = self.base.push_invoking_state(1828isize); + let __child = self.parse_generated_rule_120_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(16, 1830, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __invoking_marker = self.base.push_invoking_state(1836isize); + let __child = self.parse_generated_rule_123_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(51, 1838, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + 2 => break, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_96_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 96, GeneratedRuleError::Fatal; self.parse_generated_rule_96(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_96(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 192isize, 96, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 1856, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); return Err(__error); } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2206) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1856) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(332, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(270, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -36705,7 +29007,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(332, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(270, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -36714,524 +29016,175 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 2206, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1856, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2206 = true; - let __match = self.base.match_token_recovering(61, 2203, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2203isize); - let __child = self.parse_generated_rule_125_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_125_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(125) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_125(precedence, allow_fallback)) - } else { - self.parse_generated_rule_125(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(125); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_125(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(250isize, 125); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2..=3 | 5..=6 | 12 | 18 | 21 | 27 | 33 | 35..=36 | 40..=41 | 46 | 48 | 50 | 52..=53 | 55 | 58..=60 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2216, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + match self.base.sync_decision(atn(), 1846, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2216) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(334, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 43 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=6 | 12 | 21 | 27 | 33..=34 | 40..=41 | 45 | 50 | 52 | 55 | 57 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(334, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2216, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2209isize); - let __child = self.parse_generated_rule_127_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(23, 2211, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2211isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 2214, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + self.base.record_generated_prediction_diagnostic(atn(), 1846, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(43, 1847, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 62 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 7 | 10 | 14 | 16 | 23..=25 | 28 | 49 | 61 | 70 | 72 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 2214, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(62, 2213, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2213isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1849, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 45 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=6 | 12 | 21 | 27 | 33..=34 | 40..=41 | 50 | 52 | 55 | 57 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1849, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1848isize); + let __child = self.parse_generated_rule_81_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_126_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(126) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_126(precedence, allow_fallback)) - } else { - self.parse_generated_rule_126(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(126); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_126(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(252isize, 126); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 18 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 35 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2221, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1852, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 34 | 57 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=6 | 12 | 21 | 27 | 33 | 40..=41 | 50 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1852, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_set_recovering(&[(34, 34), (57, 57)], 1853, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __invoking_marker = self.base.push_invoking_state(1854isize); + let __child = self.parse_generated_rule_85_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 18 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 35 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 3 => { + let __invoking_marker = self.base.push_invoking_state(1855isize); + let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2221, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(18, 2222, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __match = self.base.match_token_recovering(35, 2220, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2220isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_127_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_97_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(127) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_127(precedence, allow_fallback)) - } else { - self.parse_generated_rule_127(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(127); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 97, GeneratedRuleError::Fatal; self.parse_generated_rule_97(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_127(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_97(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(254isize, 127); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 63 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 46 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 23 => antlr4_runtime::ParserAtnPrediction { alt: 13, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 3 => antlr4_runtime::ParserAtnPrediction { alt: 17, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 64 => antlr4_runtime::ParserAtnPrediction { alt: 24, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 101 => antlr4_runtime::ParserAtnPrediction { alt: 25, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2331, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 194isize, 97, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 1873, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2331) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(347, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(347, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2331, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(18, 2332, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __match = self.base.match_token_recovering(63, 2225, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2225isize); - let __child = self.parse_generated_rule_128_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 3 => { - let __match = self.base.match_token_recovering(46, 2332, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 4 => { - let __invoking_marker = self.base.push_invoking_state(2227isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 2230, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 62 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 7 | 10 | 14 | 16 | 23..=25 | 28 | 49 | 61 | 70 | 72 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1873) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(273, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? }; - self.base.record_generated_prediction_diagnostic(atn(), 2230, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(62, 2229, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2229isize); - let __child = self.parse_generated_rule_151_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(273, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction } - } - 5 => { - let __invoking_marker = self.base.push_invoking_state(2232isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(62, 2234, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(3, 2235, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2235isize); - let __child = self.parse_generated_rule_151_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(4, 2237, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 6 => { - let __invoking_marker = self.base.push_invoking_state(2238isize); - let __child = self.parse_generated_rule_129_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 7 => { - let __invoking_marker = self.base.push_invoking_state(2239isize); - let __child = self.parse_generated_rule_128_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(32, 2241, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2241isize); - let __child = self.parse_generated_rule_128_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 8 => { - let __invoking_marker = self.base.push_invoking_state(2243isize); - let __child = self.parse_generated_rule_128_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(46, 2245, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2245isize); - let __child = self.parse_generated_rule_128_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 9 => { - let __invoking_marker = self.base.push_invoking_state(2247isize); - let __child = self.parse_generated_rule_128_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(46, 2249, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 10 => { - let __invoking_marker = self.base.push_invoking_state(2250isize); - let __child = self.parse_generated_rule_128_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(63, 2252, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2252isize); - let __child = self.parse_generated_rule_128_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 11 => { - let __invoking_marker = self.base.push_invoking_state(2254isize); - let __child = self.parse_generated_rule_74_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __invoking_marker = self.base.push_invoking_state(2255isize); - let __child = self.parse_generated_rule_73_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 12 => { - let mut __loop_iter_2262 = false; - loop { - match self.base.sync_decision(atn(), 2262, !__ctx.has_matched_child(), __loop_iter_2262) { + }; + self.base.record_generated_prediction_diagnostic(atn(), 1873, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1858isize); + let __child = self.parse_generated_rule_98_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __match = self.base.match_token_recovering(36, 1861, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1861, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -37241,12 +29194,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2262) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1861) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(337, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(271, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -37256,7 +29209,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(337, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(271, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -37265,304 +29218,147 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 2262, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1861, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2262 = true; - let __invoking_marker = self.base.push_invoking_state(2257isize); - let __child = self.parse_generated_rule_126_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1860isize); + let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(16, 2259, atn())?; + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 1864, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1864) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(272, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(272, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1864, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(23, 1865, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __invoking_marker = self.base.push_invoking_state(1866isize); + let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2265isize); - let __child = self.parse_generated_rule_126_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 2268, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + 3 => { + let __invoking_marker = self.base.push_invoking_state(1867isize); + let __child = self.parse_generated_rule_105_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 62 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 7 | 10 | 14 | 16 | 23..=25 | 28 | 49 | 61 | 70 | 72 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 2268, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(62, 2267, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2267isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 4 => { + let __invoking_marker = self.base.push_invoking_state(1868isize); + let __child = self.parse_generated_rule_110_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - } - 13 => { - match self.base.sync_decision(atn(), 2271, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + 5 => { + let __match = self.base.match_token_recovering(13, 1870, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1870isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(14, 1872, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 35 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 23 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2271, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(35, 2272, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_98_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 98, GeneratedRuleError::Fatal; self.parse_generated_rule_98(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_98(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 196isize, 98, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 34 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 43 | 50 | 57 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 44 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 15 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 48 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 18 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 9 | 20 | 31 => antlr4_runtime::ParserAtnPrediction { alt: 10, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 53 => antlr4_runtime::ParserAtnPrediction { alt: 11, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1889, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 2274, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2274, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(23, 2275, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(2276isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 2279, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 62 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 7 | 10 | 14 | 16 | 23..=25 | 28 | 49 | 61 | 70 | 72 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 2279, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(62, 2278, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2278isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - 14 => { - let __invoking_marker = self.base.push_invoking_state(2281isize); - let __child = self.parse_generated_rule_74_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(3, 2284, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2284, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2..=3 | 5..=6 | 12 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 46 | 48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2284, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2283isize); - let __child = self.parse_generated_rule_131_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(4, 2287, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 15 => { - let __invoking_marker = self.base.push_invoking_state(2288isize); - let __child = self.parse_generated_rule_74_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(13, 2291, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2291, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2 | 21 | 23 | 27 | 35 | 40..=41 | 46..=47 | 55 | 64 | 69 | 98 | 102 | 104 | 110..=111 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2291, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2290isize); - let __child = self.parse_generated_rule_134_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(14, 2294, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 16 => { - let __invoking_marker = self.base.push_invoking_state(2295isize); - let __child = self.parse_generated_rule_74_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 17 => { - let __match = self.base.match_token_recovering(3, 2298, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2298, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2..=3 | 5..=6 | 12 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 46 | 48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2298, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2297isize); - let __child = self.parse_generated_rule_131_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(4, 2332, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 18 => { - let __match = self.base.match_token_recovering(48, 2302, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2302isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_2307 = false; - loop { - match self.base.sync_decision(atn(), 2307, !__ctx.has_matched_child(), __loop_iter_2307) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2307) { + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1889) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(345, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(274, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -37572,7 +29368,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(345, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(274, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -37580,373 +29376,208 @@ where } else { __prediction } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2307, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_2307 = true; - let __match = self.base.match_token_recovering(16, 2304, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2304isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - match self.base.sync_decision(atn(), 2311, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1889, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1875isize); + let __child = self.parse_generated_rule_106_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2311, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 2312, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 2 => { + let __invoking_marker = self.base.push_invoking_state(1876isize); + let __child = self.parse_generated_rule_107_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(49, 2314, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 19 => { - let __match = self.base.match_token_recovering(48, 2316, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(49, 2332, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 20 => { - let __match = self.base.match_token_recovering(33, 2318, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2318isize); - let __child = self.parse_generated_rule_127_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 21 => { - let __match = self.base.match_token_recovering(33, 2320, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(23, 2321, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2321isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 22 => { - let __match = self.base.match_token_recovering(36, 2323, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2323isize); - let __child = self.parse_generated_rule_127_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 23 => { - let __match = self.base.match_token_recovering(36, 2325, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(23, 2326, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2326isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 24 => { - let __match = self.base.match_token_recovering(64, 2328, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2328isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 3 => { + let __match = self.base.match_token_recovering(3, 1878, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1878isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(4, 1880, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 4 => { + let __invoking_marker = self.base.push_invoking_state(1881isize); + let __child = self.parse_generated_rule_104_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 5 => { + let __invoking_marker = self.base.push_invoking_state(1882isize); + let __child = self.parse_generated_rule_103_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 6 => { + let __invoking_marker = self.base.push_invoking_state(1883isize); + let __child = self.parse_generated_rule_102_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 7 => { + let __invoking_marker = self.base.push_invoking_state(1884isize); + let __child = self.parse_generated_rule_101_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 8 => { + let __invoking_marker = self.base.push_invoking_state(1885isize); + let __child = self.parse_generated_rule_100_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 9 => { + let __invoking_marker = self.base.push_invoking_state(1886isize); + let __child = self.parse_generated_rule_99_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 10 => { + let __invoking_marker = self.base.push_invoking_state(1887isize); + let __child = self.parse_generated_rule_112_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 11 => { + let __invoking_marker = self.base.push_invoking_state(1888isize); + let __child = self.parse_generated_rule_213_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 25 => { - let __match = self.base.match_token_recovering(101, 2330, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2330isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_128_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_99_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(128) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_128(precedence, allow_fallback)) - } else { - self.parse_generated_rule_128(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(128); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 99, GeneratedRuleError::Fatal; self.parse_generated_rule_99(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_128(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_99(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(256isize, 128); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2 | 5..=6 | 12 | 21 | 27 | 40..=41 | 50 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 58..=60 | 105..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2335, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 2 | 5..=6 | 12 | 21 | 27 | 40..=41 | 50 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 58..=60 | 105..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2335, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2333isize); - let __child = self.parse_generated_rule_74_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(2334isize); - let __child = self.parse_generated_rule_129_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 198isize, 99, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(18, 1892, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_129_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_100_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(129) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_129(precedence, allow_fallback)) - } else { - self.parse_generated_rule_129(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(129); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 100, GeneratedRuleError::Fatal; self.parse_generated_rule_100(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_129(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_100(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(258isize, 129); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 2338, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 60 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 58..=59 | 105..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2338, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(60, 2339, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 200isize, 100, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(48, 1894, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1894isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 1897, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 10 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1897, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(10, 1896, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1896isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(2340isize); - let __child = self.parse_generated_rule_157_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __match = self.base.match_token_recovering(49, 1900, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_130_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_101_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(130) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_130(precedence, allow_fallback)) - } else { - self.parse_generated_rule_130(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(130); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 101, GeneratedRuleError::Fatal; self.parse_generated_rule_101(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_130(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_101(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(260isize, 130); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(2342isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_2347 = false; - loop { - match self.base.sync_decision(atn(), 2347, !__ctx.has_matched_child(), __loop_iter_2347) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 202isize, 101, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(33, 1903, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1903, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -37956,12 +29587,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2347) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1903) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(350, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(276, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -37971,7 +29602,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(350, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(276, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -37980,163 +29611,205 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 2347, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1903, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2347 = true; - let __match = self.base.match_token_recovering(16, 2344, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2344isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1902isize); + let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - match self.base.sync_decision(atn(), 2351, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 2351, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 2352, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1906, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1906) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(277, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(277, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1906, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(23, 1907, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __invoking_marker = self.base.push_invoking_state(1908isize); + let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_131_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_102_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 102, GeneratedRuleError::Fatal; self.parse_generated_rule_102(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_102(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 204isize, 102, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(15, 1911, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1911isize); + let __child = self.parse_generated_rule_113_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(1912isize); + let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + success {} + recovery {} } - if let Some(error) = self.base.parse_listener_enter_rule(131) { - return Err(GeneratedRuleError::Fatal(error)); + } + + #[allow(dead_code)] + fn parse_generated_rule_103_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 103, GeneratedRuleError::Fatal; self.parse_generated_rule_103(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_103(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 206isize, 103, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(44, 1915, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_131(precedence, allow_fallback)) - } else { - self.parse_generated_rule_131(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(131); - __listener_result } #[allow(dead_code)] - fn parse_generated_rule_131(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_104_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 104, GeneratedRuleError::Fatal; self.parse_generated_rule_104(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_104(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(262isize, 131); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2..=3 | 5..=6 | 12 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2368, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 208isize, 104, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 1926, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2368) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(355, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(355, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2368, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2353isize); - let __child = self.parse_generated_rule_132_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(2354isize); - let __child = self.parse_generated_rule_151_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_2359 = false; - loop { - match self.base.sync_decision(atn(), 2359, !__ctx.has_matched_child(), __loop_iter_2359) { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1926) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(279, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(279, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1926, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(3, 1917, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(4, 1927, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + let __match = self.base.match_token_recovering(3, 1919, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1919isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(16, 1922, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1922, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -38146,12 +29819,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2359) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1922) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(352, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(278, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -38161,7 +29834,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(352, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(278, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -38170,330 +29843,164 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 2359, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1922, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2359 = true; - let __match = self.base.match_token_recovering(16, 2356, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2356isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1921isize); + let __child = self.parse_generated_rule_118_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(4, 1925, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - match self.base.sync_decision(atn(), 2366, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 2366, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 2364, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2364, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 46 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 2364, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2363isize); - let __child = self.parse_generated_rule_132_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_132_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_105_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(132) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_132(precedence, allow_fallback)) - } else { - self.parse_generated_rule_132(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(132); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 105, GeneratedRuleError::Fatal; self.parse_generated_rule_105(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_132(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_105(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(264isize, 132); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(46, 2373, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2373, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 2373, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 2372, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2372isize); - let __child = self.parse_generated_rule_130_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 210isize, 105, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(34, 1929, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1929isize); + let __child = self.parse_generated_rule_108_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_133_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_106_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(133) { - return Err(GeneratedRuleError::Fatal(error)); + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 106, GeneratedRuleError::Fatal; self.parse_generated_rule_106(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_106(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 212isize, 106, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(34, 1932, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1932isize); + let __child = self.parse_generated_rule_111_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + success {} + recovery {} } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_133(precedence, allow_fallback)) - } else { - self.parse_generated_rule_133(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(133); - __listener_result } #[allow(dead_code)] - fn parse_generated_rule_133(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_107_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 107, GeneratedRuleError::Fatal; self.parse_generated_rule_107(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_107(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(266isize, 133); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 110 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 111 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2378, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 214isize, 107, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 1935, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 110 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 111 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2378, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2375isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(110, 2379, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __match = self.base.match_token_recovering(111, 2379, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 57 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=6 | 12 | 21 | 27 | 33 | 40..=41 | 43 | 45 | 50 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1935, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(57, 1936, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + let __invoking_marker = self.base.push_invoking_state(1937isize); + let __child = self.parse_generated_rule_111_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_134_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_108_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(134) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_134(precedence, allow_fallback)) - } else { - self.parse_generated_rule_134(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(134); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 108, GeneratedRuleError::Fatal; self.parse_generated_rule_108(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_134(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_108(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(268isize, 134); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 46 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 110..=111 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 23 | 35 | 47 | 64 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2416, !__ctx.has_matched_child(), false) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 216isize, 108, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(1939isize); + let __child = self.parse_generated_rule_109_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_1944 = false; + loop { + match self.base.sync_decision(atn(), 1944, !__ctx.has_matched_child(), __loop_iter_1944) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -38502,13 +30009,13 @@ where return Err(__error); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2416) { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1944) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(364, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(281, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -38518,7 +30025,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(364, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(281, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -38526,33 +30033,99 @@ where } else { __prediction } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1944, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_1944 = true; + let __match = self.base.match_token_recovering(54, 1941, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(1941isize); + let __child = self.parse_generated_rule_109_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2416, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(46, 2417, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1948, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { - let __invoking_marker = self.base.push_invoking_state(2381isize); - let __child = self.parse_generated_rule_133_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(24, 2383, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2383isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_2391 = false; - loop { - match self.base.sync_decision(atn(), 2391, !__ctx.has_matched_child(), __loop_iter_2391) { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1948) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(282, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(282, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1948, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(54, 1949, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_109_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 109, GeneratedRuleError::Fatal; self.parse_generated_rule_109(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_109(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 218isize, 109, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=6 | 12 | 21 | 27 | 33 | 40..=41 | 43 | 45 | 50 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 11 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1976, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -38561,142 +30134,376 @@ where return Err(__error); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2391) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(358, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(358, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=6 | 12 | 21 | 27 | 33 | 40..=41 | 43 | 45 | 50 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 11 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1976, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1950isize); + let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(1951isize); + let __child = self.parse_generated_rule_111_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 3 => { + let __match = self.base.match_token_recovering(11, 1953, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(50, 1973, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1973, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2 | 21 | 27 | 40..=41 | 52 | 55 | 69 | 98..=100 | 102..=104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 2391, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1973, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2391 = true; - let __match = self.base.match_token_recovering(16, 2385, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2385isize); - let __child = self.parse_generated_rule_133_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(24, 2387, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2387isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 52 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1957, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 52 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1957, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1954isize); + let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(1955isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 3 => { + let __match = self.base.match_token_recovering(52, 1958, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let mut __loop_iter_1967 = false; + loop { + match self.base.sync_decision(atn(), 1967, !__ctx.has_matched_child(), __loop_iter_1967) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1967) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(285, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(285, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1967, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_1967 = true; + let __match = self.base.match_token_recovering(16, 1963, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 52 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 1963, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 52 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1963, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1960isize); + let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(1961isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 3 => { + let __match = self.base.match_token_recovering(52, 1964, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + match self.base.sync_decision(atn(), 1971, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1971, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 1972, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(51, 1977, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - match self.base.sync_decision(atn(), 2399, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_110_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 110, GeneratedRuleError::Fatal; self.parse_generated_rule_110(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_110(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 220isize, 110, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 1979, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2399) { - __prediction + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1979) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(289, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(289, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(360, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(360, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1979, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(57, 1980, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 1982, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1982) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(290, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? }; - self.base.record_generated_prediction_diagnostic(atn(), 2399, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 2395, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(46, 2400, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - match self.base.sync_decision(atn(), 2397, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 2397, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 2398, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(290, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction } + }; + self.base.record_generated_prediction_diagnostic(atn(), 1982, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1981isize); + let __child = self.parse_generated_rule_108_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 3 => { - let __invoking_marker = self.base.push_invoking_state(2401isize); - let __child = self.parse_generated_rule_135_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_2406 = false; - loop { - match self.base.sync_decision(atn(), 2406, !__ctx.has_matched_child(), __loop_iter_2406) { + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_111_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 111, GeneratedRuleError::Fatal; self.parse_generated_rule_111(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_111(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 222isize, 111, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2 | 5..=6 | 12 | 21 | 27 | 33 | 40..=41 | 43 | 45 | 50 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2001, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -38705,13 +30512,13 @@ where return Err(__error); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2406) { + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2001) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(361, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(295, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -38721,7 +30528,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(361, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(295, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -38729,321 +30536,103 @@ where } else { __prediction } + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2001, &__prediction); + match __prediction.alt { + 1 => { + match self.base.sync_decision(atn(), 1985, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 43 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=6 | 12 | 21 | 27 | 33 | 40..=41 | 45 | 50 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 2406, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1985, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2406 = true; - let __match = self.base.match_token_recovering(16, 2403, atn())?; + let __match = self.base.match_token_recovering(43, 1986, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2403isize); - let __child = self.parse_generated_rule_135_dispatch(0, false).map_err(GeneratedRuleError::into_error); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 1988, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 45 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=6 | 12 | 21 | 27 | 33 | 40..=41 | 50 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 1988, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(1987isize); + let __child = self.parse_generated_rule_81_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __invoking_marker = self.base.push_invoking_state(1990isize); + let __child = self.parse_generated_rule_85_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2414, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2414) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(363, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(363, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2414, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 2410, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(46, 2415, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - match self.base.sync_decision(atn(), 2412, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 2412, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 2413, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_135_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(135) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_135(precedence, allow_fallback)) - } else { - self.parse_generated_rule_135(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(135); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_135(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(270isize, 135); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 23 | 35 | 64 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2444, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2444) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(370, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(370, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2444, &__prediction); - match __prediction.alt { - 1 => { - let mut __loop_iter_2421 = false; - loop { - match self.base.sync_decision(atn(), 2421, !__ctx.has_matched_child(), __loop_iter_2421) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + 2 => { + let __match = self.base.match_token_recovering(3, 1993, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 1993, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 23 | 27 | 35 | 40..=41 | 55 | 64 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 43 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=6 | 12 | 21 | 27 | 33 | 40..=41 | 45 | 50 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 2421, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1993, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2421 = true; - let __invoking_marker = self.base.push_invoking_state(2418isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(43, 1994, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - match self.base.sync_decision(atn(), 2425, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 64 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 23 | 27 | 35 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2425, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(64, 2426, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 2428, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 35 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 23 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2428, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(35, 2429, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 2431, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2431, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(23, 2432, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(2433isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let mut __loop_iter_2437 = false; - loop { - match self.base.sync_decision(atn(), 2437, !__ctx.has_matched_child(), __loop_iter_2437) { + match self.base.sync_decision(atn(), 1996, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -39054,412 +30643,144 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 45 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=6 | 12 | 21 | 27 | 33 | 40..=41 | 50 | 52 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 2437, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 1996, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2437 = true; - let __invoking_marker = self.base.push_invoking_state(2434isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(1995isize); + let __child = self.parse_generated_rule_81_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __invoking_marker = self.base.push_invoking_state(1998isize); + let __child = self.parse_generated_rule_85_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(4, 2000, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __invoking_marker = self.base.push_invoking_state(2440isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(24, 2442, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2442isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_136_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_112_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(136) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_136(precedence, allow_fallback)) - } else { - self.parse_generated_rule_136(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(136); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 112, GeneratedRuleError::Fatal; self.parse_generated_rule_112(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_136(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_112(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(272isize, 136); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 2448, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2448) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(371, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(371, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2448, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(33, 2447, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(55, 2449, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 2451, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 224isize, 112, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 2004, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2451) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(372, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 45 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 9 | 20 | 31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(372, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2451, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2450isize); - let __child = self.parse_generated_rule_113_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(2453isize); - let __child = self.parse_generated_rule_181_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_137_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(137) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_137(precedence, allow_fallback)) - } else { - self.parse_generated_rule_137(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(137); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_137(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(274isize, 137); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 2457, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + self.base.record_generated_prediction_diagnostic(atn(), 2004, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2003isize); + let __child = self.parse_generated_rule_81_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + match self.base.sync_decision(atn(), 2007, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2457) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(373, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 20 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 9 | 31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(373, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2457, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(33, 2456, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(55, 2458, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 2460, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + self.base.record_generated_prediction_diagnostic(atn(), 2007, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(20, 2008, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + match self.base.sync_decision(atn(), 2010, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2460) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(374, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 9 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(374, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2460, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2459isize); - let __child = self.parse_generated_rule_113_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { + self.base.record_generated_prediction_diagnostic(atn(), 2010, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2009isize); + let __child = self.parse_generated_rule_114_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(2462isize); - let __child = self.parse_generated_rule_195_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_138_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(138) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_138(precedence, allow_fallback)) - } else { - self.parse_generated_rule_138(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(138); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_138(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(276isize, 138); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(2464isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_2469 = false; - loop { - match self.base.sync_decision(atn(), 2469, !__ctx.has_matched_child(), __loop_iter_2469) { + let __match = self.base.match_token_recovering(31, 2013, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(3, 2015, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2015, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -39469,12 +30790,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2469) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2015) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(375, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(299, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -39484,7 +30805,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(375, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(299, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -39493,111 +30814,23 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 2469, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2015, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2469 = true; - let __match = self.base.match_token_recovering(16, 2466, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2466isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(2014isize); + let __child = self.parse_generated_rule_33_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - match self.base.sync_decision(atn(), 2473, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 2473, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 2474, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_139_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(139) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_139(precedence, allow_fallback)) - } else { - self.parse_generated_rule_139(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(139); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_139(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(278isize, 139); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(13, 2479, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_2479 = false; - loop { - match self.base.sync_decision(atn(), 2479, !__ctx.has_matched_child(), __loop_iter_2479) { + let __match = self.base.match_token_recovering(4, 2019, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2019, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -39607,12 +30840,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2479) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2019) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(377, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(300, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -39622,7 +30855,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(377, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(300, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -39631,113 +30864,68 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 2479, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2019, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2479 = true; - let __invoking_marker = self.base.push_invoking_state(2476isize); - let __child = self.parse_generated_rule_141_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(2018isize); + let __child = self.parse_generated_rule_39_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - match self.base.sync_decision(atn(), 2483, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2..=3 | 5..=7 | 12..=13 | 15 | 18 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2483, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2482isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(14, 2486, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_140_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_113_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(140) { - return Err(GeneratedRuleError::Fatal(error)); + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 113, GeneratedRuleError::Fatal; self.parse_generated_rule_113(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_113(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 226isize, 113, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_set_recovering(&[(23, 23), (28, 28)], 2022, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_140(precedence, allow_fallback)) - } else { - self.parse_generated_rule_140(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(140); - __listener_result } #[allow(dead_code)] - fn parse_generated_rule_140(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_114_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 114, GeneratedRuleError::Fatal; self.parse_generated_rule_114(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_114(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(280isize, 140); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(13, 2491, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_2491 = false; - loop { - match self.base.sync_decision(atn(), 2491, !__ctx.has_matched_child(), __loop_iter_2491) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 228isize, 114, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(9, 2025, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2025, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -39747,49 +30935,44 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2491) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(379, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(379, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } + let __prediction = match self.base.la(1) { + 106 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 | 31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - self.base.record_generated_prediction_diagnostic(atn(), 2491, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2025, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2491 = true; - let __invoking_marker = self.base.push_invoking_state(2488isize); - let __child = self.parse_generated_rule_67_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(106, 2026, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let mut __loop_iter_2497 = false; - loop { - match self.base.sync_decision(atn(), 2497, !__ctx.has_matched_child(), __loop_iter_2497) { + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_115_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 115, GeneratedRuleError::Fatal; self.parse_generated_rule_115(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_115(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 230isize, 115, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 2068, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -39799,12 +30982,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2497) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2068) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(380, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(308, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -39814,7 +30997,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(380, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(308, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -39823,167 +31006,128 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 2497, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2068, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2497 = true; - let __invoking_marker = self.base.push_invoking_state(2494isize); - let __child = self.parse_generated_rule_141_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __match = self.base.match_token_recovering(50, 2028, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(51, 2069, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + let __match = self.base.match_token_recovering(50, 2030, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2030isize); + let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - match self.base.sync_decision(atn(), 2501, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2..=3 | 5..=7 | 12..=13 | 15 | 18 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2501, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2500isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(14, 2504, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_141_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(141) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_141(precedence, allow_fallback)) - } else { - self.parse_generated_rule_141(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(141); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_141(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(282isize, 141); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 10 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 1 | 8..=9 | 11 | 19 | 26 | 29 | 31 | 34 | 38..=39 | 42 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 3 | 7 | 15 | 18 | 23 | 33 | 36 | 44 | 46 | 48 | 50 | 58..=61 | 63..=64 | 73..=77 | 79..=80 | 105..=112 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2554, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2554) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(388, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(388, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2554, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(10, 2555, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(2506isize); - let __child = self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 3 => { - let mut __loop_iter_2510 = false; - loop { - match self.base.sync_decision(atn(), 2510, !__ctx.has_matched_child(), __loop_iter_2510) { + let mut __loop_iter_2038 = false; + loop { + match self.base.sync_decision(atn(), 2038, !__ctx.has_matched_child(), __loop_iter_2038) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2038) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(303, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(303, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2038, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2038 = true; + let __match = self.base.match_token_recovering(16, 2034, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2034, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2034) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(302, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(302, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2034, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2032isize); + let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(2033isize); + let __child = self.parse_generated_rule_116_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + match self.base.sync_decision(atn(), 2042, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -39994,89 +31138,145 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 65 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 2510, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2042, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2510 = true; - let __invoking_marker = self.base.push_invoking_state(2507isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(16, 2043, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(51, 2045, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __match = self.base.match_token_recovering(65, 2514, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2514isize); - let __child = self.parse_generated_rule_151_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 2517, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2517, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(24, 2516, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2516isize); - let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 3 => { + let __match = self.base.match_token_recovering(50, 2052, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_2052 = false; + loop { + match self.base.sync_decision(atn(), 2052, !__ctx.has_matched_child(), __loop_iter_2052) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2052) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(305, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(305, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2052, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2052 = true; + let __invoking_marker = self.base.push_invoking_state(2047isize); + let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(16, 2049, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - 2 => { + let __invoking_marker = self.base.push_invoking_state(2055isize); + let __child = self.parse_generated_rule_116_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_2060 = false; + loop { + match self.base.sync_decision(atn(), 2060, !__ctx.has_matched_child(), __loop_iter_2060) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2060) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(306, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(306, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2060, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2060 = true; + let __match = self.base.match_token_recovering(16, 2057, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2057isize); + let __child = self.parse_generated_rule_116_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(25, 2520, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2520isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(66, 2522, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2522isize); - let __child = self.parse_generated_rule_139_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(10, 2524, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 4 => { - let mut __loop_iter_2528 = false; - loop { - match self.base.sync_decision(atn(), 2528, !__ctx.has_matched_child(), __loop_iter_2528) { + match self.base.sync_decision(atn(), 2064, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -40087,104 +31287,146 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 65 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 2528, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2064, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2528 = true; - let __invoking_marker = self.base.push_invoking_state(2525isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(16, 2065, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(51, 2067, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __match = self.base.match_token_recovering(65, 2532, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2532isize); - let __child = self.parse_generated_rule_151_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 2535, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_116_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 116, GeneratedRuleError::Fatal; self.parse_generated_rule_116(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_116(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 232isize, 116, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 2093, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 | 25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2093) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(310, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? }; - self.base.record_generated_prediction_diagnostic(atn(), 2535, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(24, 2534, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2534isize); - let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(310, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction } - match self.base.sync_decision(atn(), 2539, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2093, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2070isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(25, 2072, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2072isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 25 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2539, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(25, 2538, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2538isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 2 => { + let __invoking_marker = self.base.push_invoking_state(2074isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(24, 2076, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2076isize); + let __child = self.parse_generated_rule_108_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(10, 2542, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 5 => { - let mut __loop_iter_2546 = false; - loop { - match self.base.sync_decision(atn(), 2546, !__ctx.has_matched_child(), __loop_iter_2546) { + 3 => { + let __invoking_marker = self.base.push_invoking_state(2078isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 4 => { + let __match = self.base.match_token_recovering(110, 2094, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 5 => { + let __match = self.base.match_token_recovering(58, 2094, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 6 => { + let __match = self.base.match_token_recovering(59, 2094, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 7 => { + let __match = self.base.match_token_recovering(60, 2083, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(110, 2094, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 8 => { + match self.base.sync_decision(atn(), 2085, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -40195,118 +31437,202 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 | 20 | 28 | 30 | 45 | 67..=71 | 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 60 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 111..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 2546, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2085, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2546 = true; - let __invoking_marker = self.base.push_invoking_state(2543isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(60, 2086, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_set_recovering(&[(111, 112)], 2094, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 9 => { + let __match = self.base.match_token_recovering(108, 2094, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 10 => { + let __match = self.base.match_token_recovering(109, 2094, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 11 => { + let __match = self.base.match_token_recovering(105, 2094, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 12 => { + let __match = self.base.match_token_recovering(106, 2094, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 13 => { + let __match = self.base.match_token_recovering(107, 2094, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __invoking_marker = self.base.push_invoking_state(2549isize); - let __child = self.parse_generated_rule_142_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 6 => { - let __invoking_marker = self.base.push_invoking_state(2550isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(10, 2552, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_117_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 117, GeneratedRuleError::Fatal; self.parse_generated_rule_117(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_117(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 234isize, 117, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 2096, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 7 => { - let __invoking_marker = self.base.push_invoking_state(2553isize); - let __child = self.parse_generated_rule_212_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2096) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(311, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(311, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2096, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(57, 2097, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __invoking_marker = self.base.push_invoking_state(2098isize); + let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 2101, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2101) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(312, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(312, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2101, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(54, 2100, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2100isize); + let __child = self.parse_generated_rule_95_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_142_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_118_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(142) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_142(precedence, allow_fallback)) - } else { - self.parse_generated_rule_142(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(142); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 118, GeneratedRuleError::Fatal; self.parse_generated_rule_118(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_142(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_118(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(284isize, 142); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 70 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 67 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 71 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 45 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 68 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 20 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 69 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 30 => antlr4_runtime::ParserAtnPrediction { alt: 10, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 28 => antlr4_runtime::ParserAtnPrediction { alt: 11, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2618, !__ctx.has_matched_child(), false) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 236isize, 118, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(2103isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_2108 = false; + loop { + match self.base.sync_decision(atn(), 2108, !__ctx.has_matched_child(), __loop_iter_2108) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -40315,13 +31641,13 @@ where return Err(__error); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2618) { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2108) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(397, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(313, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -40331,7 +31657,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(397, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(313, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -40339,155 +31665,182 @@ where } else { __prediction } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2108, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2108 = true; + let __match = self.base.match_token_recovering(16, 2105, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2105isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2618, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2556isize); - let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 2112, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { - let __invoking_marker = self.base.push_invoking_state(2557isize); - let __child = self.parse_generated_rule_143_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __invoking_marker = self.base.push_invoking_state(2558isize); - let __child = self.parse_generated_rule_139_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_2565 = false; - loop { - match self.base.sync_decision(atn(), 2565, !__ctx.has_matched_child(), __loop_iter_2565) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2565) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(389, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(389, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2565, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_2565 = true; - let __match = self.base.match_token_recovering(66, 2560, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2560isize); - let __child = self.parse_generated_rule_143_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __invoking_marker = self.base.push_invoking_state(2561isize); - let __child = self.parse_generated_rule_139_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 2112, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 2113, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - match self.base.sync_decision(atn(), 2570, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + 2 => { } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2570) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(390, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(390, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2570, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(66, 2569, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2569isize); - let __child = self.parse_generated_rule_139_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_119_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 119, GeneratedRuleError::Fatal; self.parse_generated_rule_119(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_119(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 238isize, 119, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 2131, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } } - 3 => { - let __match = self.base.match_token_recovering(67, 2573, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2573isize); - let __child = self.parse_generated_rule_137_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(13, 2578, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_2578 = false; - loop { - match self.base.sync_decision(atn(), 2578, !__ctx.has_matched_child(), __loop_iter_2578) { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2131) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(317, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(317, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2131, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(50, 2115, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2115isize); + let __child = self.parse_generated_rule_121_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(51, 2117, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + let __match = self.base.match_token_recovering(50, 2124, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_2124 = false; + loop { + match self.base.sync_decision(atn(), 2124, !__ctx.has_matched_child(), __loop_iter_2124) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2124) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(315, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(315, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2124, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2124 = true; + let __invoking_marker = self.base.push_invoking_state(2119isize); + let __child = self.parse_generated_rule_120_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(16, 2121, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + match self.base.sync_decision(atn(), 2128, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -40497,12 +31850,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2578) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2128) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(391, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(316, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -40512,7 +31865,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(391, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(316, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -40521,23 +31874,49 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 2578, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2128, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2578 = true; - let __invoking_marker = self.base.push_invoking_state(2575isize); - let __child = self.parse_generated_rule_67_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(2127isize); + let __child = self.parse_generated_rule_123_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(51, 2132, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - match self.base.sync_decision(atn(), 2582, !__ctx.has_matched_child(), false) { + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_120_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 120, GeneratedRuleError::Fatal; self.parse_generated_rule_120(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_120(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 240isize, 120, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __loop_iter_2136 = false; + loop { + match self.base.sync_decision(atn(), 2136, !__ctx.has_matched_child(), __loop_iter_2136) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -40548,158 +31927,117 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 2..=3 | 5..=6 | 12 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 46..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 28 | 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 2582, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2136, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(2581isize); - let __child = self.parse_generated_rule_149_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_2136 = true; + let __invoking_marker = self.base.push_invoking_state(2133isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __match = self.base.match_token_recovering(14, 2585, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - 4 => { - match self.base.sync_decision(atn(), 2587, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + match self.base.sync_decision(atn(), 2140, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2587, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2586isize); - let __child = self.parse_generated_rule_148_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } - let __invoking_marker = self.base.push_invoking_state(2589isize); - let __child = self.parse_generated_rule_144_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __invoking_marker = self.base.push_invoking_state(2590isize); - let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); } - 5 => { - match self.base.sync_decision(atn(), 2593, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 28 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2140, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(28, 2141, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 45 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2593, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2592isize); - let __child = self.parse_generated_rule_148_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 2 => { } - let __match = self.base.match_token_recovering(45, 2596, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2596isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(7, 2598, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2598isize); - let __child = self.parse_generated_rule_137_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __invoking_marker = self.base.push_invoking_state(2599isize); - let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 6 => { - match self.base.sync_decision(atn(), 2602, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + let __invoking_marker = self.base.push_invoking_state(2142isize); + let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 2145, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 68 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2602, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2601isize); - let __child = self.parse_generated_rule_148_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } - let __match = self.base.match_token_recovering(68, 2605, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2605isize); - let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); } - 7 => { - match self.base.sync_decision(atn(), 2607, !__ctx.has_matched_child(), false) { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 16 | 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 2145, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(24, 2144, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2144isize); + let __child = self.parse_generated_rule_84_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_121_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 121, GeneratedRuleError::Fatal; self.parse_generated_rule_121(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_121(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 242isize, 121, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(2147isize); + let __child = self.parse_generated_rule_120_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_2152 = false; + loop { + match self.base.sync_decision(atn(), 2152, !__ctx.has_matched_child(), __loop_iter_2152) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -40709,476 +32047,183 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2152) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(321, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(321, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } }; - self.base.record_generated_prediction_diagnostic(atn(), 2607, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2152, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(2606isize); - let __child = self.parse_generated_rule_148_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_2152 = true; + let __match = self.base.match_token_recovering(16, 2149, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2149isize); + let __child = self.parse_generated_rule_120_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __invoking_marker = self.base.push_invoking_state(2609isize); - let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); } - 8 => { - let __match = self.base.match_token_recovering(20, 2611, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2611isize); - let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 9 => { - let __match = self.base.match_token_recovering(69, 2613, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2613isize); - let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 10 => { - let __match = self.base.match_token_recovering(30, 2615, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2615isize); - let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 11 => { - let __match = self.base.match_token_recovering(28, 2617, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2617isize); - let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_143_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(143) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_143(precedence, allow_fallback)) - } else { - self.parse_generated_rule_143(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(143); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_143(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(286isize, 143); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 2630, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2630) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(398, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(398, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2630, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(70, 2621, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2621isize); - let __child = self.parse_generated_rule_137_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(70, 2623, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2623isize); - let __child = self.parse_generated_rule_145_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 3 => { - let __match = self.base.match_token_recovering(70, 2625, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(65, 2626, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2626isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(25, 2628, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2628isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_144_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(144) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_144(precedence, allow_fallback)) - } else { - self.parse_generated_rule_144(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(144); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_144(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(288isize, 144); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 2642, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + match self.base.sync_decision(atn(), 2156, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2642) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(399, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(399, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2642, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(71, 2633, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2633isize); - let __child = self.parse_generated_rule_137_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(71, 2635, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2635isize); - let __child = self.parse_generated_rule_145_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + self.base.record_generated_prediction_diagnostic(atn(), 2156, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 2157, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 3 => { - let __match = self.base.match_token_recovering(71, 2637, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(65, 2638, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2638isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(25, 2640, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2640isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_145_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_122_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(145) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_145(precedence, allow_fallback)) - } else { - self.parse_generated_rule_145(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(145); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 122, GeneratedRuleError::Fatal; self.parse_generated_rule_122(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_145(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_122(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(290isize, 145); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 65 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=6 | 12..=13 | 15 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=45 | 47..=48 | 50 | 52..=53 | 55 | 58..=61 | 64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2668, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 244isize, 122, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 2185, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 65 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=6 | 12..=13 | 15 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=45 | 47..=48 | 50 | 52..=53 | 55 | 58..=61 | 64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2668, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2644isize); - let __child = self.parse_generated_rule_147_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(36, 2646, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2646isize); - let __child = self.parse_generated_rule_146_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_2649 = true; - loop { - match self.base.sync_decision(atn(), 2649, !__ctx.has_matched_child(), __loop_iter_2649) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 2649, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_2649 = true; - let __match = self.base.match_token_recovering(36, 2646, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2646isize); - let __child = self.parse_generated_rule_146_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2185) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(328, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(328, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2185, &__prediction); + match __prediction.alt { + 1 => { + let mut __loop_iter_2161 = false; + loop { + match self.base.sync_decision(atn(), 2161, !__ctx.has_matched_child(), __loop_iter_2161) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { - break; + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 28 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2161, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2161 = true; + let __invoking_marker = self.base.push_invoking_state(2158isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(2651isize); - let __child = self.parse_generated_rule_191_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_2656 = false; - loop { - match self.base.sync_decision(atn(), 2656, !__ctx.has_matched_child(), __loop_iter_2656) { + let __match = self.base.match_token_recovering(28, 2165, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2165isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(24, 2167, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2167isize); + let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 2169, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -41188,12 +32233,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2656) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2169) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(401, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(324, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -41203,7 +32248,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(401, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(324, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -41212,36 +32257,60 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 2656, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2169, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2656 = true; - let __match = self.base.match_token_recovering(36, 2653, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2653isize); - let __child = self.parse_generated_rule_191_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(2168isize); + let __child = self.parse_generated_rule_61_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __match = self.base.match_token_recovering(36, 2660, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2660isize); - let __child = self.parse_generated_rule_147_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_2665 = false; - loop { - match self.base.sync_decision(atn(), 2665, !__ctx.has_matched_child(), __loop_iter_2665) { + 2 => { + let mut __loop_iter_2174 = false; + loop { + match self.base.sync_decision(atn(), 2174, !__ctx.has_matched_child(), __loop_iter_2174) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2174, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2174 = true; + let __invoking_marker = self.base.push_invoking_state(2171isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __invoking_marker = self.base.push_invoking_state(2177isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 2179, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -41251,93 +32320,129 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2179) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(326, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(326, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } }; - self.base.record_generated_prediction_diagnostic(atn(), 2665, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2179, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2665 = true; - let __match = self.base.match_token_recovering(36, 2662, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2662isize); - let __child = self.parse_generated_rule_146_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(2178isize); + let __child = self.parse_generated_rule_94_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 2182, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2182) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(327, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(327, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2182, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2181isize); + let __child = self.parse_generated_rule_60_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } + 3 => { + let __invoking_marker = self.base.push_invoking_state(2184isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_146_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_123_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(146) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_146(precedence, allow_fallback)) - } else { - self.parse_generated_rule_146(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(146); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 123, GeneratedRuleError::Fatal; self.parse_generated_rule_123(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_146(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_123(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(292isize, 146); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 65 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=6 | 12..=13 | 15 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=45 | 47..=48 | 50 | 52..=53 | 55 | 58..=61 | 64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2672, !__ctx.has_matched_child(), false) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 246isize, 123, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(2187isize); + let __child = self.parse_generated_rule_122_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_2192 = false; + loop { + match self.base.sync_decision(atn(), 2192, !__ctx.has_matched_child(), __loop_iter_2192) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -41346,266 +32451,131 @@ where return Err(__error); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 65 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=6 | 12..=13 | 15 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=45 | 47..=48 | 50 | 52..=53 | 55 | 58..=61 | 64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2192) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(329, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(329, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2192, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2192 = true; + let __match = self.base.match_token_recovering(16, 2189, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2189isize); + let __child = self.parse_generated_rule_122_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2672, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2670isize); - let __child = self.parse_generated_rule_147_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 2196, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { - let __invoking_marker = self.base.push_invoking_state(2671isize); - let __child = self.parse_generated_rule_191_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 51 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 2196, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 2197, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_147_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(147) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_147(precedence, allow_fallback)) - } else { - self.parse_generated_rule_147(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(147); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_147(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(294isize, 147); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(65, 2675, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2675isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(25, 2677, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2677isize); - let __child = self.parse_generated_rule_191_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_148_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(148) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_148(precedence, allow_fallback)) - } else { - self.parse_generated_rule_148(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(148); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_148(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(296isize, 148); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(2679isize); - let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(24, 2681, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_149_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_124_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(149) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_149(precedence, allow_fallback)) - } else { - self.parse_generated_rule_149(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(149); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 124, GeneratedRuleError::Fatal; self.parse_generated_rule_124(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_149(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_124(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(298isize, 149); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 2698, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 248isize, 124, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 2199, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2698) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(409, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=6 | 12 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 46 | 48 | 50 | 52..=53 | 55 | 58..=60 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(409, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + self.base.record_generated_prediction_diagnostic(atn(), 2199, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(61, 2200, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2698, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2682isize); - let __child = self.parse_generated_rule_150_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __invoking_marker = self.base.push_invoking_state(2683isize); - let __child = self.parse_generated_rule_142_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 2685, !__ctx.has_matched_child(), false) { + let __invoking_marker = self.base.push_invoking_state(2201isize); + let __child = self.parse_generated_rule_125_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_2206 = false; + loop { + match self.base.sync_decision(atn(), 2206, !__ctx.has_matched_child(), __loop_iter_2206) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -41615,1322 +32585,1065 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=6 | 12 | 14 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 46..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2206) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(332, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(332, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } }; - self.base.record_generated_prediction_diagnostic(atn(), 2685, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2206, &__prediction); match __prediction.alt { 1 => { - let __match = self.base.match_token_recovering(16, 2686, atn())?; + __loop_iter_2206 = true; + let __match = self.base.match_token_recovering(61, 2203, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 2688, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2..=3 | 5..=6 | 12 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 46..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 2688, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2687isize); - let __child = self.parse_generated_rule_149_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(2203isize); + let __child = self.parse_generated_rule_125_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - 2 => { - let __invoking_marker = self.base.push_invoking_state(2690isize); - let __child = self.parse_generated_rule_150_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __invoking_marker = self.base.push_invoking_state(2691isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 2696, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 2696, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 2694, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2694, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2..=3 | 5..=6 | 12 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 46..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 2694, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2693isize); - let __child = self.parse_generated_rule_149_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_150_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_125_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(150) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_150(precedence, allow_fallback)) - } else { - self.parse_generated_rule_150(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(150); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 125, GeneratedRuleError::Fatal; self.parse_generated_rule_125(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_150(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_125(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(300isize, 150); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __loop_iter_2703 = false; - loop { - match self.base.sync_decision(atn(), 2703, !__ctx.has_matched_child(), __loop_iter_2703) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 250isize, 125, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=6 | 12 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 46 | 48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 2..=3 | 5..=6 | 12 | 18 | 21 | 27 | 33 | 35..=36 | 40..=41 | 46 | 48 | 50 | 52..=53 | 55 | 58..=60 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2216, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2216) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(334, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(334, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } + } }; - self.base.record_generated_prediction_diagnostic(atn(), 2703, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2216, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2703 = true; - let __invoking_marker = self.base.push_invoking_state(2700isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(2209isize); + let __child = self.parse_generated_rule_127_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; + let __match = self.base.match_token_recovering(23, 2211, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2211isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 2214, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 62 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 7 | 10 | 14 | 16 | 23..=25 | 28 | 49 | 61 | 70 | 72 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 2214, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(62, 2213, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2213isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __invoking_marker = self.base.push_invoking_state(2706isize); - let __child = self.parse_generated_rule_151_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 2708, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 70 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 72 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2708, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2707isize); - let __child = self.parse_generated_rule_152_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(72, 2711, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_151_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_126_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(151) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_151(precedence, allow_fallback)) - } else { - self.parse_generated_rule_151(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(151); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 126, GeneratedRuleError::Fatal; self.parse_generated_rule_126(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_151(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_126(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(302isize, 151); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 2713, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2713) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(412, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(412, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2713, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(61, 2714, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(2715isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_2720 = false; - loop { - match self.base.sync_decision(atn(), 2720, !__ctx.has_matched_child(), __loop_iter_2720) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2720) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(413, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(413, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 252isize, 126, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 18 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 35 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2221, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 18 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 35 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } }; - self.base.record_generated_prediction_diagnostic(atn(), 2720, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2221, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2720 = true; - let __match = self.base.match_token_recovering(61, 2717, atn())?; + let __match = self.base.match_token_recovering(18, 2222, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2717isize); - let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + } + 2 => { + let __match = self.base.match_token_recovering(35, 2220, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2220isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } - 2 => { - break; - } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_152_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_127_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(152) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_152(precedence, allow_fallback)) - } else { - self.parse_generated_rule_152(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(152); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 127, GeneratedRuleError::Fatal; self.parse_generated_rule_127(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_152(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_127(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(304isize, 152); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(70, 2724, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2724isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_153_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(153) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_153(precedence, allow_fallback)) - } else { - self.parse_generated_rule_153(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(153); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_153(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(306isize, 153); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(2726isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_2730 = false; - loop { - match self.base.sync_decision(atn(), 2730, !__ctx.has_matched_child(), __loop_iter_2730) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2730) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(414, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(414, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 254isize, 127, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 63 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 46 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 23 => antlr4_runtime::ParserAtnPrediction { alt: 13, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 3 => antlr4_runtime::ParserAtnPrediction { alt: 17, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 64 => antlr4_runtime::ParserAtnPrediction { alt: 24, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 101 => antlr4_runtime::ParserAtnPrediction { alt: 25, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2331, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2331) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(347, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(347, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } } }; - self.base.record_generated_prediction_diagnostic(atn(), 2730, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2331, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2730 = true; - let __invoking_marker = self.base.push_invoking_state(2727isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __match = self.base.match_token_recovering(18, 2332, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + let __match = self.base.match_token_recovering(63, 2225, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2225isize); + let __child = self.parse_generated_rule_128_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } - 2 => { - break; + 3 => { + let __match = self.base.match_token_recovering(46, 2332, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_154_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(154) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_154(precedence, allow_fallback)) - } else { - self.parse_generated_rule_154(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(154); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_154(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(308isize, 154); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(2733isize); - let __child = self.parse_generated_rule_67_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_2737 = false; - loop { - match self.base.sync_decision(atn(), 2737, !__ctx.has_matched_child(), __loop_iter_2737) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + 4 => { + let __invoking_marker = self.base.push_invoking_state(2227isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 2230, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 62 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 7 | 10 | 14 | 16 | 23..=25 | 28 | 49 | 61 | 70 | 72 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 2230, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(62, 2229, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2229isize); + let __child = self.parse_generated_rule_151_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + 5 => { + let __invoking_marker = self.base.push_invoking_state(2232isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(62, 2234, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(3, 2235, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2235isize); + let __child = self.parse_generated_rule_151_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(4, 2237, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2737) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(415, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(415, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + 6 => { + let __invoking_marker = self.base.push_invoking_state(2238isize); + let __child = self.parse_generated_rule_129_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2737, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_2737 = true; - let __invoking_marker = self.base.push_invoking_state(2734isize); - let __child = self.parse_generated_rule_67_dispatch(0, false).map_err(GeneratedRuleError::into_error); + 7 => { + let __invoking_marker = self.base.push_invoking_state(2239isize); + let __child = self.parse_generated_rule_128_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(32, 2241, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2241isize); + let __child = self.parse_generated_rule_128_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } - 2 => { - break; + 8 => { + let __invoking_marker = self.base.push_invoking_state(2243isize); + let __child = self.parse_generated_rule_128_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(46, 2245, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2245isize); + let __child = self.parse_generated_rule_128_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_155_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(155) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_155(precedence, allow_fallback)) - } else { - self.parse_generated_rule_155(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(155); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_155(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(310isize, 155); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 3 | 13 | 20 | 22 | 28 | 30 | 45 | 48 | 58..=59 | 61 | 67..=68 | 70..=71 | 73..=77 | 79..=80 | 99..=100 | 103 | 105..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2751, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + 9 => { + let __invoking_marker = self.base.push_invoking_state(2247isize); + let __child = self.parse_generated_rule_128_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(46, 2249, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 10 => { + let __invoking_marker = self.base.push_invoking_state(2250isize); + let __child = self.parse_generated_rule_128_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(63, 2252, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2252isize); + let __child = self.parse_generated_rule_128_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 11 => { + let __invoking_marker = self.base.push_invoking_state(2254isize); + let __child = self.parse_generated_rule_74_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(2255isize); + let __child = self.parse_generated_rule_73_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 12 => { + let mut __loop_iter_2262 = false; + loop { + match self.base.sync_decision(atn(), 2262, !__ctx.has_matched_child(), __loop_iter_2262) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2262) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(337, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(337, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2262, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2262 = true; + let __invoking_marker = self.base.push_invoking_state(2257isize); + let __child = self.parse_generated_rule_126_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(16, 2259, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __invoking_marker = self.base.push_invoking_state(2265isize); + let __child = self.parse_generated_rule_126_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 2268, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2751) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(418, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 62 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 7 | 10 | 14 | 16 | 23..=25 | 28 | 49 | 61 | 70 | 72 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(418, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + self.base.record_generated_prediction_diagnostic(atn(), 2268, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(62, 2267, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2267isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2751, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2740isize); - let __child = self.parse_generated_rule_156_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(2741isize); - let __child = self.parse_generated_rule_74_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(13, 2744, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2744, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + 13 => { + match self.base.sync_decision(atn(), 2271, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 35 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 23 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2271, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(35, 2272, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2744) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(416, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + match self.base.sync_decision(atn(), 2274, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(416, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + self.base.record_generated_prediction_diagnostic(atn(), 2274, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(23, 2275, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2744, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2743isize); - let __child = self.parse_generated_rule_154_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(2276isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 2279, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 62 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 7 | 10 | 14 | 16 | 23..=25 | 28 | 49 | 61 | 70 | 72 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 2279, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(62, 2278, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2278isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - match self.base.sync_decision(atn(), 2747, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + 14 => { + let __invoking_marker = self.base.push_invoking_state(2281isize); + let __child = self.parse_generated_rule_74_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(3, 2284, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2284, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2..=3 | 5..=6 | 12 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 46 | 48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2284, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2283isize); + let __child = self.parse_generated_rule_131_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(4, 2287, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2 | 21 | 27 | 40..=41 | 46..=47 | 55 | 69 | 98 | 102 | 104 | 110 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2747, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2746isize); - let __child = self.parse_generated_rule_163_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 15 => { + let __invoking_marker = self.base.push_invoking_state(2288isize); + let __child = self.parse_generated_rule_74_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(13, 2291, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2291, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2 | 21 | 23 | 27 | 35 | 40..=41 | 46..=47 | 55 | 64 | 69 | 98 | 102 | 104 | 110..=111 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2291, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2290isize); + let __child = self.parse_generated_rule_134_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __match = self.base.match_token_recovering(14, 2294, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __match = self.base.match_token_recovering(14, 2750, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_156_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(156) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_156(precedence, allow_fallback)) - } else { - self.parse_generated_rule_156(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(156); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_156(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(312isize, 156); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 58..=59 | 105..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 6 | 12 | 21 | 27 | 40..=41 | 50 | 52..=53 | 55 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 22 | 61 | 73 | 79..=80 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 | 20 | 28 | 45 | 67..=68 | 70..=71 | 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 11, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 74 => antlr4_runtime::ParserAtnPrediction { alt: 12, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 75 => antlr4_runtime::ParserAtnPrediction { alt: 13, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 76 => antlr4_runtime::ParserAtnPrediction { alt: 14, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 77 => antlr4_runtime::ParserAtnPrediction { alt: 15, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2844, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + 16 => { + let __invoking_marker = self.base.push_invoking_state(2295isize); + let __child = self.parse_generated_rule_74_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2844) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(438, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + 17 => { + let __match = self.base.match_token_recovering(3, 2298, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2298, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2..=3 | 5..=6 | 12 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 46 | 48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(438, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + self.base.record_generated_prediction_diagnostic(atn(), 2298, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2297isize); + let __child = self.parse_generated_rule_131_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(4, 2332, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2844, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2753isize); - let __child = self.parse_generated_rule_157_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(5, 2845, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __invoking_marker = self.base.push_invoking_state(2755isize); - let __child = self.parse_generated_rule_74_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 2757, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + 18 => { + let __match = self.base.match_token_recovering(48, 2302, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2302isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_2307 = false; + loop { + match self.base.sync_decision(atn(), 2307, !__ctx.has_matched_child(), __loop_iter_2307) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2307) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(345, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(345, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2307, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2307 = true; + let __match = self.base.match_token_recovering(16, 2304, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2304isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + match self.base.sync_decision(atn(), 2311, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2757) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(419, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(419, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2757, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2756isize); - let __child = self.parse_generated_rule_73_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { + self.base.record_generated_prediction_diagnostic(atn(), 2311, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 2312, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __match = self.base.match_token_recovering(49, 2314, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - } - 4 => { - let __match = self.base.match_token_recovering(3, 2761, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2761, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + 19 => { + let __match = self.base.match_token_recovering(48, 2316, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(49, 2332, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2761, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2760isize); - let __child = self.parse_generated_rule_154_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 20 => { + let __match = self.base.match_token_recovering(33, 2318, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2318isize); + let __child = self.parse_generated_rule_127_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(4, 2845, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 5 => { - let __match = self.base.match_token_recovering(3, 2766, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2766, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + 21 => { + let __match = self.base.match_token_recovering(33, 2320, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(23, 2321, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2321isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2766) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(421, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(421, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2766, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2765isize); - let __child = self.parse_generated_rule_154_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 22 => { + let __match = self.base.match_token_recovering(36, 2323, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2323isize); + let __child = self.parse_generated_rule_127_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2768isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(4, 2770, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 6 => { - let __match = self.base.match_token_recovering(3, 2773, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2773, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + 23 => { + let __match = self.base.match_token_recovering(36, 2325, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(23, 2326, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2326isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2773) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(422, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(422, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2773, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2772isize); - let __child = self.parse_generated_rule_154_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 24 => { + let __match = self.base.match_token_recovering(64, 2328, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2328isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2775isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(16, 2778, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2778, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + 25 => { + let __match = self.base.match_token_recovering(101, 2330, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2330isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2..=3 | 5..=7 | 12..=13 | 15 | 18 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2778, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2777isize); - let __child = self.parse_generated_rule_138_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_128_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 128, GeneratedRuleError::Fatal; self.parse_generated_rule_128(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_128(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 256isize, 128, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2 | 5..=6 | 12 | 21 | 27 | 40..=41 | 50 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 58..=60 | 105..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2335, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 2 | 5..=6 | 12 | 21 | 27 | 40..=41 | 50 | 52..=53 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 58..=60 | 105..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __match = self.base.match_token_recovering(4, 2781, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2335, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2333isize); + let __child = self.parse_generated_rule_74_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(2334isize); + let __child = self.parse_generated_rule_129_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 7 => { - let __match = self.base.match_token_recovering(48, 2784, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2784, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_129_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 129, GeneratedRuleError::Fatal; self.parse_generated_rule_129(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_129(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 258isize, 129, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 2338, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2784) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(424, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(424, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2784, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2783isize); - let __child = self.parse_generated_rule_154_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } - match self.base.sync_decision(atn(), 2787, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 60 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 58..=59 | 105..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2338, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(60, 2339, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2..=3 | 5..=7 | 12..=13 | 15 | 18 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2787, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2786isize); - let __child = self.parse_generated_rule_138_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 2 => { } - let __match = self.base.match_token_recovering(49, 2845, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 8 => { - let __match = self.base.match_token_recovering(48, 2792, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2792, !__ctx.has_matched_child(), false) { + let __invoking_marker = self.base.push_invoking_state(2340isize); + let __child = self.parse_generated_rule_157_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_130_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 130, GeneratedRuleError::Fatal; self.parse_generated_rule_130(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_130(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 260isize, 130, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(2342isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_2347 = false; + loop { + match self.base.sync_decision(atn(), 2347, !__ctx.has_matched_child(), __loop_iter_2347) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -42940,12 +33653,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2792) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2347) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(426, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(350, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -42955,7 +33668,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(426, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(350, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -42964,136 +33677,130 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 2792, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2347, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(2791isize); - let __child = self.parse_generated_rule_154_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_2347 = true; + let __match = self.base.match_token_recovering(16, 2344, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2344isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __invoking_marker = self.base.push_invoking_state(2794isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(10, 2796, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2796isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(49, 2798, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - 9 => { - match self.base.sync_decision(atn(), 2800, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 22 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 61 | 73 | 79..=80 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2800, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(22, 2801, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + match self.base.sync_decision(atn(), 2351, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - match self.base.sync_decision(atn(), 2803, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 61 | 79..=80 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2803, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(73, 2804, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 2351, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 2352, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { } - let __invoking_marker = self.base.push_invoking_state(2805isize); - let __child = self.parse_generated_rule_158_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __invoking_marker = self.base.push_invoking_state(2806isize); - let __child = self.parse_generated_rule_161_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 10 => { - let __match = self.base.match_token_recovering(30, 2810, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2810, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_131_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 131, GeneratedRuleError::Fatal; self.parse_generated_rule_131(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_131(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 262isize, 131, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2..=3 | 5..=6 | 12 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2368, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2368) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(355, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(355, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 | 20 | 28 | 30 | 45 | 61 | 67..=71 | 79..=80 | 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2810, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(73, 2811, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2368, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2353isize); + let __child = self.parse_generated_rule_132_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 13 | 20 | 28 | 30 | 45 | 67..=71 | 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 61 | 79..=80 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2816, !__ctx.has_matched_child(), false) { + 2 => { + let __invoking_marker = self.base.push_invoking_state(2354isize); + let __child = self.parse_generated_rule_151_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_2359 = false; + loop { + match self.base.sync_decision(atn(), 2359, !__ctx.has_matched_child(), __loop_iter_2359) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -43102,347 +33809,4898 @@ where return Err(__error); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 13 | 20 | 28 | 30 | 45 | 67..=71 | 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 61 | 79..=80 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2359) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(352, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(352, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2359, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2359 = true; + let __match = self.base.match_token_recovering(16, 2356, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2356isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2816, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2812isize); - let __child = self.parse_generated_rule_142_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 2366, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { - let __invoking_marker = self.base.push_invoking_state(2813isize); - let __child = self.parse_generated_rule_158_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __invoking_marker = self.base.push_invoking_state(2814isize); - let __child = self.parse_generated_rule_161_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 2366, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 2364, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2364, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 46 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 2364, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2363isize); + let __child = self.parse_generated_rule_132_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 11 => { - let __invoking_marker = self.base.push_invoking_state(2818isize); - let __child = self.parse_generated_rule_142_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 12 => { - let __match = self.base.match_token_recovering(74, 2821, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2821, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_132_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 132, GeneratedRuleError::Fatal; self.parse_generated_rule_132(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_132(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 264isize, 132, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(46, 2373, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2373, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2821) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(431, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(431, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2821, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2820isize); - let __child = self.parse_generated_rule_162_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } - match self.base.sync_decision(atn(), 2824, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 2373, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 2372, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2372isize); + let __child = self.parse_generated_rule_130_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2824) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(432, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(432, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2824, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2823isize); - let __child = self.parse_generated_rule_157_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 2 => { } - match self.base.sync_decision(atn(), 2827, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_133_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 133, GeneratedRuleError::Fatal; self.parse_generated_rule_133(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_133(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 266isize, 133, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 110 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 111 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2378, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 110 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 111 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2827) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(433, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(433, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2827, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2826isize); - let __child = self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2378, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2375isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2830, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + 2 => { + let __match = self.base.match_token_recovering(110, 2379, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2830) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(434, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(434, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2830, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2829isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 3 => { + let __match = self.base.match_token_recovering(111, 2379, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 13 => { - let __match = self.base.match_token_recovering(75, 2834, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2834, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_134_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 134, GeneratedRuleError::Fatal; self.parse_generated_rule_134(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_134(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 268isize, 134, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 46 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 110..=111 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 23 | 35 | 47 | 64 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2416, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2834) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(435, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(435, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2416) { __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(364, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(364, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2834, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2833isize); - let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - 14 => { - let __match = self.base.match_token_recovering(76, 2838, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2838, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2416, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(46, 2417, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2838) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(436, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(436, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + 2 => { + let __invoking_marker = self.base.push_invoking_state(2381isize); + let __child = self.parse_generated_rule_133_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(24, 2383, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2383isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_2391 = false; + loop { + match self.base.sync_decision(atn(), 2391, !__ctx.has_matched_child(), __loop_iter_2391) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2391) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(358, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(358, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2391, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2391 = true; + let __match = self.base.match_token_recovering(16, 2385, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2385isize); + let __child = self.parse_generated_rule_133_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(24, 2387, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2387isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + match self.base.sync_decision(atn(), 2399, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2399) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(360, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(360, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2399, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 2395, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(46, 2400, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + match self.base.sync_decision(atn(), 2397, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 2397, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 2398, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + 3 => { + let __invoking_marker = self.base.push_invoking_state(2401isize); + let __child = self.parse_generated_rule_135_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_2406 = false; + loop { + match self.base.sync_decision(atn(), 2406, !__ctx.has_matched_child(), __loop_iter_2406) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2406) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(361, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(361, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2406, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2406 = true; + let __match = self.base.match_token_recovering(16, 2403, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2403isize); + let __child = self.parse_generated_rule_135_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + match self.base.sync_decision(atn(), 2414, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2414) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(363, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(363, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2414, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 2410, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(46, 2415, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + match self.base.sync_decision(atn(), 2412, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 2412, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 2413, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_135_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 135, GeneratedRuleError::Fatal; self.parse_generated_rule_135(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_135(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 270isize, 135, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 23 | 35 | 64 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2444, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2444) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(370, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(370, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2444, &__prediction); + match __prediction.alt { + 1 => { + let mut __loop_iter_2421 = false; + loop { + match self.base.sync_decision(atn(), 2421, !__ctx.has_matched_child(), __loop_iter_2421) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 23 | 27 | 35 | 40..=41 | 55 | 64 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2421, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2421 = true; + let __invoking_marker = self.base.push_invoking_state(2418isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + match self.base.sync_decision(atn(), 2425, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 64 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 23 | 27 | 35 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2425, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(64, 2426, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 2428, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 35 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 23 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2428, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(35, 2429, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 2431, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2431, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(23, 2432, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __invoking_marker = self.base.push_invoking_state(2433isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let mut __loop_iter_2437 = false; + loop { + match self.base.sync_decision(atn(), 2437, !__ctx.has_matched_child(), __loop_iter_2437) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2437, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2437 = true; + let __invoking_marker = self.base.push_invoking_state(2434isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __invoking_marker = self.base.push_invoking_state(2440isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(24, 2442, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2442isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_136_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 136, GeneratedRuleError::Fatal; self.parse_generated_rule_136(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_136(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 272isize, 136, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 2448, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2448) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(371, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(371, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2448, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(33, 2447, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(55, 2449, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 2451, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2451) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(372, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(372, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2451, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2450isize); + let __child = self.parse_generated_rule_113_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __invoking_marker = self.base.push_invoking_state(2453isize); + let __child = self.parse_generated_rule_181_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_137_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 137, GeneratedRuleError::Fatal; self.parse_generated_rule_137(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_137(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 274isize, 137, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 2457, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2457) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(373, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(373, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2457, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(33, 2456, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(55, 2458, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 2460, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2460) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(374, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(374, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2460, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2459isize); + let __child = self.parse_generated_rule_113_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __invoking_marker = self.base.push_invoking_state(2462isize); + let __child = self.parse_generated_rule_195_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_138_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 138, GeneratedRuleError::Fatal; self.parse_generated_rule_138(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_138(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 276isize, 138, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(2464isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_2469 = false; + loop { + match self.base.sync_decision(atn(), 2469, !__ctx.has_matched_child(), __loop_iter_2469) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2469) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(375, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(375, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2469, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2469 = true; + let __match = self.base.match_token_recovering(16, 2466, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2466isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + match self.base.sync_decision(atn(), 2473, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 2473, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 2474, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_139_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 139, GeneratedRuleError::Fatal; self.parse_generated_rule_139(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_139(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 278isize, 139, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(13, 2479, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_2479 = false; + loop { + match self.base.sync_decision(atn(), 2479, !__ctx.has_matched_child(), __loop_iter_2479) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2479) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(377, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(377, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2479, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2479 = true; + let __invoking_marker = self.base.push_invoking_state(2476isize); + let __child = self.parse_generated_rule_141_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + match self.base.sync_decision(atn(), 2483, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2..=3 | 5..=7 | 12..=13 | 15 | 18 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2483, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2482isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(14, 2486, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_140_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 140, GeneratedRuleError::Fatal; self.parse_generated_rule_140(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_140(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 280isize, 140, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(13, 2491, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_2491 = false; + loop { + match self.base.sync_decision(atn(), 2491, !__ctx.has_matched_child(), __loop_iter_2491) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2491) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(379, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(379, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2491, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2491 = true; + let __invoking_marker = self.base.push_invoking_state(2488isize); + let __child = self.parse_generated_rule_67_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let mut __loop_iter_2497 = false; + loop { + match self.base.sync_decision(atn(), 2497, !__ctx.has_matched_child(), __loop_iter_2497) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2497) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(380, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(380, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2497, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2497 = true; + let __invoking_marker = self.base.push_invoking_state(2494isize); + let __child = self.parse_generated_rule_141_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + match self.base.sync_decision(atn(), 2501, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2..=3 | 5..=7 | 12..=13 | 15 | 18 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2501, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2500isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(14, 2504, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_141_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 141, GeneratedRuleError::Fatal; self.parse_generated_rule_141(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_141(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 282isize, 141, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 10 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 1 | 8..=9 | 11 | 19 | 26 | 29 | 31 | 34 | 38..=39 | 42 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 3 | 7 | 15 | 18 | 23 | 33 | 36 | 44 | 46 | 48 | 50 | 58..=61 | 63..=64 | 73..=77 | 79..=80 | 105..=112 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2554, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2554) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(388, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(388, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2554, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(10, 2555, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(2506isize); + let __child = self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 3 => { + let mut __loop_iter_2510 = false; + loop { + match self.base.sync_decision(atn(), 2510, !__ctx.has_matched_child(), __loop_iter_2510) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 65 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2510, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2510 = true; + let __invoking_marker = self.base.push_invoking_state(2507isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __match = self.base.match_token_recovering(65, 2514, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2514isize); + let __child = self.parse_generated_rule_151_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 2517, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2517, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(24, 2516, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2516isize); + let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(25, 2520, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2520isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(66, 2522, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2522isize); + let __child = self.parse_generated_rule_139_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(10, 2524, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 4 => { + let mut __loop_iter_2528 = false; + loop { + match self.base.sync_decision(atn(), 2528, !__ctx.has_matched_child(), __loop_iter_2528) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 65 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2528, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2528 = true; + let __invoking_marker = self.base.push_invoking_state(2525isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __match = self.base.match_token_recovering(65, 2532, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2532isize); + let __child = self.parse_generated_rule_151_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 2535, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 | 25 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2535, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(24, 2534, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2534isize); + let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 2539, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 25 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2539, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(25, 2538, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2538isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(10, 2542, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 5 => { + let mut __loop_iter_2546 = false; + loop { + match self.base.sync_decision(atn(), 2546, !__ctx.has_matched_child(), __loop_iter_2546) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 | 20 | 28 | 30 | 45 | 67..=71 | 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2546, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2546 = true; + let __invoking_marker = self.base.push_invoking_state(2543isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __invoking_marker = self.base.push_invoking_state(2549isize); + let __child = self.parse_generated_rule_142_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 6 => { + let __invoking_marker = self.base.push_invoking_state(2550isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(10, 2552, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 7 => { + let __invoking_marker = self.base.push_invoking_state(2553isize); + let __child = self.parse_generated_rule_212_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_142_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 142, GeneratedRuleError::Fatal; self.parse_generated_rule_142(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_142(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 284isize, 142, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 70 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 67 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 71 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 45 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 68 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 20 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 69 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 30 => antlr4_runtime::ParserAtnPrediction { alt: 10, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 28 => antlr4_runtime::ParserAtnPrediction { alt: 11, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2618, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2618) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(397, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(397, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2618, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2556isize); + let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(2557isize); + let __child = self.parse_generated_rule_143_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(2558isize); + let __child = self.parse_generated_rule_139_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_2565 = false; + loop { + match self.base.sync_decision(atn(), 2565, !__ctx.has_matched_child(), __loop_iter_2565) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2565) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(389, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(389, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2565, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2565 = true; + let __match = self.base.match_token_recovering(66, 2560, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2560isize); + let __child = self.parse_generated_rule_143_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(2561isize); + let __child = self.parse_generated_rule_139_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + match self.base.sync_decision(atn(), 2570, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2570) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(390, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(390, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2570, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(66, 2569, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2569isize); + let __child = self.parse_generated_rule_139_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + 3 => { + let __match = self.base.match_token_recovering(67, 2573, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2573isize); + let __child = self.parse_generated_rule_137_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(13, 2578, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_2578 = false; + loop { + match self.base.sync_decision(atn(), 2578, !__ctx.has_matched_child(), __loop_iter_2578) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2578) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(391, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(391, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2578, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2578 = true; + let __invoking_marker = self.base.push_invoking_state(2575isize); + let __child = self.parse_generated_rule_67_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + match self.base.sync_decision(atn(), 2582, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2..=3 | 5..=6 | 12 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 46..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2582, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2581isize); + let __child = self.parse_generated_rule_149_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(14, 2585, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 4 => { + match self.base.sync_decision(atn(), 2587, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2587, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2586isize); + let __child = self.parse_generated_rule_148_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __invoking_marker = self.base.push_invoking_state(2589isize); + let __child = self.parse_generated_rule_144_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(2590isize); + let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 5 => { + match self.base.sync_decision(atn(), 2593, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 45 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2593, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2592isize); + let __child = self.parse_generated_rule_148_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(45, 2596, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2596isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(7, 2598, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2598isize); + let __child = self.parse_generated_rule_137_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(2599isize); + let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 6 => { + match self.base.sync_decision(atn(), 2602, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 68 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2602, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2601isize); + let __child = self.parse_generated_rule_148_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(68, 2605, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2605isize); + let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 7 => { + match self.base.sync_decision(atn(), 2607, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2607, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2606isize); + let __child = self.parse_generated_rule_148_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __invoking_marker = self.base.push_invoking_state(2609isize); + let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 8 => { + let __match = self.base.match_token_recovering(20, 2611, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2611isize); + let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 9 => { + let __match = self.base.match_token_recovering(69, 2613, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2613isize); + let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 10 => { + let __match = self.base.match_token_recovering(30, 2615, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2615isize); + let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 11 => { + let __match = self.base.match_token_recovering(28, 2617, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2617isize); + let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_143_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 143, GeneratedRuleError::Fatal; self.parse_generated_rule_143(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_143(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 286isize, 143, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 2630, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2630) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(398, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(398, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2630, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(70, 2621, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2621isize); + let __child = self.parse_generated_rule_137_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __match = self.base.match_token_recovering(70, 2623, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2623isize); + let __child = self.parse_generated_rule_145_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 3 => { + let __match = self.base.match_token_recovering(70, 2625, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(65, 2626, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2626isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(25, 2628, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2628isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_144_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 144, GeneratedRuleError::Fatal; self.parse_generated_rule_144(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_144(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 288isize, 144, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 2642, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2642) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(399, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(399, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2642, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(71, 2633, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2633isize); + let __child = self.parse_generated_rule_137_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __match = self.base.match_token_recovering(71, 2635, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2635isize); + let __child = self.parse_generated_rule_145_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 3 => { + let __match = self.base.match_token_recovering(71, 2637, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(65, 2638, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2638isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(25, 2640, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2640isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_145_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 145, GeneratedRuleError::Fatal; self.parse_generated_rule_145(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_145(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 290isize, 145, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 65 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=6 | 12..=13 | 15 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=45 | 47..=48 | 50 | 52..=53 | 55 | 58..=61 | 64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2668, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 65 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=6 | 12..=13 | 15 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=45 | 47..=48 | 50 | 52..=53 | 55 | 58..=61 | 64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2668, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2644isize); + let __child = self.parse_generated_rule_147_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(36, 2646, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2646isize); + let __child = self.parse_generated_rule_146_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_2649 = true; + loop { + match self.base.sync_decision(atn(), 2649, !__ctx.has_matched_child(), __loop_iter_2649) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 2649, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2649 = true; + let __match = self.base.match_token_recovering(36, 2646, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2646isize); + let __child = self.parse_generated_rule_146_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(2651isize); + let __child = self.parse_generated_rule_191_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_2656 = false; + loop { + match self.base.sync_decision(atn(), 2656, !__ctx.has_matched_child(), __loop_iter_2656) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2656) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(401, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(401, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2656, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2656 = true; + let __match = self.base.match_token_recovering(36, 2653, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2653isize); + let __child = self.parse_generated_rule_191_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __match = self.base.match_token_recovering(36, 2660, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2660isize); + let __child = self.parse_generated_rule_147_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_2665 = false; + loop { + match self.base.sync_decision(atn(), 2665, !__ctx.has_matched_child(), __loop_iter_2665) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 2665, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2665 = true; + let __match = self.base.match_token_recovering(36, 2662, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2662isize); + let __child = self.parse_generated_rule_146_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_146_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 146, GeneratedRuleError::Fatal; self.parse_generated_rule_146(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_146(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 292isize, 146, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 65 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=6 | 12..=13 | 15 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=45 | 47..=48 | 50 | 52..=53 | 55 | 58..=61 | 64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2672, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 65 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=6 | 12..=13 | 15 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=45 | 47..=48 | 50 | 52..=53 | 55 | 58..=61 | 64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2672, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2670isize); + let __child = self.parse_generated_rule_147_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(2671isize); + let __child = self.parse_generated_rule_191_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_147_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 147, GeneratedRuleError::Fatal; self.parse_generated_rule_147(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_147(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 294isize, 147, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(65, 2675, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2675isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(25, 2677, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2677isize); + let __child = self.parse_generated_rule_191_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_148_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 148, GeneratedRuleError::Fatal; self.parse_generated_rule_148(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_148(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 296isize, 148, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(2679isize); + let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(24, 2681, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_149_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 149, GeneratedRuleError::Fatal; self.parse_generated_rule_149(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_149(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 298isize, 149, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 2698, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2698) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(409, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(409, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2698, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2682isize); + let __child = self.parse_generated_rule_150_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(2683isize); + let __child = self.parse_generated_rule_142_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 2685, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=6 | 12 | 14 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 46..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 2685, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 2686, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 2688, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2..=3 | 5..=6 | 12 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 46..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 2688, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2687isize); + let __child = self.parse_generated_rule_149_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(2690isize); + let __child = self.parse_generated_rule_150_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(2691isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 2696, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 2696, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 2694, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2694, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2..=3 | 5..=6 | 12 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 46..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 2694, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2693isize); + let __child = self.parse_generated_rule_149_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_150_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 150, GeneratedRuleError::Fatal; self.parse_generated_rule_150(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_150(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 300isize, 150, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __loop_iter_2703 = false; + loop { + match self.base.sync_decision(atn(), 2703, !__ctx.has_matched_child(), __loop_iter_2703) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=6 | 12 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 46 | 48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2703, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2703 = true; + let __invoking_marker = self.base.push_invoking_state(2700isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __invoking_marker = self.base.push_invoking_state(2706isize); + let __child = self.parse_generated_rule_151_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 2708, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 70 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 72 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2708, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2707isize); + let __child = self.parse_generated_rule_152_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(72, 2711, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_151_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 151, GeneratedRuleError::Fatal; self.parse_generated_rule_151(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_151(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 302isize, 151, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 2713, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2713) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(412, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(412, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2713, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(61, 2714, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __invoking_marker = self.base.push_invoking_state(2715isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_2720 = false; + loop { + match self.base.sync_decision(atn(), 2720, !__ctx.has_matched_child(), __loop_iter_2720) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2720) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(413, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(413, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2720, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2720 = true; + let __match = self.base.match_token_recovering(61, 2717, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2717isize); + let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_152_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 152, GeneratedRuleError::Fatal; self.parse_generated_rule_152(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_152(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 304isize, 152, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(70, 2724, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2724isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_153_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 153, GeneratedRuleError::Fatal; self.parse_generated_rule_153(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_153(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 306isize, 153, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(2726isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_2730 = false; + loop { + match self.base.sync_decision(atn(), 2730, !__ctx.has_matched_child(), __loop_iter_2730) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2730) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(414, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(414, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2730, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2730 = true; + let __invoking_marker = self.base.push_invoking_state(2727isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_154_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 154, GeneratedRuleError::Fatal; self.parse_generated_rule_154(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_154(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 308isize, 154, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(2733isize); + let __child = self.parse_generated_rule_67_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_2737 = false; + loop { + match self.base.sync_decision(atn(), 2737, !__ctx.has_matched_child(), __loop_iter_2737) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2737) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(415, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(415, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2737, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2737 = true; + let __invoking_marker = self.base.push_invoking_state(2734isize); + let __child = self.parse_generated_rule_67_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_155_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 155, GeneratedRuleError::Fatal; self.parse_generated_rule_155(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_155(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 310isize, 155, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 3 | 13 | 20 | 22 | 28 | 30 | 45 | 48 | 58..=59 | 61 | 67..=68 | 70..=71 | 73..=77 | 79..=80 | 99..=100 | 103 | 105..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2751, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2751) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(418, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(418, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2751, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2740isize); + let __child = self.parse_generated_rule_156_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(2741isize); + let __child = self.parse_generated_rule_74_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(13, 2744, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2744, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2744) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(416, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(416, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2744, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2743isize); + let __child = self.parse_generated_rule_154_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 2747, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2 | 21 | 27 | 40..=41 | 46..=47 | 55 | 69 | 98 | 102 | 104 | 110 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2747, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2746isize); + let __child = self.parse_generated_rule_163_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(14, 2750, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_156_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 156, GeneratedRuleError::Fatal; self.parse_generated_rule_156(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_156(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 312isize, 156, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 58..=59 | 105..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 6 | 12 | 21 | 27 | 40..=41 | 50 | 52..=53 | 55 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 22 | 61 | 73 | 79..=80 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 | 20 | 28 | 45 | 67..=68 | 70..=71 | 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 11, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 74 => antlr4_runtime::ParserAtnPrediction { alt: 12, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 75 => antlr4_runtime::ParserAtnPrediction { alt: 13, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 76 => antlr4_runtime::ParserAtnPrediction { alt: 14, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 77 => antlr4_runtime::ParserAtnPrediction { alt: 15, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2844, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2844) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(438, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(438, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2844, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2753isize); + let __child = self.parse_generated_rule_157_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __match = self.base.match_token_recovering(5, 2845, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 3 => { + let __invoking_marker = self.base.push_invoking_state(2755isize); + let __child = self.parse_generated_rule_74_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 2757, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2757) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(419, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(419, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2757, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2756isize); + let __child = self.parse_generated_rule_73_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + 4 => { + let __match = self.base.match_token_recovering(3, 2761, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2761, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2761, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2760isize); + let __child = self.parse_generated_rule_154_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(4, 2845, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 5 => { + let __match = self.base.match_token_recovering(3, 2766, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2766, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2766) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(421, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(421, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2766, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2765isize); + let __child = self.parse_generated_rule_154_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __invoking_marker = self.base.push_invoking_state(2768isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(4, 2770, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 6 => { + let __match = self.base.match_token_recovering(3, 2773, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2773, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2773) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(422, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(422, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2773, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2772isize); + let __child = self.parse_generated_rule_154_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __invoking_marker = self.base.push_invoking_state(2775isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(16, 2778, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2778, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2..=3 | 5..=7 | 12..=13 | 15 | 18 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2778, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2777isize); + let __child = self.parse_generated_rule_138_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(4, 2781, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 7 => { + let __match = self.base.match_token_recovering(48, 2784, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2784, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2784) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(424, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(424, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2784, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2783isize); + let __child = self.parse_generated_rule_154_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 2787, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2..=3 | 5..=7 | 12..=13 | 15 | 18 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2787, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2786isize); + let __child = self.parse_generated_rule_138_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(49, 2845, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 8 => { + let __match = self.base.match_token_recovering(48, 2792, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2792, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2792) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(426, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(426, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2792, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2791isize); + let __child = self.parse_generated_rule_154_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __invoking_marker = self.base.push_invoking_state(2794isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(10, 2796, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2796isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(49, 2798, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 9 => { + match self.base.sync_decision(atn(), 2800, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 22 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 61 | 73 | 79..=80 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2800, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(22, 2801, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 2803, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 61 | 79..=80 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2803, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(73, 2804, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __invoking_marker = self.base.push_invoking_state(2805isize); + let __child = self.parse_generated_rule_158_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(2806isize); + let __child = self.parse_generated_rule_161_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 10 => { + let __match = self.base.match_token_recovering(30, 2810, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2810, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 | 20 | 28 | 30 | 45 | 61 | 67..=71 | 79..=80 | 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2810, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(73, 2811, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 13 | 20 | 28 | 30 | 45 | 67..=71 | 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 61 | 79..=80 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2816, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 13 | 20 | 28 | 30 | 45 | 67..=71 | 99..=100 | 103 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 61 | 79..=80 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2816, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2812isize); + let __child = self.parse_generated_rule_142_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(2813isize); + let __child = self.parse_generated_rule_158_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(2814isize); + let __child = self.parse_generated_rule_161_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + 11 => { + let __invoking_marker = self.base.push_invoking_state(2818isize); + let __child = self.parse_generated_rule_142_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 12 => { + let __match = self.base.match_token_recovering(74, 2821, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2821, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2821) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(431, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(431, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2821, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2820isize); + let __child = self.parse_generated_rule_162_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 2824, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2824) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(432, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(432, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2824, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2823isize); + let __child = self.parse_generated_rule_157_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 2827, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2827) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(433, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(433, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2827, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2826isize); + let __child = self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + match self.base.sync_decision(atn(), 2830, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2830) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(434, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(434, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2830, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2829isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + 13 => { + let __match = self.base.match_token_recovering(75, 2834, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2834, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2834) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(435, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(435, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2834, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2833isize); + let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + 14 => { + let __match = self.base.match_token_recovering(76, 2838, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2838, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2838) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(436, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(436, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2838, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2837isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + 15 => { + let __match = self.base.match_token_recovering(77, 2842, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2842, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2842) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(437, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(437, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2842, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2841isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_157_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 157, GeneratedRuleError::Fatal; self.parse_generated_rule_157(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_157(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 314isize, 157, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 58 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 59 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 111 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 108 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 109 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 112 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 105 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 106 => antlr4_runtime::ParserAtnPrediction { alt: 10, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 107 => antlr4_runtime::ParserAtnPrediction { alt: 11, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2858, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2858) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(439, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(439, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2858, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(58, 2859, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + let __match = self.base.match_token_recovering(59, 2859, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 3 => { + let __match = self.base.match_token_recovering(110, 2849, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(78, 2859, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 4 => { + let __match = self.base.match_token_recovering(110, 2859, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 5 => { + let __match = self.base.match_token_recovering(111, 2859, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 6 => { + let __match = self.base.match_token_recovering(108, 2859, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 7 => { + let __match = self.base.match_token_recovering(109, 2859, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 8 => { + let __match = self.base.match_token_recovering(112, 2859, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 9 => { + let __match = self.base.match_token_recovering(105, 2859, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 10 => { + let __match = self.base.match_token_recovering(106, 2859, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 11 => { + let __match = self.base.match_token_recovering(107, 2859, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_158_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 158, GeneratedRuleError::Fatal; self.parse_generated_rule_158(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_158(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 316isize, 158, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 79 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 80 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2869, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2869) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(441, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(441, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2869, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(61, 2861, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(61, 2870, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + let __match = self.base.match_token_recovering(79, 2870, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 3 => { + let __match = self.base.match_token_recovering(80, 2870, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 4 => { + let __match = self.base.match_token_recovering(61, 2866, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2866, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2..=3 | 5..=6 | 12 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 46..=48 | 50 | 52..=53 | 55 | 58..=60 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 61 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2866, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2865isize); + let __child = self.parse_generated_rule_160_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(61, 2870, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_159_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 159, GeneratedRuleError::Fatal; self.parse_generated_rule_159(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_159(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 318isize, 159, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __loop_iter_2874 = false; + loop { + match self.base.sync_decision(atn(), 2874, !__ctx.has_matched_child(), __loop_iter_2874) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=6 | 12 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 46 | 48 | 50 | 52..=53 | 55 | 58..=60 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 2838, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2874, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(2837isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_2874 = true; + let __invoking_marker = self.base.push_invoking_state(2871isize); + let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - 15 => { - let __match = self.base.match_token_recovering(77, 2842, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2842, !__ctx.has_matched_child(), false) { + let __invoking_marker = self.base.push_invoking_state(2877isize); + let __child = self.parse_generated_rule_125_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 2880, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 16 | 61 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 2880, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(24, 2879, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2879isize); + let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_160_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 160, GeneratedRuleError::Fatal; self.parse_generated_rule_160(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_160(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 320isize, 160, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(2882isize); + let __child = self.parse_generated_rule_159_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_2887 = false; + loop { + match self.base.sync_decision(atn(), 2887, !__ctx.has_matched_child(), __loop_iter_2887) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -43452,12 +38710,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2842) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2887) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(437, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(444, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -43467,7 +38725,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(437, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(444, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -43476,949 +38734,847 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 2842, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2887, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(2841isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + __loop_iter_2887 = true; + let __match = self.base.match_token_recovering(16, 2884, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2884isize); + let __child = self.parse_generated_rule_159_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { + break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + match self.base.sync_decision(atn(), 2891, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 61 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 2891, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 2892, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_157_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_161_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(157) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_157(precedence, allow_fallback)) - } else { - self.parse_generated_rule_157(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(157); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 161, GeneratedRuleError::Fatal; self.parse_generated_rule_161(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_157(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_161(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(314isize, 157); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 58 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 59 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 111 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 108 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 109 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 112 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 105 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 106 => antlr4_runtime::ParserAtnPrediction { alt: 10, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 107 => antlr4_runtime::ParserAtnPrediction { alt: 11, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2858, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 322isize, 161, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 37 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=7 | 12 | 15 | 18 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2898, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2898) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(447, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(447, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2858) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(439, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? + }; + self.base.record_generated_prediction_diagnostic(atn(), 2898, &__prediction); + match __prediction.alt { + 1 => { + match self.base.sync_decision(atn(), 2894, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 37 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(439, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + self.base.record_generated_prediction_diagnostic(atn(), 2894, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2893isize); + let __child = self.parse_generated_rule_39_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __invoking_marker = self.base.push_invoking_state(2896isize); + let __child = self.parse_generated_rule_139_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + 2 => { + let __invoking_marker = self.base.push_invoking_state(2897isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2858, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(58, 2859, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __match = self.base.match_token_recovering(59, 2859, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __match = self.base.match_token_recovering(110, 2849, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(78, 2859, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 4 => { - let __match = self.base.match_token_recovering(110, 2859, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 5 => { - let __match = self.base.match_token_recovering(111, 2859, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 6 => { - let __match = self.base.match_token_recovering(108, 2859, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 7 => { - let __match = self.base.match_token_recovering(109, 2859, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 8 => { - let __match = self.base.match_token_recovering(112, 2859, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 9 => { - let __match = self.base.match_token_recovering(105, 2859, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 10 => { - let __match = self.base.match_token_recovering(106, 2859, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 11 => { - let __match = self.base.match_token_recovering(107, 2859, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_158_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_162_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(158) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_158(precedence, allow_fallback)) - } else { - self.parse_generated_rule_158(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(158); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 162, GeneratedRuleError::Fatal; self.parse_generated_rule_162(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_158(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_162(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(316isize, 158); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 79 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 80 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2869, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 324isize, 162, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2..=3 | 5..=6 | 12..=13 | 15 | 18 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 67..=71 | 73..=77 | 79..=80 | 98 | 102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2902, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2869) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(441, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(441, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2902) { __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(448, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(448, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2902, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2900isize); + let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(2901isize); + let __child = self.parse_generated_rule_137_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2869, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(61, 2861, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(61, 2870, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __match = self.base.match_token_recovering(79, 2870, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __match = self.base.match_token_recovering(80, 2870, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 4 => { - let __match = self.base.match_token_recovering(61, 2866, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2866, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_163_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 163, GeneratedRuleError::Fatal; self.parse_generated_rule_163(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_163(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 326isize, 163, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 46 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 27 | 40..=41 | 47 | 55 | 69 | 98 | 102 | 104 | 110 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2920, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 46 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 27 | 40..=41 | 47 | 55 | 69 | 98 | 102 | 104 | 110 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2..=3 | 5..=6 | 12 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 46..=48 | 50 | 52..=53 | 55 | 58..=60 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 61 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2866, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2865isize); - let __child = self.parse_generated_rule_160_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + }; + self.base.record_generated_prediction_diagnostic(atn(), 2920, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2904isize); + let __child = self.parse_generated_rule_164_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(2905isize); + let __child = self.parse_generated_rule_165_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_2910 = false; + loop { + match self.base.sync_decision(atn(), 2910, !__ctx.has_matched_child(), __loop_iter_2910) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2910) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(449, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(449, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2910, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2910 = true; + let __match = self.base.match_token_recovering(16, 2907, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2907isize); + let __child = self.parse_generated_rule_165_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - 2 => { + match self.base.sync_decision(atn(), 2918, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2918) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(451, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(451, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2918, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 2914, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2914isize); + let __child = self.parse_generated_rule_164_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + match self.base.sync_decision(atn(), 2916, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 2916, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(16, 2917, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __match = self.base.match_token_recovering(61, 2870, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_159_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_164_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(159) { - return Err(GeneratedRuleError::Fatal(error)); + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 164, GeneratedRuleError::Fatal; self.parse_generated_rule_164(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_164(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 328isize, 164, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(46, 2923, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2923isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + success {} + recovery {} } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_159(precedence, allow_fallback)) - } else { - self.parse_generated_rule_159(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(159); - __listener_result } #[allow(dead_code)] - fn parse_generated_rule_159(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_165_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 165, GeneratedRuleError::Fatal; self.parse_generated_rule_165(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_165(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(318isize, 159); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __loop_iter_2874 = false; - loop { - match self.base.sync_decision(atn(), 2874, !__ctx.has_matched_child(), __loop_iter_2874) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 330isize, 165, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=6 | 12 | 18 | 21 | 23 | 27 | 33 | 35..=36 | 40..=41 | 46 | 48 | 50 | 52..=53 | 55 | 58..=60 | 63..=64 | 69 | 98 | 101..=102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 110 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2942, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2942) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(455, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(455, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } + } }; - self.base.record_generated_prediction_diagnostic(atn(), 2874, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2942, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2874 = true; - let __invoking_marker = self.base.push_invoking_state(2871isize); - let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let mut __loop_iter_2928 = false; + loop { + match self.base.sync_decision(atn(), 2928, !__ctx.has_matched_child(), __loop_iter_2928) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2928, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2928 = true; + let __invoking_marker = self.base.push_invoking_state(2925isize); + let __child = self.parse_generated_rule_153_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __invoking_marker = self.base.push_invoking_state(2931isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; + let mut __loop_iter_2935 = false; + loop { + match self.base.sync_decision(atn(), 2935, !__ctx.has_matched_child(), __loop_iter_2935) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 | 110 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2935, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_2935 = true; + let __invoking_marker = self.base.push_invoking_state(2932isize); + let __child = self.parse_generated_rule_153_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __invoking_marker = self.base.push_invoking_state(2938isize); + let __child = self.parse_generated_rule_166_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(24, 2940, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2940isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __invoking_marker = self.base.push_invoking_state(2877isize); - let __child = self.parse_generated_rule_125_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 2880, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 16 | 61 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 2880, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(24, 2879, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2879isize); - let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_160_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_166_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(160) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_160(precedence, allow_fallback)) - } else { - self.parse_generated_rule_160(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(160); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 166, GeneratedRuleError::Fatal; self.parse_generated_rule_166(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_160(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_166(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(320isize, 160); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(2882isize); - let __child = self.parse_generated_rule_159_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_2887 = false; - loop { - match self.base.sync_decision(atn(), 2887, !__ctx.has_matched_child(), __loop_iter_2887) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2887) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(444, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(444, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 332isize, 166, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 110 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2946, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 110 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } }; - self.base.record_generated_prediction_diagnostic(atn(), 2887, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2946, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2887 = true; - let __match = self.base.match_token_recovering(16, 2884, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2884isize); - let __child = self.parse_generated_rule_159_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(2944isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; + let __match = self.base.match_token_recovering(110, 2947, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - match self.base.sync_decision(atn(), 2891, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 61 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 2891, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 2892, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_161_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(161) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_161(precedence, allow_fallback)) - } else { - self.parse_generated_rule_161(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(161); - __listener_result + fn parse_generated_rule_167_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 167, GeneratedRuleError::Fatal; self.parse_generated_rule_167_precedence(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_161(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(322isize, 161); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 37 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=7 | 12 | 15 | 18 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2898, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2898) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(447, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + fn parse_generated_rule_167(&mut self, allow_fallback: bool) -> Result { + self.parse_generated_rule_167_precedence(0, allow_fallback) + } + + #[allow(dead_code)] + fn parse_generated_rule_167_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 334isize, 167, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let action = self.base.parser_action_at_current_indexed(2948, 167, 4, __rule_start, __consumed_eof); + let _ = action; + let __invoking_marker = self.base.push_invoking_state(2949isize); + let __child = self.parse_generated_rule_155_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + loop { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 2955, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(447, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2898, &__prediction); - match __prediction.alt { - 1 => { - match self.base.sync_decision(atn(), 2894, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + match __simulator.adaptive_predict_stream_info_with_context(457, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + }; + let __prediction = if __prediction.alt == 1 { + let __semantic_la = self.base.la(1); + if true { + __prediction + } else { + antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 37 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } else { + __prediction }; - self.base.record_generated_prediction_diagnostic(atn(), 2894, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2955, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(2893isize); - let __child = self.parse_generated_rule_39_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.parse_listener_exit_rule(167); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); + } + self.base.push_new_recursion_context_with_previous(334isize, 167, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(167) { + return Err(__listener_error); + } + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __invoking_marker = self.base.push_invoking_state(2952isize); + let __child = self.parse_generated_rule_168_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } - 2 => { - } + 2 => break, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __invoking_marker = self.base.push_invoking_state(2896isize); - let __child = self.parse_generated_rule_139_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); } - 2 => { - let __invoking_marker = self.base.push_invoking_state(2897isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_162_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_168_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(162) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_162(precedence, allow_fallback)) - } else { - self.parse_generated_rule_162(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(162); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 168, GeneratedRuleError::Fatal; self.parse_generated_rule_168(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_162(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_168(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(324isize, 162); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2..=3 | 5..=6 | 12..=13 | 15 | 18 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 67..=71 | 73..=77 | 79..=80 | 98 | 102 | 104..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2902, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 336isize, 168, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 43 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 116 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 3 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 2984, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2902) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(448, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(448, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2984) { __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(462, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(462, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2902, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2900isize); - let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(2901isize); - let __child = self.parse_generated_rule_137_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_163_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(163) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_163(precedence, allow_fallback)) - } else { - self.parse_generated_rule_163(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(163); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_163(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(326isize, 163); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 46 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 27 | 40..=41 | 47 | 55 | 69 | 98 | 102 | 104 | 110 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2920, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + }; + self.base.record_generated_prediction_diagnostic(atn(), 2984, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(43, 2985, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 46 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 27 | 40..=41 | 47 | 55 | 69 | 98 | 102 | 104 | 110 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 2 => { + let __match = self.base.match_token_recovering(48, 2960, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2960isize); + let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(49, 2962, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2920, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2904isize); - let __child = self.parse_generated_rule_164_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(2905isize); - let __child = self.parse_generated_rule_165_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_2910 = false; - loop { - match self.base.sync_decision(atn(), 2910, !__ctx.has_matched_child(), __loop_iter_2910) { + 3 => { + let __match = self.base.match_token_recovering(78, 2964, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2964isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 2974, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -44428,12 +39584,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2910) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2974) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(449, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(460, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -44443,7 +39599,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(449, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(460, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -44452,266 +39608,263 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 2910, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 2974, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2910 = true; - let __match = self.base.match_token_recovering(16, 2907, atn())?; + match self.base.sync_decision(atn(), 2967, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 3 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2967, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(12, 2966, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2966isize); + let __child = self.parse_generated_rule_115_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(3, 2971, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2971, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2..=3 | 5..=7 | 12..=13 | 15 | 18 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2971, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2970isize); + let __child = self.parse_generated_rule_138_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(4, 2975, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2907isize); - let __child = self.parse_generated_rule_165_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - match self.base.sync_decision(atn(), 2918, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + 4 => { + let __match = self.base.match_token_recovering(78, 2977, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(110, 2985, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2918) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(451, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(451, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2918, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 2914, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2914isize); - let __child = self.parse_generated_rule_164_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 5 => { + let __match = self.base.match_token_recovering(116, 2985, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 6 => { + let __match = self.base.match_token_recovering(3, 2981, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 2981, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { - match self.base.sync_decision(atn(), 2916, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2..=3 | 5..=7 | 12..=13 | 15 | 18 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 2981, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2980isize); + let __child = self.parse_generated_rule_138_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 16 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 2916, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(16, 2917, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 2 => { } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __match = self.base.match_token_recovering(4, 2985, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_164_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(164) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_164(precedence, allow_fallback)) - } else { - self.parse_generated_rule_164(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(164); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_164(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(328isize, 164); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(46, 2923, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2923isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_165_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_169_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(165) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_165(precedence, allow_fallback)) - } else { - self.parse_generated_rule_165(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(165); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 169, GeneratedRuleError::Fatal; self.parse_generated_rule_169(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_165(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_169(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(330isize, 165); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 110 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2942, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 338isize, 169, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2..=3 | 5..=6 | 12..=13 | 20..=22 | 27..=28 | 30 | 40..=41 | 45 | 48 | 50 | 52..=53 | 55 | 58..=59 | 61 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 47 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 60 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 44 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 36 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 15 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 64 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 7 => antlr4_runtime::ParserAtnPrediction { alt: 10, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 3017, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2942) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(455, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(455, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3017) { __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(465, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(465, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2942, &__prediction); - match __prediction.alt { - 1 => { - let mut __loop_iter_2928 = false; - loop { - match self.base.sync_decision(atn(), 2928, !__ctx.has_matched_child(), __loop_iter_2928) { + }; + self.base.record_generated_prediction_diagnostic(atn(), 3017, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(2986isize); + let __child = self.parse_generated_rule_167_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(2987isize); + let __child = self.parse_generated_rule_153_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(2988isize); + let __child = self.parse_generated_rule_169_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 3 => { + let __match = self.base.match_token_recovering(60, 2991, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2991isize); + let __child = self.parse_generated_rule_169_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 4 => { + let __match = self.base.match_token_recovering(44, 2993, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2993isize); + let __child = self.parse_generated_rule_169_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 5 => { + let __match = self.base.match_token_recovering(33, 2995, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(55, 2996, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(2996isize); + let __child = self.parse_generated_rule_113_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(2997isize); + let __child = self.parse_generated_rule_169_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 6 => { + let __match = self.base.match_token_recovering(33, 3001, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 3001, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -44722,36 +39875,32 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=7 | 12..=13 | 15 | 20..=22 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=45 | 47..=48 | 50 | 52..=53 | 55 | 58..=61 | 64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 2928, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 3001, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2928 = true; - let __invoking_marker = self.base.push_invoking_state(2925isize); - let __child = self.parse_generated_rule_153_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(23, 3002, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __invoking_marker = self.base.push_invoking_state(3003isize); + let __child = self.parse_generated_rule_169_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2931isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let mut __loop_iter_2935 = false; - loop { - match self.base.sync_decision(atn(), 2935, !__ctx.has_matched_child(), __loop_iter_2935) { + 7 => { + let __match = self.base.match_token_recovering(36, 3006, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 3006, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -44762,992 +39911,188 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 | 110 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=7 | 12..=13 | 15 | 20..=22 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=45 | 47..=48 | 50 | 52..=53 | 55 | 58..=61 | 64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 2935, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 3006, &__prediction); match __prediction.alt { 1 => { - __loop_iter_2935 = true; - let __invoking_marker = self.base.push_invoking_state(2932isize); - let __child = self.parse_generated_rule_153_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(23, 3007, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __invoking_marker = self.base.push_invoking_state(3008isize); + let __child = self.parse_generated_rule_169_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2938isize); - let __child = self.parse_generated_rule_166_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(24, 2940, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2940isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_166_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(166) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_166(precedence, allow_fallback)) - } else { - self.parse_generated_rule_166(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(166); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_166(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(332isize, 166); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 110 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2946, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 2 | 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 110 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2946, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2944isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(110, 2947, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_167_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(167) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_167_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_167_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(167); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_167(&mut self, allow_fallback: bool) -> Result { - self.parse_generated_rule_167_precedence(0, allow_fallback) - } - - #[allow(dead_code)] - fn parse_generated_rule_167_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(334isize, 167, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let action = self.base.parser_action_at_current_indexed(2948, 167, 4, __rule_start, __consumed_eof); - let _ = action; - let __invoking_marker = self.base.push_invoking_state(2949isize); - let __child = self.parse_generated_rule_155_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 2955, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(457, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), - } + 8 => { + let __match = self.base.match_token_recovering(15, 3010, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3010isize); + let __child = self.parse_generated_rule_169_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - }; - let __prediction = if __prediction.alt == 1 { - let __semantic_la = self.base.la(1); - if true { - __prediction - } else { - antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } + 9 => { + let __match = self.base.match_token_recovering(64, 3012, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3012isize); + let __child = self.parse_generated_rule_169_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - } else { - __prediction - }; - self.base.record_generated_prediction_diagnostic(atn(), 2955, &__prediction); - match __prediction.alt { - 1 => { - self.base.parse_listener_exit_rule(167); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); - } - self.base.push_new_recursion_context_with_previous(334isize, 167, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(167) { - return Err(__listener_error); - } - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); - } - let __invoking_marker = self.base.push_invoking_state(2952isize); - let __child = self.parse_generated_rule_168_dispatch(0, false).map_err(GeneratedRuleError::into_error); + 10 => { + let __match = self.base.match_token_recovering(7, 3014, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3014isize); + let __child = self.parse_generated_rule_137_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(3015isize); + let __child = self.parse_generated_rule_139_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } - 2 => break, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_168_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(168) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_168(precedence, allow_fallback)) - } else { - self.parse_generated_rule_168(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(168); - __listener_result + fn parse_generated_rule_170_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 170, GeneratedRuleError::Fatal; self.parse_generated_rule_170_precedence(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_168(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(336isize, 168); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 43 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 116 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 3 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 2984, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2984) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(462, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(462, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 2984, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(43, 2985, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __match = self.base.match_token_recovering(48, 2960, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2960isize); - let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(49, 2962, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __match = self.base.match_token_recovering(78, 2964, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2964isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - match self.base.sync_decision(atn(), 2974, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } + fn parse_generated_rule_170(&mut self, allow_fallback: bool) -> Result { + self.parse_generated_rule_170_precedence(0, allow_fallback) + } + + #[allow(dead_code)] + fn parse_generated_rule_170_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 340isize, 170, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let action = self.base.parser_action_at_current_indexed(3019, 170, 5, __rule_start, __consumed_eof); + let _ = action; + let __invoking_marker = self.base.push_invoking_state(3020isize); + let __child = self.parse_generated_rule_169_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + loop { let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2974) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(460, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3030, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(460, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction + match __simulator.adaptive_predict_stream_info_with_context(467, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } }; - self.base.record_generated_prediction_diagnostic(atn(), 2974, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 3030, &__prediction); match __prediction.alt { 1 => { - match self.base.sync_decision(atn(), 2967, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + self.base.parse_listener_exit_rule(170); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); + } + self.base.push_new_recursion_context_with_previous(340isize, 170, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(170) { + return Err(__listener_error); } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 3 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(466, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? }; - self.base.record_generated_prediction_diagnostic(atn(), 2967, &__prediction); + if self.base.report_diagnostic_errors() { + let __diagnostic_la = self.base.la(1); + let mut __diagnostic_alts = Vec::new(); + if __diagnostic_la == 17 { + __diagnostic_alts.push(1); + } + if __diagnostic_la == 24 { + __diagnostic_alts.push(2); + } + self.base.record_generated_ambiguity_diagnostic(atn(), 3028, __decision_start, __decision_start, &__diagnostic_alts); + } match __prediction.alt { 1 => { - let __match = self.base.match_token_recovering(12, 2966, atn())?; + if !self.base.precpred(2) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 2)")); + } + let __match = self.base.match_token_recovering(17, 3024, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2966isize); - let __child = self.parse_generated_rule_115_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(3024isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(3, 2971, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2971, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2..=3 | 5..=7 | 12..=13 | 15 | 18 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2971, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2970isize); - let __child = self.parse_generated_rule_138_dispatch(0, false).map_err(GeneratedRuleError::into_error); + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __match = self.base.match_token_recovering(24, 3027, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3027isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } - 2 => { - } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __match = self.base.match_token_recovering(4, 2975, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - 4 => { - let __match = self.base.match_token_recovering(78, 2977, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(110, 2985, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 5 => { - let __match = self.base.match_token_recovering(116, 2985, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 6 => { - let __match = self.base.match_token_recovering(3, 2981, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 2981, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2..=3 | 5..=7 | 12..=13 | 15 | 18 | 20..=23 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=48 | 50 | 52..=53 | 55 | 58..=61 | 63..=64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 2981, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2980isize); - let __child = self.parse_generated_rule_138_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(4, 2985, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_169_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(169) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_169(precedence, allow_fallback)) - } else { - self.parse_generated_rule_169(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(169); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_169(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(338isize, 169); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2..=3 | 5..=6 | 12..=13 | 20..=22 | 27..=28 | 30 | 40..=41 | 45 | 48 | 50 | 52..=53 | 55 | 58..=59 | 61 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 47 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 60 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 44 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 36 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 15 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 64 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 7 => antlr4_runtime::ParserAtnPrediction { alt: 10, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 3017, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3017) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(465, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(465, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3017, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(2986isize); - let __child = self.parse_generated_rule_167_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(2987isize); - let __child = self.parse_generated_rule_153_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __invoking_marker = self.base.push_invoking_state(2988isize); - let __child = self.parse_generated_rule_169_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 3 => { - let __match = self.base.match_token_recovering(60, 2991, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2991isize); - let __child = self.parse_generated_rule_169_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 4 => { - let __match = self.base.match_token_recovering(44, 2993, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2993isize); - let __child = self.parse_generated_rule_169_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 5 => { - let __match = self.base.match_token_recovering(33, 2995, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(55, 2996, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(2996isize); - let __child = self.parse_generated_rule_113_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __invoking_marker = self.base.push_invoking_state(2997isize); - let __child = self.parse_generated_rule_169_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 6 => { - let __match = self.base.match_token_recovering(33, 3001, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 3001, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=7 | 12..=13 | 15 | 20..=22 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=45 | 47..=48 | 50 | 52..=53 | 55 | 58..=61 | 64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 3001, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(23, 3002, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(3003isize); - let __child = self.parse_generated_rule_169_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 7 => { - let __match = self.base.match_token_recovering(36, 3006, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 3006, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=7 | 12..=13 | 15 | 20..=22 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=45 | 47..=48 | 50 | 52..=53 | 55 | 58..=61 | 64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 3006, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(23, 3007, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { } + 2 => break, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __invoking_marker = self.base.push_invoking_state(3008isize); - let __child = self.parse_generated_rule_169_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 8 => { - let __match = self.base.match_token_recovering(15, 3010, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3010isize); - let __child = self.parse_generated_rule_169_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 9 => { - let __match = self.base.match_token_recovering(64, 3012, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3012isize); - let __child = self.parse_generated_rule_169_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 10 => { - let __match = self.base.match_token_recovering(7, 3014, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3014isize); - let __child = self.parse_generated_rule_137_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __invoking_marker = self.base.push_invoking_state(3015isize); - let __child = self.parse_generated_rule_139_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_170_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(170) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_170_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_170_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(170); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_170(&mut self, allow_fallback: bool) -> Result { - self.parse_generated_rule_170_precedence(0, allow_fallback) - } - - #[allow(dead_code)] - fn parse_generated_rule_170_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(340isize, 170, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let action = self.base.parser_action_at_current_indexed(3019, 170, 5, __rule_start, __consumed_eof); - let _ = action; - let __invoking_marker = self.base.push_invoking_state(3020isize); - let __child = self.parse_generated_rule_169_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3030, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(467, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3030, &__prediction); - match __prediction.alt { - 1 => { - self.base.parse_listener_exit_rule(170); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); - } - self.base.push_new_recursion_context_with_previous(340isize, 170, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(170) { - return Err(__listener_error); - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(466, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if self.base.report_diagnostic_errors() { - let __diagnostic_la = self.base.la(1); - let mut __diagnostic_alts = Vec::new(); - if __diagnostic_la == 17 { - __diagnostic_alts.push(1); - } - if __diagnostic_la == 24 { - __diagnostic_alts.push(2); - } - self.base.record_generated_ambiguity_diagnostic(atn(), 3028, __decision_start, __decision_start, &__diagnostic_alts); - } - match __prediction.alt { - 1 => { - if !self.base.precpred(2) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 2)")); - } - let __match = self.base.match_token_recovering(17, 3024, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3024isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); - } - let __match = self.base.match_token_recovering(24, 3027, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3027isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - 2 => break, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) + } } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_171_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(171) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_171_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_171_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(171); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 171, GeneratedRuleError::Fatal; self.parse_generated_rule_171_precedence(precedence, allow_fallback) } } #[allow(dead_code)] @@ -45757,161 +40102,128 @@ where #[allow(dead_code)] fn parse_generated_rule_171_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(342isize, 171, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let action = self.base.parser_action_at_current_indexed(3033, 171, 6, __rule_start, __consumed_eof); - let _ = action; - let __invoking_marker = self.base.push_invoking_state(3034isize); - let __child = self.parse_generated_rule_170_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3047, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(469, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3047, &__prediction); - match __prediction.alt { - 1 => { - self.base.parse_listener_exit_rule(171); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); - } - self.base.push_new_recursion_context_with_previous(342isize, 171, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(171) { - return Err(__listener_error); - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = { + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 342isize, 171, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let action = self.base.parser_action_at_current_indexed(3033, 171, 6, __rule_start, __consumed_eof); + let _ = action; + let __invoking_marker = self.base.push_invoking_state(3034isize); + let __child = self.parse_generated_rule_170_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + loop { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3047, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(468, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if self.base.report_diagnostic_errors() { - let __diagnostic_la = self.base.la(1); - let mut __diagnostic_alts = Vec::new(); - if __diagnostic_la == 15 { - __diagnostic_alts.push(1); + match __simulator.adaptive_predict_stream_info_with_context(469, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), } - if __diagnostic_la == 81 { - __diagnostic_alts.push(2); + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3047, &__prediction); + match __prediction.alt { + 1 => { + self.base.parse_listener_exit_rule(171); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); } - if __diagnostic_la == 82 { - __diagnostic_alts.push(3); + self.base.push_new_recursion_context_with_previous(342isize, 171, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(171) { + return Err(__listener_error); } - self.base.record_generated_ambiguity_diagnostic(atn(), 3045, __decision_start, __decision_start, &__diagnostic_alts); - } - match __prediction.alt { - 1 => { - if !self.base.precpred(3) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 3)")); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(468, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if self.base.report_diagnostic_errors() { + let __diagnostic_la = self.base.la(1); + let mut __diagnostic_alts = Vec::new(); + if __diagnostic_la == 15 { + __diagnostic_alts.push(1); } - let __match = self.base.match_token_recovering(15, 3038, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3038isize); - let __child = self.parse_generated_rule_170_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - if !self.base.precpred(2) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 2)")); + if __diagnostic_la == 81 { + __diagnostic_alts.push(2); } - let __match = self.base.match_token_recovering(81, 3041, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3041isize); - let __child = self.parse_generated_rule_170_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + if __diagnostic_la == 82 { + __diagnostic_alts.push(3); + } + self.base.record_generated_ambiguity_diagnostic(atn(), 3045, __decision_start, __decision_start, &__diagnostic_alts); } - 3 => { - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + match __prediction.alt { + 1 => { + if !self.base.precpred(3) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 3)")); + } + let __match = self.base.match_token_recovering(15, 3038, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3038isize); + let __child = self.parse_generated_rule_170_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(82, 3044, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3044isize); - let __child = self.parse_generated_rule_170_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 2 => { + if !self.base.precpred(2) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 2)")); + } + let __match = self.base.match_token_recovering(81, 3041, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3041isize); + let __child = self.parse_generated_rule_170_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 3 => { + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __match = self.base.match_token_recovering(82, 3044, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3044isize); + let __child = self.parse_generated_rule_170_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + 2 => break, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => break, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_172_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(172) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_172_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_172_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(172); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 172, GeneratedRuleError::Fatal; self.parse_generated_rule_172_precedence(precedence, allow_fallback) } } #[allow(dead_code)] @@ -45921,145 +40233,112 @@ where #[allow(dead_code)] fn parse_generated_rule_172_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(344isize, 172, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let action = self.base.parser_action_at_current_indexed(3050, 172, 7, __rule_start, __consumed_eof); - let _ = action; - let __invoking_marker = self.base.push_invoking_state(3051isize); - let __child = self.parse_generated_rule_171_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3061, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(471, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3061, &__prediction); - match __prediction.alt { - 1 => { - self.base.parse_listener_exit_rule(172); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); - } - self.base.push_new_recursion_context_with_previous(344isize, 172, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(172) { - return Err(__listener_error); - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = { + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 344isize, 172, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let action = self.base.parser_action_at_current_indexed(3050, 172, 7, __rule_start, __consumed_eof); + let _ = action; + let __invoking_marker = self.base.push_invoking_state(3051isize); + let __child = self.parse_generated_rule_171_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + loop { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3061, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(470, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if self.base.report_diagnostic_errors() { - let __diagnostic_la = self.base.la(1); - let mut __diagnostic_alts = Vec::new(); - if __diagnostic_la == 54 { - __diagnostic_alts.push(1); - } - if __diagnostic_la == 60 { - __diagnostic_alts.push(2); + match __simulator.adaptive_predict_stream_info_with_context(471, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), } - self.base.record_generated_ambiguity_diagnostic(atn(), 3059, __decision_start, __decision_start, &__diagnostic_alts); } - match __prediction.alt { - 1 => { - if !self.base.precpred(2) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 2)")); + }; + self.base.record_generated_prediction_diagnostic(atn(), 3061, &__prediction); + match __prediction.alt { + 1 => { + self.base.parse_listener_exit_rule(172); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); + } + self.base.push_new_recursion_context_with_previous(344isize, 172, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(172) { + return Err(__listener_error); + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(470, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if self.base.report_diagnostic_errors() { + let __diagnostic_la = self.base.la(1); + let mut __diagnostic_alts = Vec::new(); + if __diagnostic_la == 54 { + __diagnostic_alts.push(1); } - let __match = self.base.match_token_recovering(54, 3055, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3055isize); - let __child = self.parse_generated_rule_171_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + if __diagnostic_la == 60 { + __diagnostic_alts.push(2); + } + self.base.record_generated_ambiguity_diagnostic(atn(), 3059, __decision_start, __decision_start, &__diagnostic_alts); } - 2 => { - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + match __prediction.alt { + 1 => { + if !self.base.precpred(2) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 2)")); + } + let __match = self.base.match_token_recovering(54, 3055, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3055isize); + let __child = self.parse_generated_rule_171_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(60, 3058, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3058isize); - let __child = self.parse_generated_rule_171_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 2 => { + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __match = self.base.match_token_recovering(60, 3058, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3058isize); + let __child = self.parse_generated_rule_171_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + 2 => break, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => break, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_173_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(173) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_173_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_173_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(173); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 173, GeneratedRuleError::Fatal; self.parse_generated_rule_173_precedence(precedence, allow_fallback) } } #[allow(dead_code)] @@ -46069,151 +40348,118 @@ where #[allow(dead_code)] fn parse_generated_rule_173_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(346isize, 173, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let action = self.base.parser_action_at_current_indexed(3064, 173, 8, __rule_start, __consumed_eof); - let _ = action; - let __invoking_marker = self.base.push_invoking_state(3065isize); - let __child = self.parse_generated_rule_172_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3077, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(473, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3077, &__prediction); - match __prediction.alt { - 1 => { - self.base.parse_listener_exit_rule(173); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); - } - self.base.push_new_recursion_context_with_previous(346isize, 173, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(173) { - return Err(__listener_error); - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = { + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 346isize, 173, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let action = self.base.parser_action_at_current_indexed(3064, 173, 8, __rule_start, __consumed_eof); + let _ = action; + let __invoking_marker = self.base.push_invoking_state(3065isize); + let __child = self.parse_generated_rule_172_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + loop { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3077, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(472, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if self.base.report_diagnostic_errors() { - let __diagnostic_la = self.base.la(1); - let mut __diagnostic_alts = Vec::new(); - if __diagnostic_la == 50 { - __diagnostic_alts.push(1); + match __simulator.adaptive_predict_stream_info_with_context(473, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), } - if __diagnostic_la == 51 { - __diagnostic_alts.push(2); - } - self.base.record_generated_ambiguity_diagnostic(atn(), 3075, __decision_start, __decision_start, &__diagnostic_alts); } - match __prediction.alt { - 1 => { - if !self.base.precpred(2) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 2)")); + }; + self.base.record_generated_prediction_diagnostic(atn(), 3077, &__prediction); + match __prediction.alt { + 1 => { + self.base.parse_listener_exit_rule(173); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); + } + self.base.push_new_recursion_context_with_previous(346isize, 173, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(173) { + return Err(__listener_error); + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(472, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if self.base.report_diagnostic_errors() { + let __diagnostic_la = self.base.la(1); + let mut __diagnostic_alts = Vec::new(); + if __diagnostic_la == 50 { + __diagnostic_alts.push(1); } - let __match = self.base.match_token_recovering(50, 3069, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(50, 3070, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3070isize); - let __child = self.parse_generated_rule_172_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + if __diagnostic_la == 51 { + __diagnostic_alts.push(2); + } + self.base.record_generated_ambiguity_diagnostic(atn(), 3075, __decision_start, __decision_start, &__diagnostic_alts); } - 2 => { - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + match __prediction.alt { + 1 => { + if !self.base.precpred(2) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 2)")); + } + let __match = self.base.match_token_recovering(50, 3069, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(50, 3070, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3070isize); + let __child = self.parse_generated_rule_172_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(51, 3073, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(51, 3074, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3074isize); - let __child = self.parse_generated_rule_172_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 2 => { + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __match = self.base.match_token_recovering(51, 3073, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(51, 3074, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3074isize); + let __child = self.parse_generated_rule_172_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + 2 => break, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => break, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_174_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(174) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_174_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_174_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(174); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 174, GeneratedRuleError::Fatal; self.parse_generated_rule_174_precedence(precedence, allow_fallback) } } #[allow(dead_code)] @@ -46223,115 +40469,82 @@ where #[allow(dead_code)] fn parse_generated_rule_174_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(348isize, 174, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let action = self.base.parser_action_at_current_indexed(3080, 174, 9, __rule_start, __consumed_eof); - let _ = action; - let __invoking_marker = self.base.push_invoking_state(3081isize); - let __child = self.parse_generated_rule_173_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3088, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(474, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - let __prediction = if __prediction.alt == 1 { - let __semantic_la = self.base.la(1); - if __semantic_la == 33 { - __prediction - } else { - antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } - } - } else { - __prediction - }; - self.base.record_generated_prediction_diagnostic(atn(), 3088, &__prediction); - match __prediction.alt { - 1 => { - self.base.parse_listener_exit_rule(174); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 348isize, 174, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let action = self.base.parser_action_at_current_indexed(3080, 174, 9, __rule_start, __consumed_eof); + let _ = action; + let __invoking_marker = self.base.push_invoking_state(3081isize); + let __child = self.parse_generated_rule_173_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + loop { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3088, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + match __simulator.adaptive_predict_stream_info_with_context(474, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - self.base.push_new_recursion_context_with_previous(348isize, 174, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(174) { - return Err(__listener_error); + }; + let __prediction = if __prediction.alt == 1 { + let __semantic_la = self.base.la(1); + if __semantic_la == 33 { + __prediction + } else { + antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } } - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } else { + __prediction + }; + self.base.record_generated_prediction_diagnostic(atn(), 3088, &__prediction); + match __prediction.alt { + 1 => { + self.base.parse_listener_exit_rule(174); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); + } + self.base.push_new_recursion_context_with_previous(348isize, 174, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(174) { + return Err(__listener_error); + } + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __match = self.base.match_token_recovering(33, 3085, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3085isize); + let __child = self.parse_generated_rule_173_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(33, 3085, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3085isize); - let __child = self.parse_generated_rule_173_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 2 => break, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => break, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_175_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(175) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_175_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_175_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(175); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 175, GeneratedRuleError::Fatal; self.parse_generated_rule_175_precedence(precedence, allow_fallback) } } #[allow(dead_code)] @@ -46341,115 +40554,82 @@ where #[allow(dead_code)] fn parse_generated_rule_175_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(350isize, 175, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let action = self.base.parser_action_at_current_indexed(3091, 175, 10, __rule_start, __consumed_eof); - let _ = action; - let __invoking_marker = self.base.push_invoking_state(3092isize); - let __child = self.parse_generated_rule_174_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3099, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(475, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - let __prediction = if __prediction.alt == 1 { - let __semantic_la = self.base.la(1); - if __semantic_la == 83 { - __prediction - } else { - antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } - } - } else { - __prediction - }; - self.base.record_generated_prediction_diagnostic(atn(), 3099, &__prediction); - match __prediction.alt { - 1 => { - self.base.parse_listener_exit_rule(175); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 350isize, 175, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let action = self.base.parser_action_at_current_indexed(3091, 175, 10, __rule_start, __consumed_eof); + let _ = action; + let __invoking_marker = self.base.push_invoking_state(3092isize); + let __child = self.parse_generated_rule_174_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + loop { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3099, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + match __simulator.adaptive_predict_stream_info_with_context(475, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - self.base.push_new_recursion_context_with_previous(350isize, 175, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(175) { - return Err(__listener_error); + }; + let __prediction = if __prediction.alt == 1 { + let __semantic_la = self.base.la(1); + if __semantic_la == 83 { + __prediction + } else { + antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } } - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } else { + __prediction + }; + self.base.record_generated_prediction_diagnostic(atn(), 3099, &__prediction); + match __prediction.alt { + 1 => { + self.base.parse_listener_exit_rule(175); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); + } + self.base.push_new_recursion_context_with_previous(350isize, 175, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(175) { + return Err(__listener_error); + } + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __match = self.base.match_token_recovering(83, 3096, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3096isize); + let __child = self.parse_generated_rule_174_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(83, 3096, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3096isize); - let __child = self.parse_generated_rule_174_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 2 => break, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => break, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_176_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(176) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_176_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_176_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(176); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 176, GeneratedRuleError::Fatal; self.parse_generated_rule_176_precedence(precedence, allow_fallback) } } #[allow(dead_code)] @@ -46459,922 +40639,724 @@ where #[allow(dead_code)] fn parse_generated_rule_176_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(352isize, 176, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let action = self.base.parser_action_at_current_indexed(3102, 176, 11, __rule_start, __consumed_eof); - let _ = action; - let __invoking_marker = self.base.push_invoking_state(3103isize); - let __child = self.parse_generated_rule_175_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3110, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(476, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - let __prediction = if __prediction.alt == 1 { - let __semantic_la = self.base.la(1); - if __semantic_la == 61 { - __prediction - } else { - antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } - } - } else { - __prediction - }; - self.base.record_generated_prediction_diagnostic(atn(), 3110, &__prediction); - match __prediction.alt { - 1 => { - self.base.parse_listener_exit_rule(176); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 352isize, 176, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let action = self.base.parser_action_at_current_indexed(3102, 176, 11, __rule_start, __consumed_eof); + let _ = action; + let __invoking_marker = self.base.push_invoking_state(3103isize); + let __child = self.parse_generated_rule_175_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + loop { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3110, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + match __simulator.adaptive_predict_stream_info_with_context(476, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - self.base.push_new_recursion_context_with_previous(352isize, 176, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(176) { - return Err(__listener_error); + }; + let __prediction = if __prediction.alt == 1 { + let __semantic_la = self.base.la(1); + if __semantic_la == 61 { + __prediction + } else { + antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } } - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } else { + __prediction + }; + self.base.record_generated_prediction_diagnostic(atn(), 3110, &__prediction); + match __prediction.alt { + 1 => { + self.base.parse_listener_exit_rule(176); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); + } + self.base.push_new_recursion_context_with_previous(352isize, 176, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(176) { + return Err(__listener_error); + } + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __match = self.base.match_token_recovering(61, 3107, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3107isize); + let __child = self.parse_generated_rule_175_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(61, 3107, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3107isize); - let __child = self.parse_generated_rule_175_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 2 => break, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => break, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_177_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(177) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_177(precedence, allow_fallback)) - } else { - self.parse_generated_rule_177(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(177); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 177, GeneratedRuleError::Fatal; self.parse_generated_rule_177(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_177(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(354isize, 177); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 3118, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3118) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(477, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(477, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3118, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3113isize); - let __child = self.parse_generated_rule_176_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(3114isize); - let __child = self.parse_generated_rule_176_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_set_recovering(&[(50, 51), (84, 87)], 3116, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3116isize); - let __child = self.parse_generated_rule_176_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_178_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(178) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_178_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_178_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(178); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_178(&mut self, allow_fallback: bool) -> Result { - self.parse_generated_rule_178_precedence(0, allow_fallback) - } - - #[allow(dead_code)] - fn parse_generated_rule_178_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(356isize, 178, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let action = self.base.parser_action_at_current_indexed(3120, 178, 12, __rule_start, __consumed_eof); - let _ = action; - let __invoking_marker = self.base.push_invoking_state(3121isize); - let __child = self.parse_generated_rule_177_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3128, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(478, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - let __prediction = if __prediction.alt == 1 { - let __semantic_la = self.base.la(1); - if __semantic_la == 36 { - __prediction - } else { - antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 354isize, 177, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 3118, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } - } else { - __prediction - }; - self.base.record_generated_prediction_diagnostic(atn(), 3128, &__prediction); - match __prediction.alt { - 1 => { - self.base.parse_listener_exit_rule(178); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); - } - self.base.push_new_recursion_context_with_previous(356isize, 178, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(178) { - return Err(__listener_error); - } - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); - } - let __match = self.base.match_token_recovering(36, 3125, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3125isize); - let __child = self.parse_generated_rule_177_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); } - 2 => break, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_179_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(179) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_179_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_179_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(179); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_179(&mut self, allow_fallback: bool) -> Result { - self.parse_generated_rule_179_precedence(0, allow_fallback) - } - - #[allow(dead_code)] - fn parse_generated_rule_179_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(358isize, 179, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let action = self.base.parser_action_at_current_indexed(3131, 179, 13, __rule_start, __consumed_eof); - let _ = action; - let __invoking_marker = self.base.push_invoking_state(3132isize); - let __child = self.parse_generated_rule_178_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - loop { let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3139, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3118) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(477, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(479, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - let __prediction = if __prediction.alt == 1 { - let __semantic_la = self.base.la(1); - if __semantic_la == 79 { - __prediction + __simulator.adaptive_predict_stream_info_with_context(477, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? } else { - antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } + __prediction } - } else { - __prediction }; - self.base.record_generated_prediction_diagnostic(atn(), 3139, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 3118, &__prediction); match __prediction.alt { 1 => { - self.base.parse_listener_exit_rule(179); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); - } - self.base.push_new_recursion_context_with_previous(358isize, 179, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(179) { - return Err(__listener_error); - } - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); - } - let __match = self.base.match_token_recovering(79, 3136, atn())?; + let __invoking_marker = self.base.push_invoking_state(3113isize); + let __child = self.parse_generated_rule_176_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(3114isize); + let __child = self.parse_generated_rule_176_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_set_recovering(&[(50, 51), (84, 87)], 3116, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3136isize); - let __child = self.parse_generated_rule_178_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(3116isize); + let __child = self.parse_generated_rule_176_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } - 2 => break, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_180_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(180) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_180(precedence, allow_fallback)) - } else { - self.parse_generated_rule_180(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(180); - __listener_result + fn parse_generated_rule_178_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 178, GeneratedRuleError::Fatal; self.parse_generated_rule_178_precedence(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_180(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(360isize, 180); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 46 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 63 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 3161, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3161) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(484, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(484, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3161, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3142isize); - let __child = self.parse_generated_rule_179_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(3143isize); - let __child = self.parse_generated_rule_179_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(46, 3146, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 3146, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } + fn parse_generated_rule_178(&mut self, allow_fallback: bool) -> Result { + self.parse_generated_rule_178_precedence(0, allow_fallback) + } + + #[allow(dead_code)] + fn parse_generated_rule_178_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 356isize, 178, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let action = self.base.parser_action_at_current_indexed(3120, 178, 12, __rule_start, __consumed_eof); + let _ = action; + let __invoking_marker = self.base.push_invoking_state(3121isize); + let __child = self.parse_generated_rule_177_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + loop { let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3146) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(480, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3128, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(480, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + match __simulator.adaptive_predict_stream_info_with_context(478, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + }; + let __prediction = if __prediction.alt == 1 { + let __semantic_la = self.base.la(1); + if __semantic_la == 36 { __prediction + } else { + antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } } + } else { + __prediction }; - self.base.record_generated_prediction_diagnostic(atn(), 3146, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 3128, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(3145isize); - let __child = self.parse_generated_rule_179_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.parse_listener_exit_rule(178); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); + } + self.base.push_new_recursion_context_with_previous(356isize, 178, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(178) { + return Err(__listener_error); + } + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __match = self.base.match_token_recovering(36, 3125, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3125isize); + let __child = self.parse_generated_rule_177_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } - 2 => { - } + 2 => break, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - 3 => { - let __invoking_marker = self.base.push_invoking_state(3148isize); - let __child = self.parse_generated_rule_179_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(63, 3151, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 3151, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_179_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 179, GeneratedRuleError::Fatal; self.parse_generated_rule_179_precedence(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_179(&mut self, allow_fallback: bool) -> Result { + self.parse_generated_rule_179_precedence(0, allow_fallback) + } + + #[allow(dead_code)] + fn parse_generated_rule_179_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 358isize, 179, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let action = self.base.parser_action_at_current_indexed(3131, 179, 13, __rule_start, __consumed_eof); + let _ = action; + let __invoking_marker = self.base.push_invoking_state(3132isize); + let __child = self.parse_generated_rule_178_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + loop { let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3151) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(481, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3139, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(481, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + match __simulator.adaptive_predict_stream_info_with_context(479, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + }; + let __prediction = if __prediction.alt == 1 { + let __semantic_la = self.base.la(1); + if __semantic_la == 79 { __prediction + } else { + antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } } + } else { + __prediction }; - self.base.record_generated_prediction_diagnostic(atn(), 3151, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 3139, &__prediction); match __prediction.alt { 1 => { - let __invoking_marker = self.base.push_invoking_state(3150isize); - let __child = self.parse_generated_rule_179_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.parse_listener_exit_rule(179); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); + } + self.base.push_new_recursion_context_with_previous(358isize, 179, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(179) { + return Err(__listener_error); + } + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __match = self.base.match_token_recovering(79, 3136, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3136isize); + let __child = self.parse_generated_rule_178_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } - 2 => { - } + 2 => break, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - 4 => { - let __match = self.base.match_token_recovering(46, 3155, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 3155, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_180_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 180, GeneratedRuleError::Fatal; self.parse_generated_rule_180(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_180(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 360isize, 180, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 46 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 63 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 3161, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3155) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(482, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(482, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3161) { __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(484, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(484, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3155, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3154isize); - let __child = self.parse_generated_rule_179_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3161, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(3142isize); + let __child = self.parse_generated_rule_179_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(3143isize); + let __child = self.parse_generated_rule_179_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(46, 3146, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 3146, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3146) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(480, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(480, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3146, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(3145isize); + let __child = self.parse_generated_rule_179_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - 5 => { - let __match = self.base.match_token_recovering(63, 3159, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 3159, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + 3 => { + let __invoking_marker = self.base.push_invoking_state(3148isize); + let __child = self.parse_generated_rule_179_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(63, 3151, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 3151, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3151) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(481, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(481, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3151, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(3150isize); + let __child = self.parse_generated_rule_179_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3159) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(483, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(483, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + 4 => { + let __match = self.base.match_token_recovering(46, 3155, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 3155, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3155) { __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(482, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(482, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3155, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(3154isize); + let __child = self.parse_generated_rule_179_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3159, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3158isize); - let __child = self.parse_generated_rule_179_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + } + 5 => { + let __match = self.base.match_token_recovering(63, 3159, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 3159, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3159) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(483, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(483, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3159, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(3158isize); + let __child = self.parse_generated_rule_179_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_181_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(181) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_181(precedence, allow_fallback)) - } else { - self.parse_generated_rule_181(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(181); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 181, GeneratedRuleError::Fatal; self.parse_generated_rule_181(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_181(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(362isize, 181); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 18 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 3171, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 362isize, 181, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 18 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 3171, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3171) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(485, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(485, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3171) { __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(485, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(485, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3171, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(3163isize); + let __child = self.parse_generated_rule_180_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __match = self.base.match_token_recovering(18, 3165, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(25, 3166, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3166isize); + let __child = self.parse_generated_rule_181_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 3 => { + let __invoking_marker = self.base.push_invoking_state(3167isize); + let __child = self.parse_generated_rule_180_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_set_recovering(&[(25, 25), (88, 97)], 3169, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3169isize); + let __child = self.parse_generated_rule_181_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3171, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3163isize); - let __child = self.parse_generated_rule_180_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(18, 3165, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(25, 3166, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3166isize); - let __child = self.parse_generated_rule_181_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 3 => { - let __invoking_marker = self.base.push_invoking_state(3167isize); - let __child = self.parse_generated_rule_180_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_set_recovering(&[(25, 25), (88, 97)], 3169, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3169isize); - let __child = self.parse_generated_rule_181_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_182_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(182) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_182_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_182_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(182); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 182, GeneratedRuleError::Fatal; self.parse_generated_rule_182_precedence(precedence, allow_fallback) } } #[allow(dead_code)] @@ -47384,365 +41366,299 @@ where #[allow(dead_code)] fn parse_generated_rule_182_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(364isize, 182, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let action = self.base.parser_action_at_current_indexed(3173, 182, 14, __rule_start, __consumed_eof); - let _ = action; - let __invoking_marker = self.base.push_invoking_state(3174isize); - let __child = self.parse_generated_rule_156_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3180, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(486, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - let __prediction = if __prediction.alt == 1 { - let __semantic_la = self.base.la(1); - if true { - __prediction - } else { - antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } - } - } else { - __prediction - }; - self.base.record_generated_prediction_diagnostic(atn(), 3180, &__prediction); - match __prediction.alt { - 1 => { - self.base.parse_listener_exit_rule(182); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 364isize, 182, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let action = self.base.parser_action_at_current_indexed(3173, 182, 14, __rule_start, __consumed_eof); + let _ = action; + let __invoking_marker = self.base.push_invoking_state(3174isize); + let __child = self.parse_generated_rule_156_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + loop { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3180, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + match __simulator.adaptive_predict_stream_info_with_context(486, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - self.base.push_new_recursion_context_with_previous(364isize, 182, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(182) { - return Err(__listener_error); + }; + let __prediction = if __prediction.alt == 1 { + let __semantic_la = self.base.la(1); + if true { + __prediction + } else { + antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } } - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } else { + __prediction + }; + self.base.record_generated_prediction_diagnostic(atn(), 3180, &__prediction); + match __prediction.alt { + 1 => { + self.base.parse_listener_exit_rule(182); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); + } + self.base.push_new_recursion_context_with_previous(364isize, 182, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(182) { + return Err(__listener_error); + } + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __invoking_marker = self.base.push_invoking_state(3177isize); + let __child = self.parse_generated_rule_168_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3177isize); - let __child = self.parse_generated_rule_168_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 2 => break, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => break, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_183_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(183) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_183(precedence, allow_fallback)) - } else { - self.parse_generated_rule_183(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(183); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 183, GeneratedRuleError::Fatal; self.parse_generated_rule_183(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_183(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(366isize, 183); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2..=3 | 5..=6 | 12..=13 | 20..=22 | 27..=28 | 30 | 40..=41 | 45 | 48 | 50 | 52..=53 | 55 | 58..=59 | 61 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 47 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 60 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 44 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 36 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 15 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 64 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 3210, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 366isize, 183, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2..=3 | 5..=6 | 12..=13 | 20..=22 | 27..=28 | 30 | 40..=41 | 45 | 48 | 50 | 52..=53 | 55 | 58..=59 | 61 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 47 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 60 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 44 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 36 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 15 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 64 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 3210, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3210) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(489, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(489, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3210) { __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(489, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(489, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3210, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3183isize); - let __child = self.parse_generated_rule_182_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(3184isize); - let __child = self.parse_generated_rule_153_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __invoking_marker = self.base.push_invoking_state(3185isize); - let __child = self.parse_generated_rule_183_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 3 => { - let __match = self.base.match_token_recovering(60, 3188, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3188isize); - let __child = self.parse_generated_rule_183_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 4 => { - let __match = self.base.match_token_recovering(44, 3190, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3190isize); - let __child = self.parse_generated_rule_183_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 5 => { - let __match = self.base.match_token_recovering(33, 3192, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(55, 3193, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3193isize); - let __child = self.parse_generated_rule_113_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __invoking_marker = self.base.push_invoking_state(3194isize); - let __child = self.parse_generated_rule_183_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 6 => { - let __match = self.base.match_token_recovering(33, 3198, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 3198, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3210, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(3183isize); + let __child = self.parse_generated_rule_182_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=6 | 12..=13 | 15 | 20..=22 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=45 | 47..=48 | 50 | 52..=53 | 55 | 58..=61 | 64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 3198, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(23, 3199, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 2 => { + let __invoking_marker = self.base.push_invoking_state(3184isize); + let __child = self.parse_generated_rule_153_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(3185isize); + let __child = self.parse_generated_rule_183_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3200isize); - let __child = self.parse_generated_rule_183_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 7 => { - let __match = self.base.match_token_recovering(36, 3203, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 3203, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + 3 => { + let __match = self.base.match_token_recovering(60, 3188, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3188isize); + let __child = self.parse_generated_rule_183_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 4 => { + let __match = self.base.match_token_recovering(44, 3190, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3190isize); + let __child = self.parse_generated_rule_183_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 5 => { + let __match = self.base.match_token_recovering(33, 3192, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(55, 3193, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3193isize); + let __child = self.parse_generated_rule_113_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __invoking_marker = self.base.push_invoking_state(3194isize); + let __child = self.parse_generated_rule_183_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 6 => { + let __match = self.base.match_token_recovering(33, 3198, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 3198, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=6 | 12..=13 | 15 | 20..=22 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=45 | 47..=48 | 50 | 52..=53 | 55 | 58..=61 | 64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 3198, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(23, 3199, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __invoking_marker = self.base.push_invoking_state(3200isize); + let __child = self.parse_generated_rule_183_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 2..=3 | 5..=6 | 12..=13 | 15 | 20..=22 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=45 | 47..=48 | 50 | 52..=53 | 55 | 58..=61 | 64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 3203, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(23, 3204, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + 7 => { + let __match = self.base.match_token_recovering(36, 3203, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 3203, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 23 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 2..=3 | 5..=6 | 12..=13 | 15 | 20..=22 | 27..=28 | 30 | 33 | 36 | 40..=41 | 44..=45 | 47..=48 | 50 | 52..=53 | 55 | 58..=61 | 64 | 67..=71 | 73..=77 | 79..=80 | 98..=100 | 102..=112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 3203, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(23, 3204, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __invoking_marker = self.base.push_invoking_state(3205isize); + let __child = self.parse_generated_rule_183_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3205isize); - let __child = self.parse_generated_rule_183_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 8 => { - let __match = self.base.match_token_recovering(15, 3207, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3207isize); - let __child = self.parse_generated_rule_183_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 8 => { + let __match = self.base.match_token_recovering(15, 3207, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3207isize); + let __child = self.parse_generated_rule_183_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 9 => { + let __match = self.base.match_token_recovering(64, 3209, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3209isize); + let __child = self.parse_generated_rule_183_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 9 => { - let __match = self.base.match_token_recovering(64, 3209, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3209isize); - let __child = self.parse_generated_rule_183_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_184_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(184) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_184_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_184_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(184); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 184, GeneratedRuleError::Fatal; self.parse_generated_rule_184_precedence(precedence, allow_fallback) } } #[allow(dead_code)] @@ -47752,145 +41668,112 @@ where #[allow(dead_code)] fn parse_generated_rule_184_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(368isize, 184, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let action = self.base.parser_action_at_current_indexed(3212, 184, 15, __rule_start, __consumed_eof); - let _ = action; - let __invoking_marker = self.base.push_invoking_state(3213isize); - let __child = self.parse_generated_rule_183_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3223, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(491, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3223, &__prediction); - match __prediction.alt { - 1 => { - self.base.parse_listener_exit_rule(184); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); - } - self.base.push_new_recursion_context_with_previous(368isize, 184, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(184) { - return Err(__listener_error); - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = { + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 368isize, 184, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let action = self.base.parser_action_at_current_indexed(3212, 184, 15, __rule_start, __consumed_eof); + let _ = action; + let __invoking_marker = self.base.push_invoking_state(3213isize); + let __child = self.parse_generated_rule_183_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + loop { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3223, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(490, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if self.base.report_diagnostic_errors() { - let __diagnostic_la = self.base.la(1); - let mut __diagnostic_alts = Vec::new(); - if __diagnostic_la == 17 { - __diagnostic_alts.push(1); + match __simulator.adaptive_predict_stream_info_with_context(491, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), } - if __diagnostic_la == 24 { - __diagnostic_alts.push(2); - } - self.base.record_generated_ambiguity_diagnostic(atn(), 3221, __decision_start, __decision_start, &__diagnostic_alts); } - match __prediction.alt { - 1 => { - if !self.base.precpred(2) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 2)")); + }; + self.base.record_generated_prediction_diagnostic(atn(), 3223, &__prediction); + match __prediction.alt { + 1 => { + self.base.parse_listener_exit_rule(184); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); + } + self.base.push_new_recursion_context_with_previous(368isize, 184, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(184) { + return Err(__listener_error); + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(490, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if self.base.report_diagnostic_errors() { + let __diagnostic_la = self.base.la(1); + let mut __diagnostic_alts = Vec::new(); + if __diagnostic_la == 17 { + __diagnostic_alts.push(1); } - let __match = self.base.match_token_recovering(17, 3217, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3217isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + if __diagnostic_la == 24 { + __diagnostic_alts.push(2); + } + self.base.record_generated_ambiguity_diagnostic(atn(), 3221, __decision_start, __decision_start, &__diagnostic_alts); } - 2 => { - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + match __prediction.alt { + 1 => { + if !self.base.precpred(2) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 2)")); + } + let __match = self.base.match_token_recovering(17, 3217, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3217isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(24, 3220, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3220isize); - let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 2 => { + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __match = self.base.match_token_recovering(24, 3220, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3220isize); + let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + 2 => break, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => break, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_185_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(185) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_185_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_185_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(185); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 185, GeneratedRuleError::Fatal; self.parse_generated_rule_185_precedence(precedence, allow_fallback) } } #[allow(dead_code)] @@ -47900,161 +41783,128 @@ where #[allow(dead_code)] fn parse_generated_rule_185_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(370isize, 185, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let action = self.base.parser_action_at_current_indexed(3226, 185, 16, __rule_start, __consumed_eof); - let _ = action; - let __invoking_marker = self.base.push_invoking_state(3227isize); - let __child = self.parse_generated_rule_184_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3240, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(493, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3240, &__prediction); - match __prediction.alt { - 1 => { - self.base.parse_listener_exit_rule(185); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); - } - self.base.push_new_recursion_context_with_previous(370isize, 185, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(185) { - return Err(__listener_error); - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = { + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 370isize, 185, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let action = self.base.parser_action_at_current_indexed(3226, 185, 16, __rule_start, __consumed_eof); + let _ = action; + let __invoking_marker = self.base.push_invoking_state(3227isize); + let __child = self.parse_generated_rule_184_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + loop { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3240, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(492, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if self.base.report_diagnostic_errors() { - let __diagnostic_la = self.base.la(1); - let mut __diagnostic_alts = Vec::new(); - if __diagnostic_la == 15 { - __diagnostic_alts.push(1); + match __simulator.adaptive_predict_stream_info_with_context(493, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), } - if __diagnostic_la == 81 { - __diagnostic_alts.push(2); + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3240, &__prediction); + match __prediction.alt { + 1 => { + self.base.parse_listener_exit_rule(185); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); } - if __diagnostic_la == 82 { - __diagnostic_alts.push(3); + self.base.push_new_recursion_context_with_previous(370isize, 185, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(185) { + return Err(__listener_error); } - self.base.record_generated_ambiguity_diagnostic(atn(), 3238, __decision_start, __decision_start, &__diagnostic_alts); - } - match __prediction.alt { - 1 => { - if !self.base.precpred(3) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 3)")); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(492, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if self.base.report_diagnostic_errors() { + let __diagnostic_la = self.base.la(1); + let mut __diagnostic_alts = Vec::new(); + if __diagnostic_la == 15 { + __diagnostic_alts.push(1); } - let __match = self.base.match_token_recovering(15, 3231, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3231isize); - let __child = self.parse_generated_rule_184_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - if !self.base.precpred(2) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 2)")); + if __diagnostic_la == 81 { + __diagnostic_alts.push(2); } - let __match = self.base.match_token_recovering(81, 3234, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3234isize); - let __child = self.parse_generated_rule_184_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + if __diagnostic_la == 82 { + __diagnostic_alts.push(3); + } + self.base.record_generated_ambiguity_diagnostic(atn(), 3238, __decision_start, __decision_start, &__diagnostic_alts); } - 3 => { - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + match __prediction.alt { + 1 => { + if !self.base.precpred(3) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 3)")); + } + let __match = self.base.match_token_recovering(15, 3231, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3231isize); + let __child = self.parse_generated_rule_184_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(82, 3237, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3237isize); - let __child = self.parse_generated_rule_184_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 2 => { + if !self.base.precpred(2) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 2)")); + } + let __match = self.base.match_token_recovering(81, 3234, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3234isize); + let __child = self.parse_generated_rule_184_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 3 => { + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __match = self.base.match_token_recovering(82, 3237, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3237isize); + let __child = self.parse_generated_rule_184_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + 2 => break, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => break, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_186_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(186) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_186_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_186_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(186); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 186, GeneratedRuleError::Fatal; self.parse_generated_rule_186_precedence(precedence, allow_fallback) } } #[allow(dead_code)] @@ -48064,145 +41914,112 @@ where #[allow(dead_code)] fn parse_generated_rule_186_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(372isize, 186, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let action = self.base.parser_action_at_current_indexed(3243, 186, 17, __rule_start, __consumed_eof); - let _ = action; - let __invoking_marker = self.base.push_invoking_state(3244isize); - let __child = self.parse_generated_rule_185_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3254, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(495, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3254, &__prediction); - match __prediction.alt { - 1 => { - self.base.parse_listener_exit_rule(186); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); - } - self.base.push_new_recursion_context_with_previous(372isize, 186, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(186) { - return Err(__listener_error); - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = { + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 372isize, 186, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let action = self.base.parser_action_at_current_indexed(3243, 186, 17, __rule_start, __consumed_eof); + let _ = action; + let __invoking_marker = self.base.push_invoking_state(3244isize); + let __child = self.parse_generated_rule_185_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + loop { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3254, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(494, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if self.base.report_diagnostic_errors() { - let __diagnostic_la = self.base.la(1); - let mut __diagnostic_alts = Vec::new(); - if __diagnostic_la == 54 { - __diagnostic_alts.push(1); + match __simulator.adaptive_predict_stream_info_with_context(495, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), } - if __diagnostic_la == 60 { - __diagnostic_alts.push(2); - } - self.base.record_generated_ambiguity_diagnostic(atn(), 3252, __decision_start, __decision_start, &__diagnostic_alts); } - match __prediction.alt { - 1 => { - if !self.base.precpred(2) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 2)")); + }; + self.base.record_generated_prediction_diagnostic(atn(), 3254, &__prediction); + match __prediction.alt { + 1 => { + self.base.parse_listener_exit_rule(186); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); + } + self.base.push_new_recursion_context_with_previous(372isize, 186, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(186) { + return Err(__listener_error); + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(494, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if self.base.report_diagnostic_errors() { + let __diagnostic_la = self.base.la(1); + let mut __diagnostic_alts = Vec::new(); + if __diagnostic_la == 54 { + __diagnostic_alts.push(1); } - let __match = self.base.match_token_recovering(54, 3248, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3248isize); - let __child = self.parse_generated_rule_185_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + if __diagnostic_la == 60 { + __diagnostic_alts.push(2); + } + self.base.record_generated_ambiguity_diagnostic(atn(), 3252, __decision_start, __decision_start, &__diagnostic_alts); } - 2 => { - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + match __prediction.alt { + 1 => { + if !self.base.precpred(2) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 2)")); + } + let __match = self.base.match_token_recovering(54, 3248, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3248isize); + let __child = self.parse_generated_rule_185_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __match = self.base.match_token_recovering(60, 3251, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3251isize); + let __child = self.parse_generated_rule_185_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(60, 3251, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3251isize); - let __child = self.parse_generated_rule_185_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + 2 => break, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => break, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_187_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(187) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_187_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_187_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(187); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 187, GeneratedRuleError::Fatal; self.parse_generated_rule_187_precedence(precedence, allow_fallback) } } #[allow(dead_code)] @@ -48212,151 +42029,118 @@ where #[allow(dead_code)] fn parse_generated_rule_187_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(374isize, 187, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let action = self.base.parser_action_at_current_indexed(3257, 187, 18, __rule_start, __consumed_eof); - let _ = action; - let __invoking_marker = self.base.push_invoking_state(3258isize); - let __child = self.parse_generated_rule_186_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3270, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(497, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3270, &__prediction); - match __prediction.alt { - 1 => { - self.base.parse_listener_exit_rule(187); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); - } - self.base.push_new_recursion_context_with_previous(374isize, 187, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(187) { - return Err(__listener_error); - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = { + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 374isize, 187, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let action = self.base.parser_action_at_current_indexed(3257, 187, 18, __rule_start, __consumed_eof); + let _ = action; + let __invoking_marker = self.base.push_invoking_state(3258isize); + let __child = self.parse_generated_rule_186_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + loop { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3270, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(496, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if self.base.report_diagnostic_errors() { - let __diagnostic_la = self.base.la(1); - let mut __diagnostic_alts = Vec::new(); - if __diagnostic_la == 50 { - __diagnostic_alts.push(1); - } - if __diagnostic_la == 51 { - __diagnostic_alts.push(2); + match __simulator.adaptive_predict_stream_info_with_context(497, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), } - self.base.record_generated_ambiguity_diagnostic(atn(), 3268, __decision_start, __decision_start, &__diagnostic_alts); } - match __prediction.alt { - 1 => { - if !self.base.precpred(2) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 2)")); + }; + self.base.record_generated_prediction_diagnostic(atn(), 3270, &__prediction); + match __prediction.alt { + 1 => { + self.base.parse_listener_exit_rule(187); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); + } + self.base.push_new_recursion_context_with_previous(374isize, 187, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(187) { + return Err(__listener_error); + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(496, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if self.base.report_diagnostic_errors() { + let __diagnostic_la = self.base.la(1); + let mut __diagnostic_alts = Vec::new(); + if __diagnostic_la == 50 { + __diagnostic_alts.push(1); } - let __match = self.base.match_token_recovering(50, 3262, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(50, 3263, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3263isize); - let __child = self.parse_generated_rule_186_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + if __diagnostic_la == 51 { + __diagnostic_alts.push(2); + } + self.base.record_generated_ambiguity_diagnostic(atn(), 3268, __decision_start, __decision_start, &__diagnostic_alts); } - 2 => { - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + match __prediction.alt { + 1 => { + if !self.base.precpred(2) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 2)")); + } + let __match = self.base.match_token_recovering(50, 3262, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(50, 3263, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3263isize); + let __child = self.parse_generated_rule_186_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(51, 3266, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(51, 3267, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3267isize); - let __child = self.parse_generated_rule_186_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 2 => { + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __match = self.base.match_token_recovering(51, 3266, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(51, 3267, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3267isize); + let __child = self.parse_generated_rule_186_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + 2 => break, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => break, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_188_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(188) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_188_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_188_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(188); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 188, GeneratedRuleError::Fatal; self.parse_generated_rule_188_precedence(precedence, allow_fallback) } } #[allow(dead_code)] @@ -48366,115 +42150,82 @@ where #[allow(dead_code)] fn parse_generated_rule_188_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(376isize, 188, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let action = self.base.parser_action_at_current_indexed(3273, 188, 19, __rule_start, __consumed_eof); - let _ = action; - let __invoking_marker = self.base.push_invoking_state(3274isize); - let __child = self.parse_generated_rule_187_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3281, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(498, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - let __prediction = if __prediction.alt == 1 { - let __semantic_la = self.base.la(1); - if __semantic_la == 33 { - __prediction - } else { - antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } - } - } else { - __prediction - }; - self.base.record_generated_prediction_diagnostic(atn(), 3281, &__prediction); - match __prediction.alt { - 1 => { - self.base.parse_listener_exit_rule(188); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 376isize, 188, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let action = self.base.parser_action_at_current_indexed(3273, 188, 19, __rule_start, __consumed_eof); + let _ = action; + let __invoking_marker = self.base.push_invoking_state(3274isize); + let __child = self.parse_generated_rule_187_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + loop { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3281, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + match __simulator.adaptive_predict_stream_info_with_context(498, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - self.base.push_new_recursion_context_with_previous(376isize, 188, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(188) { - return Err(__listener_error); + }; + let __prediction = if __prediction.alt == 1 { + let __semantic_la = self.base.la(1); + if __semantic_la == 33 { + __prediction + } else { + antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } } - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } else { + __prediction + }; + self.base.record_generated_prediction_diagnostic(atn(), 3281, &__prediction); + match __prediction.alt { + 1 => { + self.base.parse_listener_exit_rule(188); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); + } + self.base.push_new_recursion_context_with_previous(376isize, 188, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(188) { + return Err(__listener_error); + } + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __match = self.base.match_token_recovering(33, 3278, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3278isize); + let __child = self.parse_generated_rule_187_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(33, 3278, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3278isize); - let __child = self.parse_generated_rule_187_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 2 => break, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => break, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_189_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(189) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_189_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_189_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(189); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 189, GeneratedRuleError::Fatal; self.parse_generated_rule_189_precedence(precedence, allow_fallback) } } #[allow(dead_code)] @@ -48484,115 +42235,82 @@ where #[allow(dead_code)] fn parse_generated_rule_189_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(378isize, 189, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let action = self.base.parser_action_at_current_indexed(3284, 189, 20, __rule_start, __consumed_eof); - let _ = action; - let __invoking_marker = self.base.push_invoking_state(3285isize); - let __child = self.parse_generated_rule_188_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3292, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(499, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - let __prediction = if __prediction.alt == 1 { - let __semantic_la = self.base.la(1); - if __semantic_la == 83 { - __prediction - } else { - antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } - } - } else { - __prediction - }; - self.base.record_generated_prediction_diagnostic(atn(), 3292, &__prediction); - match __prediction.alt { - 1 => { - self.base.parse_listener_exit_rule(189); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 378isize, 189, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let action = self.base.parser_action_at_current_indexed(3284, 189, 20, __rule_start, __consumed_eof); + let _ = action; + let __invoking_marker = self.base.push_invoking_state(3285isize); + let __child = self.parse_generated_rule_188_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + loop { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3292, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + match __simulator.adaptive_predict_stream_info_with_context(499, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - self.base.push_new_recursion_context_with_previous(378isize, 189, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(189) { - return Err(__listener_error); + }; + let __prediction = if __prediction.alt == 1 { + let __semantic_la = self.base.la(1); + if __semantic_la == 83 { + __prediction + } else { + antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } } - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } else { + __prediction + }; + self.base.record_generated_prediction_diagnostic(atn(), 3292, &__prediction); + match __prediction.alt { + 1 => { + self.base.parse_listener_exit_rule(189); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); + } + self.base.push_new_recursion_context_with_previous(378isize, 189, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(189) { + return Err(__listener_error); + } + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __match = self.base.match_token_recovering(83, 3289, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3289isize); + let __child = self.parse_generated_rule_188_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(83, 3289, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3289isize); - let __child = self.parse_generated_rule_188_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 2 => break, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => break, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_190_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(190) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_190_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_190_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(190); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 190, GeneratedRuleError::Fatal; self.parse_generated_rule_190_precedence(precedence, allow_fallback) } } #[allow(dead_code)] @@ -48602,425 +42320,359 @@ where #[allow(dead_code)] fn parse_generated_rule_190_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(380isize, 190, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let action = self.base.parser_action_at_current_indexed(3295, 190, 21, __rule_start, __consumed_eof); - let _ = action; - let __invoking_marker = self.base.push_invoking_state(3296isize); - let __child = self.parse_generated_rule_189_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3303, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(500, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - let __prediction = if __prediction.alt == 1 { - let __semantic_la = self.base.la(1); - if __semantic_la == 61 { - __prediction - } else { - antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } - } - } else { - __prediction - }; - self.base.record_generated_prediction_diagnostic(atn(), 3303, &__prediction); - match __prediction.alt { - 1 => { - self.base.parse_listener_exit_rule(190); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 380isize, 190, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let action = self.base.parser_action_at_current_indexed(3295, 190, 21, __rule_start, __consumed_eof); + let _ = action; + let __invoking_marker = self.base.push_invoking_state(3296isize); + let __child = self.parse_generated_rule_189_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + loop { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3303, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + match __simulator.adaptive_predict_stream_info_with_context(500, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - self.base.push_new_recursion_context_with_previous(380isize, 190, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(190) { - return Err(__listener_error); + }; + let __prediction = if __prediction.alt == 1 { + let __semantic_la = self.base.la(1); + if __semantic_la == 61 { + __prediction + } else { + antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } } - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } else { + __prediction + }; + self.base.record_generated_prediction_diagnostic(atn(), 3303, &__prediction); + match __prediction.alt { + 1 => { + self.base.parse_listener_exit_rule(190); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); + } + self.base.push_new_recursion_context_with_previous(380isize, 190, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(190) { + return Err(__listener_error); + } + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __match = self.base.match_token_recovering(61, 3300, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3300isize); + let __child = self.parse_generated_rule_189_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(61, 3300, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3300isize); - let __child = self.parse_generated_rule_189_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 2 => break, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => break, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_191_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(191) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_191(precedence, allow_fallback)) - } else { - self.parse_generated_rule_191(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(191); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 191, GeneratedRuleError::Fatal; self.parse_generated_rule_191(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_191(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(382isize, 191); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 23 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 3325, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 382isize, 191, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 23 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 3325, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3325) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(505, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(505, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3325) { __prediction - } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3325, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3306isize); - let __child = self.parse_generated_rule_190_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - match self.base.sync_decision(atn(), 3309, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3309) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(501, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(501, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3309, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(33, 3308, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(55, 3310, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 3312, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(505, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(505, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3312) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(502, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(502, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3312, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3311isize); - let __child = self.parse_generated_rule_113_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 3325, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(3306isize); + let __child = self.parse_generated_rule_190_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3314isize); - let __child = self.parse_generated_rule_190_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_set_recovering(&[(50, 51), (84, 87)], 3318, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 3318, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + 2 => { + match self.base.sync_decision(atn(), 3309, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3318) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(503, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(503, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3309) { __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(501, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(501, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3309, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(33, 3308, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(55, 3310, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3318, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(33, 3317, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(55, 3319, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { + match self.base.sync_decision(atn(), 3312, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - match self.base.sync_decision(atn(), 3321, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3312) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(502, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(502, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3312, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(3311isize); + let __child = self.parse_generated_rule_113_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __invoking_marker = self.base.push_invoking_state(3314isize); + let __child = self.parse_generated_rule_190_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_set_recovering(&[(50, 51), (84, 87)], 3318, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 3318, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3321) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(504, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(504, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3318) { __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(503, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(503, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3318, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(33, 3317, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(55, 3319, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3321, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3320isize); - let __child = self.parse_generated_rule_113_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + match self.base.sync_decision(atn(), 3321, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3321) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(504, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(504, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3321, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(3320isize); + let __child = self.parse_generated_rule_113_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __invoking_marker = self.base.push_invoking_state(3323isize); + let __child = self.parse_generated_rule_190_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3323isize); - let __child = self.parse_generated_rule_190_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_192_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(192) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_192_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_192_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(192); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 192, GeneratedRuleError::Fatal; self.parse_generated_rule_192_precedence(precedence, allow_fallback) } } #[allow(dead_code)] @@ -49030,115 +42682,82 @@ where #[allow(dead_code)] fn parse_generated_rule_192_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(384isize, 192, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let action = self.base.parser_action_at_current_indexed(3327, 192, 22, __rule_start, __consumed_eof); - let _ = action; - let __invoking_marker = self.base.push_invoking_state(3328isize); - let __child = self.parse_generated_rule_191_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3335, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(506, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - let __prediction = if __prediction.alt == 1 { - let __semantic_la = self.base.la(1); - if __semantic_la == 36 { - __prediction - } else { - antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } - } - } else { - __prediction - }; - self.base.record_generated_prediction_diagnostic(atn(), 3335, &__prediction); - match __prediction.alt { - 1 => { - self.base.parse_listener_exit_rule(192); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 384isize, 192, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let action = self.base.parser_action_at_current_indexed(3327, 192, 22, __rule_start, __consumed_eof); + let _ = action; + let __invoking_marker = self.base.push_invoking_state(3328isize); + let __child = self.parse_generated_rule_191_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + loop { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3335, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + match __simulator.adaptive_predict_stream_info_with_context(506, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - self.base.push_new_recursion_context_with_previous(384isize, 192, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(192) { - return Err(__listener_error); + }; + let __prediction = if __prediction.alt == 1 { + let __semantic_la = self.base.la(1); + if __semantic_la == 36 { + __prediction + } else { + antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } } - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } else { + __prediction + }; + self.base.record_generated_prediction_diagnostic(atn(), 3335, &__prediction); + match __prediction.alt { + 1 => { + self.base.parse_listener_exit_rule(192); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); + } + self.base.push_new_recursion_context_with_previous(384isize, 192, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(192) { + return Err(__listener_error); + } + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __match = self.base.match_token_recovering(36, 3332, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3332isize); + let __child = self.parse_generated_rule_191_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(36, 3332, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3332isize); - let __child = self.parse_generated_rule_191_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 2 => break, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => break, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_193_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(193) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_193_precedence(precedence, allow_fallback)) - } else { - self.parse_generated_rule_193_precedence(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(193); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 193, GeneratedRuleError::Fatal; self.parse_generated_rule_193_precedence(precedence, allow_fallback) } } #[allow(dead_code)] @@ -49148,1432 +42767,860 @@ where #[allow(dead_code)] fn parse_generated_rule_193_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_recursion_rule(386isize, 193, __precedence); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let action = self.base.parser_action_at_current_indexed(3338, 193, 23, __rule_start, __consumed_eof); - let _ = action; - let __invoking_marker = self.base.push_invoking_state(3339isize); - let __child = self.parse_generated_rule_192_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - loop { - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3346, __precedence) { - Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, - Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - None => { - let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - match __simulator.adaptive_predict_stream_info_with_context(507, __prediction_precedence, self.base.input(), __prediction_context) { - Ok(__prediction) => __prediction, - Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, - Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - let __prediction = if __prediction.alt == 1 { - let __semantic_la = self.base.la(1); - if __semantic_la == 79 { - __prediction - } else { - antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } - } - } else { - __prediction - }; - self.base.record_generated_prediction_diagnostic(atn(), 3346, &__prediction); - match __prediction.alt { - 1 => { - self.base.parse_listener_exit_rule(193); - if let Some(__depth_error) = self.base.rule_depth_cap_violation() { - return Err(__depth_error); + antlr4_runtime::__antlr4_rust_generated_rule! { + recursive self, 386isize, 193, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let action = self.base.parser_action_at_current_indexed(3338, 193, 23, __rule_start, __consumed_eof); + let _ = action; + let __invoking_marker = self.base.push_invoking_state(3339isize); + let __child = self.parse_generated_rule_192_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + loop { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 3346, __precedence) { + Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None }, + Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + None => { + let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize }; + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + match __simulator.adaptive_predict_stream_info_with_context(507, __prediction_precedence, self.base.input(), __prediction_context) { + Ok(__prediction) => __prediction, + Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None }, + Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)), + } } - self.base.push_new_recursion_context_with_previous(386isize, 193, &mut __ctx); - if let Some(__listener_error) = self.base.parse_listener_enter_rule(193) { - return Err(__listener_error); + }; + let __prediction = if __prediction.alt == 1 { + let __semantic_la = self.base.la(1); + if __semantic_la == 79 { + __prediction + } else { + antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction } } - if !self.base.precpred(1) { - return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } else { + __prediction + }; + self.base.record_generated_prediction_diagnostic(atn(), 3346, &__prediction); + match __prediction.alt { + 1 => { + self.base.parse_listener_exit_rule(193); + if let Some(__depth_error) = self.base.rule_depth_cap_violation() { + return Err(__depth_error); + } + self.base.push_new_recursion_context_with_previous(386isize, 193, &mut __ctx); + if let Some(__listener_error) = self.base.parse_listener_enter_rule(193) { + return Err(__listener_error); + } + if !self.base.precpred(1) { + return Err(self.base.failed_predicate_error("precpred(_ctx, 1)")); + } + let __match = self.base.match_token_recovering(79, 3343, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3343isize); + let __child = self.parse_generated_rule_192_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(79, 3343, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3343isize); - let __child = self.parse_generated_rule_192_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 2 => break, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - 2 => break, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.unroll_recursion_context(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_recursion_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_194_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(194) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_194(precedence, allow_fallback)) - } else { - self.parse_generated_rule_194(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(194); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 194, GeneratedRuleError::Fatal; self.parse_generated_rule_194(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_194(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(388isize, 194); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 46 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 63 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 3368, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 388isize, 194, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 46 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 63 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 3368, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3368) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(512, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(512, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3368) { __prediction - } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3368, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3349isize); - let __child = self.parse_generated_rule_193_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(3350isize); - let __child = self.parse_generated_rule_193_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(46, 3353, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 3353, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3353) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(508, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(508, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3353, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3352isize); - let __child = self.parse_generated_rule_193_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(512, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(512, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - 3 => { - let __invoking_marker = self.base.push_invoking_state(3355isize); - let __child = self.parse_generated_rule_193_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(63, 3358, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 3358, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3368, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(3349isize); + let __child = self.parse_generated_rule_193_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3358) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(509, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(509, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3358, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3357isize); - let __child = self.parse_generated_rule_193_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + 2 => { + let __invoking_marker = self.base.push_invoking_state(3350isize); + let __child = self.parse_generated_rule_193_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(46, 3353, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 3353, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3353) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(508, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(508, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3353, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(3352isize); + let __child = self.parse_generated_rule_193_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - 4 => { - let __match = self.base.match_token_recovering(46, 3362, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 3362, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + 3 => { + let __invoking_marker = self.base.push_invoking_state(3355isize); + let __child = self.parse_generated_rule_193_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(63, 3358, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 3358, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3362) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(510, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(510, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3358) { __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(509, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(509, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3358, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(3357isize); + let __child = self.parse_generated_rule_193_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3362, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3361isize); - let __child = self.parse_generated_rule_193_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - } - 5 => { - let __match = self.base.match_token_recovering(63, 3366, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 3366, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + 4 => { + let __match = self.base.match_token_recovering(46, 3362, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 3362, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3366) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(511, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(511, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3362) { __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(510, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(510, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3362, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(3361isize); + let __child = self.parse_generated_rule_193_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3366, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3365isize); - let __child = self.parse_generated_rule_193_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + } + 5 => { + let __match = self.base.match_token_recovering(63, 3366, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 3366, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3366) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(511, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(511, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3366, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(3365isize); + let __child = self.parse_generated_rule_193_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_195_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(195) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_195(precedence, allow_fallback)) - } else { - self.parse_generated_rule_195(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(195); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 195, GeneratedRuleError::Fatal; self.parse_generated_rule_195(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_195(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(390isize, 195); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 18 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 3394, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 390isize, 195, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 18 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 3394, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3394) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(514, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(514, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3394) { __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(514, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(514, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3394, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3370isize); - let __child = self.parse_generated_rule_194_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(18, 3372, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(25, 3373, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3373isize); - let __child = self.parse_generated_rule_195_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 3 => { - let __invoking_marker = self.base.push_invoking_state(3374isize); - let __child = self.parse_generated_rule_194_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 25 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 88 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 89 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 90 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 91 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 92 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 93 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 51 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 95 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 96 => antlr4_runtime::ParserAtnPrediction { alt: 10, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 97 => antlr4_runtime::ParserAtnPrediction { alt: 11, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 87 => antlr4_runtime::ParserAtnPrediction { alt: 12, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 86 => antlr4_runtime::ParserAtnPrediction { alt: 13, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 3390, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3394, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(3370isize); + let __child = self.parse_generated_rule_194_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __match = self.base.match_token_recovering(18, 3372, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(25, 3373, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3373isize); + let __child = self.parse_generated_rule_195_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 3 => { + let __invoking_marker = self.base.push_invoking_state(3374isize); + let __child = self.parse_generated_rule_194_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 25 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 88 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 89 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 90 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 91 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 92 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 93 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 51 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 95 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 96 => antlr4_runtime::ParserAtnPrediction { alt: 10, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 97 => antlr4_runtime::ParserAtnPrediction { alt: 11, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 87 => antlr4_runtime::ParserAtnPrediction { alt: 12, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 86 => antlr4_runtime::ParserAtnPrediction { alt: 13, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 3390, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 25 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 88 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 89 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 90 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 91 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 92 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 93 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 51 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 95 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 96 => antlr4_runtime::ParserAtnPrediction { alt: 10, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 97 => antlr4_runtime::ParserAtnPrediction { alt: 11, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 87 => antlr4_runtime::ParserAtnPrediction { alt: 12, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 86 => antlr4_runtime::ParserAtnPrediction { alt: 13, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 25 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 88 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 89 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 90 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 91 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 92 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 93 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 51 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 95 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 96 => antlr4_runtime::ParserAtnPrediction { alt: 10, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 97 => antlr4_runtime::ParserAtnPrediction { alt: 11, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 87 => antlr4_runtime::ParserAtnPrediction { alt: 12, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 86 => antlr4_runtime::ParserAtnPrediction { alt: 13, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 3390, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(25, 3391, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + 2 => { + let __match = self.base.match_token_recovering(88, 3391, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 3 => { + let __match = self.base.match_token_recovering(89, 3391, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 4 => { + let __match = self.base.match_token_recovering(90, 3391, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 5 => { + let __match = self.base.match_token_recovering(91, 3391, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 6 => { + let __match = self.base.match_token_recovering(92, 3391, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 7 => { + let __match = self.base.match_token_recovering(93, 3391, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 8 => { + let __match = self.base.match_token_recovering(51, 3383, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(51, 3384, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(25, 3391, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 9 => { + let __match = self.base.match_token_recovering(95, 3391, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 10 => { + let __match = self.base.match_token_recovering(96, 3391, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 11 => { + let __match = self.base.match_token_recovering(97, 3391, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 12 => { + let __match = self.base.match_token_recovering(87, 3391, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 13 => { + let __match = self.base.match_token_recovering(86, 3391, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3390, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(25, 3391, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __match = self.base.match_token_recovering(88, 3391, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __match = self.base.match_token_recovering(89, 3391, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 4 => { - let __match = self.base.match_token_recovering(90, 3391, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 5 => { - let __match = self.base.match_token_recovering(91, 3391, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 6 => { - let __match = self.base.match_token_recovering(92, 3391, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 7 => { - let __match = self.base.match_token_recovering(93, 3391, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 8 => { - let __match = self.base.match_token_recovering(51, 3383, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(51, 3384, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(25, 3391, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 9 => { - let __match = self.base.match_token_recovering(95, 3391, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 10 => { - let __match = self.base.match_token_recovering(96, 3391, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 11 => { - let __match = self.base.match_token_recovering(97, 3391, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 12 => { - let __match = self.base.match_token_recovering(87, 3391, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 13 => { - let __match = self.base.match_token_recovering(86, 3391, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + let __invoking_marker = self.base.push_invoking_state(3392isize); + let __child = self.parse_generated_rule_195_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3392isize); - let __child = self.parse_generated_rule_195_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_196_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(196) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_196(precedence, allow_fallback)) - } else { - self.parse_generated_rule_196(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(196); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 196, GeneratedRuleError::Fatal; self.parse_generated_rule_196(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_196(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(392isize, 196); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_set_recovering(&[(2, 2), (21, 21), (27, 27), (40, 41), (55, 55), (69, 69), (98, 98), (102, 102), (104, 104)], 3397, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 392isize, 196, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_set_recovering(&[(2, 2), (21, 21), (27, 27), (40, 41), (55, 55), (69, 69), (98, 98), (102, 102), (104, 104)], 3397, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_197_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(197) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_197(precedence, allow_fallback)) - } else { - self.parse_generated_rule_197(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(197); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 197, GeneratedRuleError::Fatal; self.parse_generated_rule_197(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_197(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(394isize, 197); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 52 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 5 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 22 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 6 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 3404, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 394isize, 197, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 21 | 27 | 40..=41 | 55 | 69 | 98 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 52 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 5 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 22 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 6 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 3404, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3404) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(515, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(515, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3404) { __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(515, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(515, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3404, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(3398isize); + let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __match = self.base.match_token_recovering(2, 3405, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 3 => { + let __match = self.base.match_token_recovering(52, 3405, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 4 => { + let __match = self.base.match_token_recovering(5, 3405, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 5 => { + let __match = self.base.match_token_recovering(22, 3405, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 6 => { + let __match = self.base.match_token_recovering(6, 3405, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3404, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3398isize); - let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __match = self.base.match_token_recovering(2, 3405, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __match = self.base.match_token_recovering(52, 3405, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 4 => { - let __match = self.base.match_token_recovering(5, 3405, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 5 => { - let __match = self.base.match_token_recovering(22, 3405, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 6 => { - let __match = self.base.match_token_recovering(6, 3405, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_198_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(198) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_198(precedence, allow_fallback)) - } else { - self.parse_generated_rule_198(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(198); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 198, GeneratedRuleError::Fatal; self.parse_generated_rule_198(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_198(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(396isize, 198); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_not_set_recovering(&[(3, 4), (13, 14), (48, 49), (101, 101)], 1, atn().max_token_type(), 3407, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 396isize, 198, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_not_set_recovering(&[(3, 4), (13, 14), (48, 49), (101, 101)], 1, atn().max_token_type(), 3407, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_199_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(199) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_199(precedence, allow_fallback)) - } else { - self.parse_generated_rule_199(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(199); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 199, GeneratedRuleError::Fatal; self.parse_generated_rule_199(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_199(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(398isize, 199); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_not_set_recovering(&[(3, 4), (13, 15), (43, 43), (48, 49), (54, 54)], 1, atn().max_token_type(), 3409, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_200_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(200) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_200(precedence, allow_fallback)) - } else { - self.parse_generated_rule_200(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(200); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_200(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(400isize, 200); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 2 | 5..=6 | 12 | 21 | 27 | 40..=41 | 52..=53 | 55 | 69 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 3412, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3412) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(516, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(516, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3412, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3410isize); - let __child = self.parse_generated_rule_201_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(3411isize); - let __child = self.parse_generated_rule_212_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_201_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(201) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_201(precedence, allow_fallback)) - } else { - self.parse_generated_rule_201(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(201); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_201(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(402isize, 201); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_token_recovering(98, 3415, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(44, 3417, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 3417, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3417) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(517, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(517, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3417, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_not_set_recovering(&[(-1, -1)], 1, atn().max_token_type(), 3418, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(3419isize); - let __child = self.parse_generated_rule_202_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 398isize, 199, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_not_set_recovering(&[(3, 4), (13, 15), (43, 43), (48, 49), (54, 54)], 1, atn().max_token_type(), 3409, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_202_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(202) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_202(precedence, allow_fallback)) - } else { - self.parse_generated_rule_202(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(202); - __listener_result + fn parse_generated_rule_200_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 200, GeneratedRuleError::Fatal; self.parse_generated_rule_200(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_202(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_200(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(404isize, 202); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 3438, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3438, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(3, 3423, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 3423, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 3 | 13 | 48 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 3423, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3422isize); - let __child = self.parse_generated_rule_203_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __match = self.base.match_token_recovering(4, 3426, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(10, 3439, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __match = self.base.match_token_recovering(48, 3429, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 3429, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 3 | 13 | 48 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 3429, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3428isize); - let __child = self.parse_generated_rule_203_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 400isize, 200, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 2 | 5..=6 | 12 | 21 | 27 | 40..=41 | 52..=53 | 55 | 69 | 102 | 104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 3412, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3412) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(516, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(516, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - let __match = self.base.match_token_recovering(49, 3432, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(10, 3439, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __match = self.base.match_token_recovering(13, 3435, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 3435, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3412, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(3410isize); + let __child = self.parse_generated_rule_201_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 3 | 13 | 48 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 3435, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3434isize); - let __child = self.parse_generated_rule_203_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + 2 => { + let __invoking_marker = self.base.push_invoking_state(3411isize); + let __child = self.parse_generated_rule_212_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(14, 3439, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_203_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_201_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(203) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_203(precedence, allow_fallback)) - } else { - self.parse_generated_rule_203(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(203); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 201, GeneratedRuleError::Fatal; self.parse_generated_rule_201(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_203(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_201(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(406isize, 203); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(3440isize); - let __child = self.parse_generated_rule_204_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_3445 = false; - loop { - match self.base.sync_decision(atn(), 3445, !__ctx.has_matched_child(), __loop_iter_3445) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 402isize, 201, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_token_recovering(98, 3415, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(44, 3417, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 3417, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -50583,12 +43630,12 @@ where } } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3445) { + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3417) { __prediction } else { let __prediction = { let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(522, 0, self.base.input()) + __simulator.adaptive_predict_stream_info_sll_probe(517, 0, self.base.input()) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -50598,7 +43645,7 @@ where let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(522, 0, self.base.input(), __prediction_context) + __simulator.adaptive_predict_stream_info_with_context(517, 0, self.base.input(), __prediction_context) .map_err(|__error| match __error { antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), _ => self.base.no_viable_alternative_error(__decision_start), @@ -50607,205 +43654,74 @@ where __prediction } }; - self.base.record_generated_prediction_diagnostic(atn(), 3445, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 3417, &__prediction); match __prediction.alt { 1 => { - __loop_iter_3445 = true; - let __match = self.base.match_token_recovering(10, 3442, atn())?; + let __match = self.base.match_not_set_recovering(&[(-1, -1)], 1, atn().max_token_type(), 3418, atn())?; __consumed_eof |= __match.consumed_eof(); for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3442isize); - let __child = self.parse_generated_rule_204_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __invoking_marker = self.base.push_invoking_state(3419isize); + let __child = self.parse_generated_rule_202_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 3449, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 10 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 | 14 | 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - }; - self.base.record_generated_prediction_diagnostic(atn(), 3449, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(10, 3450, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_204_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(204) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_204(precedence, allow_fallback)) - } else { - self.parse_generated_rule_204(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(204); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_204(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(408isize, 204); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(3451isize); - let __child = self.parse_generated_rule_205_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(72, 3453, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3453isize); - let __child = self.parse_generated_rule_210_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + success {} + recovery {} } } #[allow(dead_code)] - fn parse_generated_rule_205_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_202_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(205) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_205(precedence, allow_fallback)) - } else { - self.parse_generated_rule_205(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(205); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 202, GeneratedRuleError::Fatal; self.parse_generated_rule_202(precedence, allow_fallback) } } #[allow(dead_code)] - fn parse_generated_rule_205(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + fn parse_generated_rule_202(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(410isize, 205); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 3479, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 404isize, 202, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 3438, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3479, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(3, 3459, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_3459 = false; - loop { - match self.base.sync_decision(atn(), 3459, !__ctx.has_matched_child(), __loop_iter_3459) { + }; + self.base.record_generated_prediction_diagnostic(atn(), 3438, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(3, 3423, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 3423, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -50816,37 +43732,35 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 3 | 13 | 48 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 3459, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 3423, &__prediction); match __prediction.alt { 1 => { - __loop_iter_3459 = true; - let __invoking_marker = self.base.push_invoking_state(3456isize); - let __child = self.parse_generated_rule_206_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(3422isize); + let __child = self.parse_generated_rule_203_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(4, 3426, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(10, 3439, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __match = self.base.match_token_recovering(4, 3480, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __match = self.base.match_token_recovering(48, 3467, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_3467 = false; - loop { - match self.base.sync_decision(atn(), 3467, !__ctx.has_matched_child(), __loop_iter_3467) { + 2 => { + let __match = self.base.match_token_recovering(48, 3429, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 3429, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -50857,37 +43771,35 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 3 | 13 | 48 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 3467, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 3429, &__prediction); match __prediction.alt { 1 => { - __loop_iter_3467 = true; - let __invoking_marker = self.base.push_invoking_state(3464isize); - let __child = self.parse_generated_rule_206_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(3428isize); + let __child = self.parse_generated_rule_203_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(49, 3432, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(10, 3439, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __match = self.base.match_token_recovering(49, 3480, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __match = self.base.match_token_recovering(13, 3475, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_3475 = false; - loop { - match self.base.sync_decision(atn(), 3475, !__ctx.has_matched_child(), __loop_iter_3475) { + 3 => { + let __match = self.base.match_token_recovering(13, 3435, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 3435, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -50898,174 +43810,485 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 3 | 13 | 48 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 3475, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 3435, &__prediction); match __prediction.alt { 1 => { - __loop_iter_3475 = true; - let __invoking_marker = self.base.push_invoking_state(3472isize); - let __child = self.parse_generated_rule_206_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(3434isize); + let __child = self.parse_generated_rule_203_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } - 2 => { - break; + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + let __match = self.base.match_token_recovering(14, 3439, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_203_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 203, GeneratedRuleError::Fatal; self.parse_generated_rule_203(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_203(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 406isize, 203, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(3440isize); + let __child = self.parse_generated_rule_204_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_3445 = false; + loop { + match self.base.sync_decision(atn(), 3445, !__ctx.has_matched_child(), __loop_iter_3445) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3445) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(522, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(522, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3445, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_3445 = true; + let __match = self.base.match_token_recovering(10, 3442, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3442isize); + let __child = self.parse_generated_rule_204_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + match self.base.sync_decision(atn(), 3449, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 10 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 | 14 | 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + }; + self.base.record_generated_prediction_diagnostic(atn(), 3449, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(10, 3450, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_204_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 204, GeneratedRuleError::Fatal; self.parse_generated_rule_204(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_204(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 408isize, 204, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(3451isize); + let __child = self.parse_generated_rule_205_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(72, 3453, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3453isize); + let __child = self.parse_generated_rule_210_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_205_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 205, GeneratedRuleError::Fatal; self.parse_generated_rule_205(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_205(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 410isize, 205, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 3479, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3479, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(3, 3459, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_3459 = false; + loop { + match self.base.sync_decision(atn(), 3459, !__ctx.has_matched_child(), __loop_iter_3459) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 3459, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_3459 = true; + let __invoking_marker = self.base.push_invoking_state(3456isize); + let __child = self.parse_generated_rule_206_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __match = self.base.match_token_recovering(4, 3480, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 2 => { + let __match = self.base.match_token_recovering(48, 3467, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_3467 = false; + loop { + match self.base.sync_decision(atn(), 3467, !__ctx.has_matched_child(), __loop_iter_3467) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 3467, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_3467 = true; + let __invoking_marker = self.base.push_invoking_state(3464isize); + let __child = self.parse_generated_rule_206_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __match = self.base.match_token_recovering(49, 3480, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 3 => { + let __match = self.base.match_token_recovering(13, 3475, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_3475 = false; + loop { + match self.base.sync_decision(atn(), 3475, !__ctx.has_matched_child(), __loop_iter_3475) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 3475, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_3475 = true; + let __invoking_marker = self.base.push_invoking_state(3472isize); + let __child = self.parse_generated_rule_206_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + let __match = self.base.match_token_recovering(14, 3480, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + } + } + success {} + recovery {} + } + } + + #[allow(dead_code)] + fn parse_generated_rule_206_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { + let _ = precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 206, GeneratedRuleError::Fatal; self.parse_generated_rule_206(precedence, allow_fallback) } + } + + #[allow(dead_code)] + fn parse_generated_rule_206(&mut self, __precedence: i32, allow_fallback: bool) -> Result { + let _ = __precedence; + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 412isize, 206, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1..=2 | 5..=12 | 15..=47 | 50..=100 | 102..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 3 | 13 | 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 3500, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3500) { + __prediction + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(530, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(530, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction + } + } + } + }; + self.base.record_generated_prediction_diagnostic(atn(), 3500, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(3481isize); + let __child = self.parse_generated_rule_198_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + let __invoking_marker = self.base.push_invoking_state(3482isize); + let __child = self.parse_generated_rule_205_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 3 => { + let __match = self.base.match_token_recovering(101, 3484, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_not_set_recovering(&[(-1, -1)], 1, atn().max_token_type(), 3485, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(24, 3486, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3486isize); + let __child = self.parse_generated_rule_207_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 4 => { + let __match = self.base.match_token_recovering(101, 3488, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(3, 3490, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3489isize); + let __child = self.parse_generated_rule_206_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let mut __loop_iter_3492 = true; + loop { + match self.base.sync_decision(atn(), 3492, !__ctx.has_matched_child(), __loop_iter_3492) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } + } + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 3492, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_3492 = true; + let __invoking_marker = self.base.push_invoking_state(3489isize); + let __child = self.parse_generated_rule_206_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - let __match = self.base.match_token_recovering(14, 3480, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - } - } - - #[allow(dead_code)] - fn parse_generated_rule_206_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { - let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(206) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_206(precedence, allow_fallback)) - } else { - self.parse_generated_rule_206(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(206); - __listener_result - } - - #[allow(dead_code)] - fn parse_generated_rule_206(&mut self, __precedence: i32, allow_fallback: bool) -> Result { - let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(412isize, 206); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 1..=2 | 5..=12 | 15..=47 | 50..=100 | 102..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 3 | 13 | 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 3500, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3500) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(530, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(530, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { - __prediction } - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3500, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3481isize); - let __child = self.parse_generated_rule_198_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(3482isize); - let __child = self.parse_generated_rule_205_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 3 => { - let __match = self.base.match_token_recovering(101, 3484, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_not_set_recovering(&[(-1, -1)], 1, atn().max_token_type(), 3485, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(24, 3486, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3486isize); - let __child = self.parse_generated_rule_207_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 4 => { - let __match = self.base.match_token_recovering(101, 3488, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(3, 3490, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3489isize); - let __child = self.parse_generated_rule_206_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let mut __loop_iter_3492 = true; - loop { - match self.base.sync_decision(atn(), 3492, !__ctx.has_matched_child(), __loop_iter_3492) { + let __match = self.base.match_token_recovering(4, 3496, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + match self.base.sync_decision(atn(), 3496, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -51076,384 +44299,159 @@ where } let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); let __prediction = match self.base.la(1) { - 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 1..=2 | 5..=12 | 16..=42 | 44..=47 | 50..=53 | 55..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 15 | 43 | 54 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), }; - self.base.record_generated_prediction_diagnostic(atn(), 3492, &__prediction); + self.base.record_generated_prediction_diagnostic(atn(), 3496, &__prediction); match __prediction.alt { 1 => { - __loop_iter_3492 = true; - let __invoking_marker = self.base.push_invoking_state(3489isize); - let __child = self.parse_generated_rule_206_dispatch(0, false).map_err(GeneratedRuleError::into_error); + let __invoking_marker = self.base.push_invoking_state(3495isize); + let __child = self.parse_generated_rule_208_dispatch(0, false).map_err(GeneratedRuleError::into_error); self.base.discard_invoking_state(__invoking_marker); let __child = __child?; self.base.add_parse_child(&mut __ctx, __child); } 2 => { - break; } _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __invoking_marker = self.base.push_invoking_state(3498isize); + let __child = self.parse_generated_rule_209_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(4, 3496, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - match self.base.sync_decision(atn(), 3496, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 1..=2 | 5..=12 | 16..=42 | 44..=47 | 50..=53 | 55..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 15 | 43 | 54 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 3496, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3495isize); - let __child = self.parse_generated_rule_208_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - let __invoking_marker = self.base.push_invoking_state(3498isize); - let __child = self.parse_generated_rule_209_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_207_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(207) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_207(precedence, allow_fallback)) - } else { - self.parse_generated_rule_207(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(207); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 207, GeneratedRuleError::Fatal; self.parse_generated_rule_207(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_207(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(414isize, 207); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_not_set_recovering(&[(-1, -1)], 1, atn().max_token_type(), 3503, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 414isize, 207, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_not_set_recovering(&[(-1, -1)], 1, atn().max_token_type(), 3503, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_208_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(208) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_208(precedence, allow_fallback)) - } else { - self.parse_generated_rule_208(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(208); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 208, GeneratedRuleError::Fatal; self.parse_generated_rule_208(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_208(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(416isize, 208); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(3504isize); - let __child = self.parse_generated_rule_199_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 416isize, 208, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(3504isize); + let __child = self.parse_generated_rule_199_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_209_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(209) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_209(precedence, allow_fallback)) - } else { - self.parse_generated_rule_209(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(209); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 209, GeneratedRuleError::Fatal; self.parse_generated_rule_209(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_209(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(418isize, 209); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_set_recovering(&[(15, 15), (43, 43), (54, 54)], 3507, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 418isize, 209, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_set_recovering(&[(15, 15), (43, 43), (54, 54)], 3507, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_210_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(210) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_210(precedence, allow_fallback)) - } else { - self.parse_generated_rule_210(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(210); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 210, GeneratedRuleError::Fatal; self.parse_generated_rule_210(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_210(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(420isize, 210); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(3508isize); - let __child = self.parse_generated_rule_211_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 420isize, 210, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(3508isize); + let __child = self.parse_generated_rule_211_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_211_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(211) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_211(precedence, allow_fallback)) - } else { - self.parse_generated_rule_211(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(211); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 211, GeneratedRuleError::Fatal; self.parse_generated_rule_211(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_211(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(422isize, 211); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => { - match self.base.sync_decision(atn(), 3534, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - match self.base.la(1) { - 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 13 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3534, &__prediction); - match __prediction.alt { - 1 => { - let __match = self.base.match_token_recovering(3, 3514, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_3514 = false; - loop { - match self.base.sync_decision(atn(), 3514, !__ctx.has_matched_child(), __loop_iter_3514) { + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 422isize, 211, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => { + match self.base.sync_decision(atn(), 3534, !__ctx.has_matched_child(), false) { Ok(__sync_children) => { for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } } @@ -51462,508 +44460,415 @@ where return Err(__error); } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 3514, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_3514 = true; - let __invoking_marker = self.base.push_invoking_state(3511isize); - let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } + __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + match self.base.la(1) { + 3 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 48 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 13 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None }, _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __match = self.base.match_token_recovering(4, 3535, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __match = self.base.match_token_recovering(48, 3522, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_3522 = false; - loop { - match self.base.sync_decision(atn(), 3522, !__ctx.has_matched_child(), __loop_iter_3522) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 3522, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_3522 = true; - let __invoking_marker = self.base.push_invoking_state(3519isize); - let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + }; + self.base.record_generated_prediction_diagnostic(atn(), 3534, &__prediction); + match __prediction.alt { + 1 => { + let __match = self.base.match_token_recovering(3, 3514, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_3514 = false; + loop { + match self.base.sync_decision(atn(), 3514, !__ctx.has_matched_child(), __loop_iter_3514) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { - break; + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 3514, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_3514 = true; + let __invoking_marker = self.base.push_invoking_state(3511isize); + let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(4, 3535, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __match = self.base.match_token_recovering(49, 3535, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __match = self.base.match_token_recovering(13, 3530, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_3530 = false; - loop { - match self.base.sync_decision(atn(), 3530, !__ctx.has_matched_child(), __loop_iter_3530) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + 2 => { + let __match = self.base.match_token_recovering(48, 3522, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_3522 = false; + loop { + match self.base.sync_decision(atn(), 3522, !__ctx.has_matched_child(), __loop_iter_3522) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 3522, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_3522 = true; + let __invoking_marker = self.base.push_invoking_state(3519isize); + let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 3530, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_3530 = true; - let __invoking_marker = self.base.push_invoking_state(3527isize); - let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(49, 3535, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 3 => { + let __match = self.base.match_token_recovering(13, 3530, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_3530 = false; + loop { + match self.base.sync_decision(atn(), 3530, !__ctx.has_matched_child(), __loop_iter_3530) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { - break; + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 3530, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_3530 = true; + let __invoking_marker = self.base.push_invoking_state(3527isize); + let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(14, 3535, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __match = self.base.match_token_recovering(14, 3535, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_212_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(212) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_212(precedence, allow_fallback)) - } else { - self.parse_generated_rule_212(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(212); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 212, GeneratedRuleError::Fatal; self.parse_generated_rule_212(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_212(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(424isize, 212); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - match self.base.sync_decision(atn(), 3571, !__ctx.has_matched_child(), false) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 424isize, 212, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + match self.base.sync_decision(atn(), 3571, !__ctx.has_matched_child(), false) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3571) { - __prediction - } else { - let __prediction = { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - __simulator.adaptive_predict_stream_info_sll_probe(538, 0, self.base.input()) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - }; - if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { - let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); - let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); - __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); - __simulator.adaptive_predict_stream_info_with_context(538, 0, self.base.input(), __prediction_context) - .map_err(|__error| match __error { - antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), - _ => self.base.no_viable_alternative_error(__decision_start), - })? - } else { + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3571) { __prediction - } - }; - self.base.record_generated_prediction_diagnostic(atn(), 3571, &__prediction); - match __prediction.alt { - 1 => { - let __invoking_marker = self.base.push_invoking_state(3536isize); - let __child = self.parse_generated_rule_79_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(44, 3538, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(3, 3542, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_3542 = false; - loop { - match self.base.sync_decision(atn(), 3542, !__ctx.has_matched_child(), __loop_iter_3542) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 3542, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_3542 = true; - let __invoking_marker = self.base.push_invoking_state(3539isize); - let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - } - 2 => { - break; - } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } + } else { + let __prediction = { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + __simulator.adaptive_predict_stream_info_sll_probe(538, 0, self.base.input()) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + }; + if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll { + let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn())); + let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn())); + __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection); + __simulator.adaptive_predict_stream_info_with_context(538, 0, self.base.input(), __prediction_context) + .map_err(|__error| match __error { + antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index), + _ => self.base.no_viable_alternative_error(__decision_start), + })? + } else { + __prediction } - let __match = self.base.match_token_recovering(4, 3546, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(10, 3547, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 2 => { - let __invoking_marker = self.base.push_invoking_state(3548isize); - let __child = self.parse_generated_rule_79_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(44, 3550, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(48, 3554, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_3554 = false; - loop { - match self.base.sync_decision(atn(), 3554, !__ctx.has_matched_child(), __loop_iter_3554) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } - } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); - } - } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 3554, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_3554 = true; - let __invoking_marker = self.base.push_invoking_state(3551isize); - let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + }; + self.base.record_generated_prediction_diagnostic(atn(), 3571, &__prediction); + match __prediction.alt { + 1 => { + let __invoking_marker = self.base.push_invoking_state(3536isize); + let __child = self.parse_generated_rule_79_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(44, 3538, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(3, 3542, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_3542 = false; + loop { + match self.base.sync_decision(atn(), 3542, !__ctx.has_matched_child(), __loop_iter_3542) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { - break; + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 4 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 3542, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_3542 = true; + let __invoking_marker = self.base.push_invoking_state(3539isize); + let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(4, 3546, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(10, 3547, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __match = self.base.match_token_recovering(49, 3558, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(10, 3559, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - } - 3 => { - let __invoking_marker = self.base.push_invoking_state(3560isize); - let __child = self.parse_generated_rule_79_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(44, 3562, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __match = self.base.match_token_recovering(13, 3566, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let mut __loop_iter_3566 = false; - loop { - match self.base.sync_decision(atn(), 3566, !__ctx.has_matched_child(), __loop_iter_3566) { - Ok(__sync_children) => { - for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + 2 => { + let __invoking_marker = self.base.push_invoking_state(3548isize); + let __child = self.parse_generated_rule_79_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(44, 3550, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(48, 3554, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_3554 = false; + loop { + match self.base.sync_decision(atn(), 3554, !__ctx.has_matched_child(), __loop_iter_3554) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - Err(__error) => { - __sync_error = Some(__error.clone()); - return Err(__error); + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 3554, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_3554 = true; + let __invoking_marker = self.base.push_invoking_state(3551isize); + let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } } - let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); - let __prediction = match self.base.la(1) { - 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - }; - self.base.record_generated_prediction_diagnostic(atn(), 3566, &__prediction); - match __prediction.alt { - 1 => { - __loop_iter_3566 = true; - let __invoking_marker = self.base.push_invoking_state(3563isize); - let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(49, 3558, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(10, 3559, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + 3 => { + let __invoking_marker = self.base.push_invoking_state(3560isize); + let __child = self.parse_generated_rule_79_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(44, 3562, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __match = self.base.match_token_recovering(13, 3566, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let mut __loop_iter_3566 = false; + loop { + match self.base.sync_decision(atn(), 3566, !__ctx.has_matched_child(), __loop_iter_3566) { + Ok(__sync_children) => { + for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); } + } + Err(__error) => { + __sync_error = Some(__error.clone()); + return Err(__error); + } } - 2 => { - break; + let __decision_start = antlr4_runtime::IntStream::index(self.base.input()); + let __prediction = match self.base.la(1) { + 1..=3 | 5..=13 | 15..=48 | 50..=117 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + 14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None }, + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), + }; + self.base.record_generated_prediction_diagnostic(atn(), 3566, &__prediction); + match __prediction.alt { + 1 => { + __loop_iter_3566 = true; + let __invoking_marker = self.base.push_invoking_state(3563isize); + let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + 2 => { + break; + } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } + let __match = self.base.match_token_recovering(14, 3570, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } } - let __match = self.base.match_token_recovering(14, 3570, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + _ => return Err(self.base.no_viable_alternative_error(__decision_start)), } - _ => return Err(self.base.no_viable_alternative_error(__decision_start)), - } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_213_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(213) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_213(precedence, allow_fallback)) - } else { - self.parse_generated_rule_213(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(213); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 213, GeneratedRuleError::Fatal; self.parse_generated_rule_213(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_213(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(426isize, 213); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __invoking_marker = self.base.push_invoking_state(3573isize); - let __child = self.parse_generated_rule_79_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - let __match = self.base.match_token_recovering(44, 3575, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - let __invoking_marker = self.base.push_invoking_state(3575isize); - let __child = self.parse_generated_rule_211_dispatch(0, false).map_err(GeneratedRuleError::into_error); - self.base.discard_invoking_state(__invoking_marker); - let __child = __child?; - self.base.add_parse_child(&mut __ctx, __child); - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 426isize, 213, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __invoking_marker = self.base.push_invoking_state(3573isize); + let __child = self.parse_generated_rule_79_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + let __match = self.base.match_token_recovering(44, 3575, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + let __invoking_marker = self.base.push_invoking_state(3575isize); + let __child = self.parse_generated_rule_211_dispatch(0, false).map_err(GeneratedRuleError::into_error); + self.base.discard_invoking_state(__invoking_marker); + let __child = __child?; + self.base.add_parse_child(&mut __ctx, __child); + } + success {} + recovery {} } } #[allow(dead_code)] fn parse_generated_rule_214_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result { let _ = precedence; - if let Some(error) = self.base.rule_depth_cap_violation() { - return Err(GeneratedRuleError::Fatal(error)); - } - if let Some(error) = self.base.parse_listener_enter_rule(214) { - return Err(GeneratedRuleError::Fatal(error)); - } - let __listener_result = if self.base.generated_rule_stack_check_due() { - antlr4_runtime::grow_generated_rule_stack(|| self.parse_generated_rule_214(precedence, allow_fallback)) - } else { - self.parse_generated_rule_214(precedence, allow_fallback) - }; - self.base.parse_listener_exit_rule(214); - __listener_result + antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 214, GeneratedRuleError::Fatal; self.parse_generated_rule_214(precedence, allow_fallback) } } #[allow(dead_code)] fn parse_generated_rule_214(&mut self, __precedence: i32, allow_fallback: bool) -> Result { let _ = __precedence; - let _ = allow_fallback; - let __generated_diagnostic_marker = self.base.generated_diagnostics_checkpoint(); - let mut __ctx = self.base.enter_rule(428isize, 214); - let __rule_start = antlr4_runtime::IntStream::index(self.base.input()); - let mut __consumed_eof = false; - let mut __sync_error: Option = None; - let __result = (|| -> Result<(), antlr4_runtime::AntlrError> { - let __match = self.base.match_set_recovering(&[(99, 100), (103, 103)], 3578, atn())?; - __consumed_eof |= __match.consumed_eof(); - for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } - Ok(()) - })(); - match __result { - Ok(()) => { - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } - Err(__error) => { - if let Some(__error) = __sync_error { - if allow_fallback { - self.base.exit_rule(); - self.base.rollback_generated_tree(__generated_diagnostic_marker); - self.base.record_generated_syntax_error(); - return Err(GeneratedRuleError::Fatal(__error)); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - return Ok(__tree); - } - self.base.recover_generated_rule(&mut __ctx, atn(), __error); - let __tree = self.base.finish_rule(__ctx, __consumed_eof); - Ok(__tree) - } + antlr4_runtime::__antlr4_rust_generated_rule! { + ordinary self, 428isize, 214, allow_fallback, atn(), GeneratedRuleError::Fatal; + retry [none]; + bind (__ctx, __rule_start, __consumed_eof, __sync_error); + setup {} + body { + let __match = self.base.match_set_recovering(&[(99, 100), (103, 103)], 3578, atn())?; + __consumed_eof |= __match.consumed_eof(); + for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); } + } + success {} + recovery {} } } diff --git a/crates/antlr-rust-runtime/src/lib.rs b/crates/antlr-rust-runtime/src/lib.rs index 6521798b..8b870884 100644 --- a/crates/antlr-rust-runtime/src/lib.rs +++ b/crates/antlr-rust-runtime/src/lib.rs @@ -4,7 +4,7 @@ extern crate self as antlr4_runtime; /// Current generated-source/runtime contract revision emitted by the bundled generator. #[doc(hidden)] -pub const __ANTLR4_RUST_CODEGEN_API: u32 = 5; +pub const __ANTLR4_RUST_CODEGEN_API: u32 = 6; /// Verifies that generated source is compatible with the selected runtime. #[doc(hidden)] @@ -15,13 +15,14 @@ macro_rules! __antlr4_rust_require_codegen_api { (3, $generator_version:literal) => {}; (4, $generator_version:literal) => {}; (5, $generator_version:literal) => {}; + (6, $generator_version:literal) => {}; ($requested:literal, $generator_version:literal) => { compile_error!(concat!( "antlr4-rust generated-code API mismatch: antlr4-rust-gen v", $generator_version, " emitted generated-code API revision ", stringify!($requested), - ", but the selected antlr-rust-runtime supports revisions 1, 2, 3, 4, and 5; regenerate \ + ", but the selected antlr-rust-runtime supports revisions 1, 2, 3, 4, 5, and 6; regenerate \ this recognizer with a compatible antlr4-rust-gen or select a compatible \ antlr-rust-runtime dependency" )); diff --git a/crates/antlr-rust-runtime/src/parser.rs b/crates/antlr-rust-runtime/src/parser.rs index 3a43c865..29d523b2 100644 --- a/crates/antlr-rust-runtime/src/parser.rs +++ b/crates/antlr-rust-runtime/src/parser.rs @@ -131,6 +131,172 @@ pub fn grow_generated_rule_stack(body: impl FnOnce() -> R) -> R { stacker::maybe_grow(FAST_RECOGNIZE_RED_ZONE, FAST_RECOGNIZE_STACK_SIZE, body) } +/// Shared lifecycle and recovery shell for generated parser rules. +/// +/// This is an implementation detail of `antlr4-rust-gen`, not a stable +/// hand-written parser API. The binders supplied by generated code keep +/// grammar-specific locals and steps inline while this macro owns the fixed +/// dispatch, entry, recovery, and exit state machine. +#[doc(hidden)] +#[macro_export] +macro_rules! __antlr4_rust_generated_rule { + ( + dispatch $parser:ident, $rule:expr, $fatal:path; + $body:expr + ) => {{ + if let Some(error) = $parser.base.rule_depth_cap_violation() { + return Err($fatal(error)); + } + if let Some(error) = $parser.base.parse_listener_enter_rule($rule) { + return Err($fatal(error)); + } + let __listener_result = if $parser.base.generated_rule_stack_check_due() { + $crate::grow_generated_rule_stack(|| $body) + } else { + $body + }; + $parser.base.parse_listener_exit_rule($rule); + __listener_result + }}; + ( + ordinary $parser:ident, $state:expr, $rule:expr, $allow_fallback:expr, + $atn:expr, $fatal:path; + retry [$($retry:tt)*]; + bind ($ctx:ident, $rule_start:ident, $consumed_eof:ident, $sync_error:ident); + setup { $($setup:tt)* } + body { $($body:tt)* } + success { $($success:tt)* } + recovery { $($recovery:tt)* } + ) => { + $crate::__antlr4_rust_generated_rule! { + @body + parser $parser; + enter $parser.base.enter_rule($state, $rule); + finish finish_rule; + abort exit_rule; + allow_fallback $allow_fallback; + atn $atn; + fatal $fatal; + retry [$($retry)*]; + bind ($ctx, $rule_start, $consumed_eof, $sync_error); + setup { $($setup)* } + body { $($body)* } + success { $($success)* } + recovery { $($recovery)* } + } + }; + ( + recursive $parser:ident, $state:expr, $rule:expr, $precedence:expr, + $allow_fallback:expr, $atn:expr, $fatal:path; + retry [$($retry:tt)*]; + bind ($ctx:ident, $rule_start:ident, $consumed_eof:ident, $sync_error:ident); + setup { $($setup:tt)* } + body { $($body:tt)* } + success { $($success:tt)* } + recovery { $($recovery:tt)* } + ) => { + $crate::__antlr4_rust_generated_rule! { + @body + parser $parser; + enter $parser.base.enter_recursion_rule($state, $rule, $precedence); + finish finish_recursion_rule; + abort unroll_recursion_context; + allow_fallback $allow_fallback; + atn $atn; + fatal $fatal; + retry [$($retry)*]; + bind ($ctx, $rule_start, $consumed_eof, $sync_error); + setup { $($setup)* } + body { $($body)* } + success { $($success)* } + recovery { $($recovery)* } + } + }; + ( + @body + parser $parser:ident; + enter $enter:expr; + finish $finish:ident; + abort $abort:ident; + allow_fallback $allow_fallback:expr; + atn $atn:expr; + fatal $fatal:path; + retry [$($retry:tt)*]; + bind ($ctx:ident, $rule_start:ident, $consumed_eof:ident, $sync_error:ident); + setup { $($setup:tt)* } + body { $($body:tt)* } + success { $($success:tt)* } + recovery { $($recovery:tt)* } + ) => {{ + let __generated_diagnostic_marker = + $parser.base.generated_diagnostics_checkpoint(); + let mut $ctx = $enter; + let $rule_start = $crate::IntStream::index($parser.base.input()); + $($setup)* + let mut $consumed_eof = false; + let mut $sync_error: Option<$crate::AntlrError> = None; + let __result = (|| -> Result<(), $crate::AntlrError> { + $($body)* + Ok(()) + })(); + match __result { + Ok(()) => { + $($success)* + let __tree = $parser.base.$finish($ctx, $consumed_eof); + Ok(__tree) + } + Err(__error) => { + $crate::__antlr4_rust_generated_rule! { + @retry + [$($retry)*] + parser $parser; + marker __generated_diagnostic_marker; + abort $abort; + } + let __error = if let Some(__sync_error) = $sync_error { + if $allow_fallback { + $parser.base.$abort(); + $parser + .base + .rollback_generated_tree(__generated_diagnostic_marker); + $parser.base.record_generated_syntax_error(); + return Err($fatal(__sync_error)); + } + __sync_error + } else { + __error + }; + $parser + .base + .recover_generated_rule(&mut $ctx, $atn, __error); + $($recovery)* + let __tree = $parser.base.$finish($ctx, $consumed_eof); + Ok(__tree) + } + } + }}; + ( + @retry + [none] + parser $parser:ident; + marker $marker:ident; + abort $abort:ident; + ) => {}; + ( + @retry + [$condition:expr => $retry_error:expr] + parser $parser:ident; + marker $marker:ident; + abort $abort:ident; + ) => { + if $condition { + $parser.base.$abort(); + $parser.base.restore_generated_diagnostics($marker); + return Err($retry_error); + } + }; +} + /// Receives committed rule enter/exit events during recognition, matching /// ANTLR's `addParseListener` contract ([`Parser::add_parse_listener`], /// also inherent on [`BaseParser`] and generated parsers). diff --git a/crates/antlr-rust-runtime/src/xpath/generated/x_path_lexer.rs b/crates/antlr-rust-runtime/src/xpath/generated/x_path_lexer.rs index 80cb8004..b82779f6 100644 --- a/crates/antlr-rust-runtime/src/xpath/generated/x_path_lexer.rs +++ b/crates/antlr-rust-runtime/src/xpath/generated/x_path_lexer.rs @@ -1,6 +1,6 @@ // @generated by antlr-rust-codegen v0.28.0 - do not edit // project: https://github.com/ophi-dev/antlr-rust-runtime -antlr4_runtime::__antlr4_rust_require_codegen_api!(5, "0.28.0"); +antlr4_runtime::__antlr4_rust_require_codegen_api!(6, "0.28.0"); #[allow(warnings, missing_docs, clippy::all, clippy::pedantic, clippy::nursery)] #[rustfmt::skip] mod __antlr4_rust_generated { diff --git a/docs/migration.md b/docs/migration.md index d9bc7930..4d677e99 100644 --- a/docs/migration.md +++ b/docs/migration.md @@ -7,9 +7,9 @@ generated-code API revision that is checked against the selected runtime at compile time, so releases that deliberately preserve the source contract can remain compatible without exact SemVer equality. -The current generator emits revision 5 so generated lexer and parser facades -can use runtime-owned support macros. This runtime continues to accept -revisions 1 through 4 because their required APIs remain supported. +The current generator emits revision 6 so generated parser rules can use the +runtime-owned lifecycle and recovery contract. This runtime continues to +accept revisions 1 through 5 because their required APIs remain supported. Generated modules created before the compatibility check was introduced carry no enforceable revision. Regenerate every committed lexer and parser once when diff --git a/third_party/antlr-v4-grammar/self-hosted.sha256 b/third_party/antlr-v4-grammar/self-hosted.sha256 index 71b158cb..8ade0a03 100644 --- a/third_party/antlr-v4-grammar/self-hosted.sha256 +++ b/third_party/antlr-v4-grammar/self-hosted.sha256 @@ -2,5 +2,5 @@ 1286e542499e4480b3ab5ff60e4a4a7faf21134ca4c4f8f1f468f30095fa25cb third_party/antlr-v4-grammar/ANTLRv4Parser.g4 c7114545a75ab294215819962e92e570383dc830fd5768463dab04e6733bcb80 third_party/antlr-v4-grammar/predefined.tokens 5803594bd2c8dd2d5180f1ca08fc70dfc80308479d18a7c4a1b743fa523b55ec third_party/antlr-v4-grammar/antlr-v4.toml -35547e3a2a01478d72249dfc22b1645992d115e75e40823f83f04bfcf95b7edf crates/antlr-rust-g4-parser/src/generated/antlr_v4_lexer.rs -eead8fa8c521ad69c050b0e019438bb34c287ee540e28fc3442d2d703b3cc432 crates/antlr-rust-g4-parser/src/generated/antlr_v4_parser.rs +2d58d0093ecc504b086b0ba3e6b42fcda9b58988d97759732a4851c4e64a876e crates/antlr-rust-g4-parser/src/generated/antlr_v4_lexer.rs +2ec52bfe99c6529406c854b4b906510e11b9a31722a917f78bb0084a03ccb3e3 crates/antlr-rust-g4-parser/src/generated/antlr_v4_parser.rs From 958099045ed6196c587f0825682f4f95cdfbeb72 Mon Sep 17 00:00:00 2001 From: Konstantin Vyatkin Date: Tue, 4 Aug 2026 23:27:40 +0200 Subject: [PATCH 2/2] test(codegen): tighten lifecycle assertions Anchor the init-order check on its surrounding lifecycle sections, require the deep-nesting fixture to emit the dispatch arm that owns stack growth, and document the generated body Result boundary. --- crates/antlr-rust-codegen/src/generator/tests.rs | 13 +++++++------ .../tests/antlr4_rust_gen_cli/parser.rs | 4 ++-- crates/antlr-rust-runtime/src/parser.rs | 2 ++ 3 files changed, 11 insertions(+), 8 deletions(-) diff --git a/crates/antlr-rust-codegen/src/generator/tests.rs b/crates/antlr-rust-codegen/src/generator/tests.rs index 2edcac9a..afbda5d5 100644 --- a/crates/antlr-rust-codegen/src/generator/tests.rs +++ b/crates/antlr-rust-codegen/src/generator/tests.rs @@ -1694,15 +1694,16 @@ fn embedded_init_action_runs_at_rule_entry() { ) .expect("embedded parser should render"); - let setup_at = rendered - .find("setup {") - .expect("generated rule declares setup section"); let init_at = rendered .find("println!(\"init\");") .expect("embedded @init body is emitted"); - let body_at = rendered - .find("body {") - .expect("generated rule body follows entry setup"); + let setup_at = rendered[..init_at] + .rfind("setup {") + .expect("generated rule declares setup section"); + let body_at = init_at + + rendered[init_at..] + .find("body {") + .expect("generated rule body follows entry setup"); assert!( setup_at < init_at && init_at < body_at, diff --git a/crates/antlr-rust-codegen/tests/antlr4_rust_gen_cli/parser.rs b/crates/antlr-rust-codegen/tests/antlr4_rust_gen_cli/parser.rs index 3f6379f7..33ff1a33 100644 --- a/crates/antlr-rust-codegen/tests/antlr4_rust_gen_cli/parser.rs +++ b/crates/antlr-rust-codegen/tests/antlr4_rust_gen_cli/parser.rs @@ -158,8 +158,8 @@ fn deeply_nested_input_parses_without_native_stack_overflow() { // the 10,000-level parse below proves its segmented-stack guard is active. let parser = fs::read_to_string(out.join("nest_parser.rs")).expect("parser should be emitted"); assert!( - parser.contains("antlr4_runtime::__antlr4_rust_generated_rule!"), - "generated dispatch must use the shared rule lifecycle\n{parser}" + parser.contains("antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self,"), + "generated dispatch must use the shared lifecycle dispatch form\n{parser}" ); assert_generated_project( diff --git a/crates/antlr-rust-runtime/src/parser.rs b/crates/antlr-rust-runtime/src/parser.rs index 29d523b2..47bb0f0e 100644 --- a/crates/antlr-rust-runtime/src/parser.rs +++ b/crates/antlr-rust-runtime/src/parser.rs @@ -235,6 +235,8 @@ macro_rules! __antlr4_rust_generated_rule { $($setup)* let mut $consumed_eof = false; let mut $sync_error: Option<$crate::AntlrError> = None; + // The body has its own Result boundary: `?` and `return` exit only this + // closure, with errors entering recovery. Parser borrows must not escape it. let __result = (|| -> Result<(), $crate::AntlrError> { $($body)* Ok(())