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..afbda5d5 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,19 @@ 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 init_at = rendered .find("println!(\"init\");") .expect("embedded @init body is emitted"); - let body_at = rendered - .find("let mut __consumed_eof") - .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!( - 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 +3018,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..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 @@ -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! { dispatch self,"), + "generated dispatch must use the shared lifecycle dispatch form\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..47bb0f0e 100644 --- a/crates/antlr-rust-runtime/src/parser.rs +++ b/crates/antlr-rust-runtime/src/parser.rs @@ -131,6 +131,174 @@ 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; + // 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(()) + })(); + 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