1use crate::builtins::run_builtin_action_with_info;
4use crate::context::{Context, ContextSeed, InstanceInfo};
5use crate::error::TabnasError;
6use crate::lexer::{compile_number_exclude, Lexer, RelexCheckpoint};
7use crate::options::Options;
8use crate::rule::{
9 resolved_action_order, resolved_alt_action_order, ActionBinding, AltActionBinding, AltMatch,
10 AltSpec, CompareOp, Condition, Rule, RuleDone, RuleDoneAlt, RuleName, RuleSnapshot, RuleSpec,
11 RuleState, StateAction,
12};
13use crate::token::{Tin, Token, TIN_AA, TIN_BD, TIN_ZZ};
14use crate::value::Value;
15use crate::{
16 Action, AltAction, ContextAction, LexSubscriber, ParseGuard, RuleDoneSubscriber,
17 RuleSubscriber, TokenSubscriber,
18};
19use indexmap::IndexMap;
20use std::borrow::Cow;
21use std::cell::RefCell;
22use std::collections::{BTreeSet, HashMap};
23use std::panic::{catch_unwind, AssertUnwindSafe};
24use std::rc::Rc;
25use std::sync::Arc;
26
27#[derive(Debug, Clone, PartialEq, Eq)]
28pub struct Continuations {
29 pub tins: Vec<Tin>,
30 pub tokens: Vec<String>,
31}
32
33#[derive(Debug, Clone)]
34pub struct ParseRecovery {
35 pub value: Option<Value>,
36 pub errors: Vec<TabnasError>,
37 pub fatal: Option<TabnasError>,
38}
39
40#[derive(Default)]
41struct ContinuationCapture {
42 at_end: BTreeSet<Tin>,
43 have_end: bool,
44 failure: Vec<Tin>,
45}
46
47struct ParseMode<'a> {
48 continuation: Option<&'a mut ContinuationCapture>,
49 recovering: bool,
50 errors: &'a mut Vec<TabnasError>,
51 partial: Option<PartialValue>,
52 gave_up: bool,
61}
62
63enum PartialValue {
72 Node(Rc<RefCell<Value>>),
73 Complete(Value),
74}
75
76impl PartialValue {
77 fn into_value(self) -> Option<Value> {
78 match self {
79 Self::Complete(value) => Some(value),
80 Self::Node(node) => {
81 let value = node.borrow().clone();
82 (!matches!(value, Value::Undefined | Value::Null)).then(|| value.unwrap_undefined())
83 }
84 }
85 }
86}
87
88struct RelexUndo {
89 position: usize,
90 token: Token,
91 checkpoint: RelexCheckpoint,
92 tokens: Vec<Token>,
93}
94
95#[derive(Clone, Copy, PartialEq, Eq)]
98enum Fetch {
99 Rule,
103 Trailing,
107}
108
109#[derive(Clone, Copy)]
110struct ParseSite<'a> {
111 source: &'a str,
112 stack: &'a [Rule],
113 alts: &'a [AltSpec],
114}
115
116pub struct Parser {
117 pub options: Arc<Options>,
121 ignore_tins: Vec<Tin>,
122 exclude_regex: Option<Arc<regex::Regex>>,
133 exclude_pattern: Option<String>,
134 rules: IndexMap<String, Arc<RuleSpec>>,
146 prepared_include: String,
156 prepared_exclude: String,
157 expected_tins: Vec<ExpectedTins>,
163 names: Vec<RuleName>,
175 prepared: Vec<PreparedRule>,
184 pub actions: HashMap<String, Action>,
185 pub context_actions: HashMap<String, ContextAction>,
186 pub matched_actions: HashMap<String, AltAction>,
187 pub state_actions: HashMap<String, StateAction>,
188 pub token_subscribers: Vec<TokenSubscriber>,
189 pub lex_subscribers: Vec<LexSubscriber>,
190 pub rule_subscribers: Vec<RuleSubscriber>,
191 pub rule_done_subscribers: Vec<RuleDoneSubscriber>,
192 pub parse_guards: Vec<ParseGuard>,
193 pub instance: InstanceInfo,
194}
195
196struct PreparedRule {
212 name: RuleName,
218 spec: Arc<RuleSpec>,
219 open: Vec<PreparedAlt>,
220 close: Vec<PreparedAlt>,
221 open_first: AltIndex,
225 close_first: AltIndex,
226 bo: Vec<ActionBinding>,
233 ao: Vec<ActionBinding>,
234 bc: Vec<ActionBinding>,
235 ac: Vec<ActionBinding>,
236}
237
238impl PreparedRule {
239 fn first(&self, is_open: bool) -> &AltIndex {
241 if is_open {
242 &self.open_first
243 } else {
244 &self.close_first
245 }
246 }
247
248 fn alt(&self, is_open: bool, idx: usize) -> Option<&PreparedAlt> {
249 if is_open {
250 self.open.get(idx)
251 } else {
252 self.close.get(idx)
253 }
254 }
255
256 fn before(&self, is_open: bool) -> &[ActionBinding] {
258 if is_open {
259 &self.bo
260 } else {
261 &self.bc
262 }
263 }
264
265 fn after(&self, is_open: bool) -> &[ActionBinding] {
267 if is_open {
268 &self.ao
269 } else {
270 &self.ac
271 }
272 }
273}
274
275struct PreparedAlt {
278 p: PreparedRoute,
279 r: PreparedRoute,
280 actions: Vec<AltActionBinding>,
282 observed: bool,
300 named: bool,
301 groups: bool,
310 group_tags: Vec<String>,
318}
319
320enum PreparedRoute {
321 ByName,
327 Static {
328 slot: usize,
329 name: RuleName,
330 spec: Arc<RuleSpec>,
331 },
332}
333
334impl PreparedRoute {
335 fn resolved(&self, name: &str) -> Option<(usize, RuleName, &Arc<RuleSpec>)> {
346 match self {
347 PreparedRoute::Static {
348 slot,
349 name: prepared,
350 spec,
351 } if prepared.as_str() == name => Some((*slot, prepared.clone(), spec)),
352 _ => None,
353 }
354 }
355}
356
357pub(crate) fn resolved_slot(alt: &AltSpec, slot: usize, options: &Options) -> Option<Vec<Tin>> {
374 let names = alt.s_names.get(slot)?;
375 if names.is_empty() || alt.s.get(slot) != alt.s_bound.get(slot) {
376 return None;
377 }
378 let mut tins = Vec::with_capacity(names.len());
379 for name in names {
380 if let Some(set) = options.token_set.get(name.trim_start_matches('#')) {
381 tins.extend(set.iter().copied());
382 } else {
383 tins.push(options.token(name)?);
384 }
385 }
386 Some(tins)
387}
388
389fn resolve_slot_names(spec: &mut RuleSpec, options: &Options) {
392 for alt in spec.open.iter_mut().chain(spec.close.iter_mut()) {
393 for slot in 0..alt.s.len() {
394 if let Some(tins) = resolved_slot(alt, slot, options) {
395 alt.s[slot] = tins;
396 }
397 }
398 }
399}
400
401#[derive(Debug, Default)]
415struct AltIndex {
416 by_tin: HashMap<Tin, Vec<usize>>,
417 wild: Vec<usize>,
418}
419
420const NO_ALTS: &[usize] = &[];
421
422impl AltIndex {
423 fn of(alts: &[AltSpec]) -> Self {
424 let mut by_tin: HashMap<Tin, Vec<usize>> = HashMap::new();
425 let mut wild = Vec::new();
426 for (idx, alt) in alts.iter().enumerate() {
427 match alt.s.first() {
428 Some(slot) if !slot.is_empty() && !slot.contains(&TIN_AA) => {
429 for tin in slot {
430 let list = by_tin.entry(*tin).or_default();
431 if list.last() != Some(&idx) {
434 list.push(idx);
435 }
436 }
437 }
438 _ => wild.push(idx),
439 }
440 }
441 AltIndex { by_tin, wild }
442 }
443
444 fn named(&self, tin: Tin) -> &[usize] {
447 self.by_tin.get(&tin).map_or(NO_ALTS, Vec::as_slice)
448 }
449}
450
451#[derive(Debug, Default)]
452struct ExpectedTins {
453 open: Vec<Vec<Tin>>,
454 close: Vec<Vec<Tin>>,
455}
456
457impl ExpectedTins {
458 fn of(spec: &RuleSpec, options: &Options) -> Self {
476 Self {
477 open: Self::by_slot(&spec.open, options),
478 close: Self::by_slot(&spec.close, options),
479 }
480 }
481
482 fn by_slot(alts: &[AltSpec], options: &Options) -> Vec<Vec<Tin>> {
483 let alts: Vec<&AltSpec> = alts
484 .iter()
485 .filter(|alt| groups_enabled(alt, options))
486 .collect();
487 let slots = alts.iter().map(|alt| alt.s.len()).max().unwrap_or(0);
488 (0..slots)
489 .map(|slot| Self::collate(alts.iter().copied(), slot))
490 .collect()
491 }
492
493 fn live(alts: &[AltSpec], options: &Options, slot: usize) -> Vec<Tin> {
496 Self::collate(alts.iter().filter(|alt| groups_enabled(alt, options)), slot)
497 }
498
499 fn collate<'a>(alts: impl Iterator<Item = &'a AltSpec>, slot: usize) -> Vec<Tin> {
500 let mut expected = BTreeSet::new();
501 for alt in alts {
502 if let Some(tins) = alt.s.get(slot) {
503 expected.extend(tins.iter().copied());
504 }
505 }
506 expected.into_iter().collect()
507 }
508
509 fn at(&self, is_open: bool, slot: usize) -> &[Tin] {
510 let slots = if is_open { &self.open } else { &self.close };
511 slots.get(slot).map(Vec::as_slice).unwrap_or_default()
512 }
513}
514
515impl Parser {
516 pub fn new(options: Options) -> Self {
517 let mut options = options;
518 options.sort_for_lexing();
519 Self::from_shared(Arc::new(options))
520 }
521
522 pub fn from_shared(options: Arc<Options>) -> Self {
525 if let Err(error) = options.validate_comment_definitions() {
526 panic!("invalid options: {error}");
527 }
528 Parser {
529 ignore_tins: options.ignore_tins(),
530 exclude_regex: compile_number_exclude(&options),
531 exclude_pattern: options.number.exclude.clone(),
532 options,
533 rules: IndexMap::new(),
534 prepared_include: String::new(),
535 prepared_exclude: String::new(),
536 expected_tins: Vec::new(),
537 names: Vec::new(),
538 prepared: Vec::new(),
539 actions: HashMap::new(),
540 context_actions: HashMap::new(),
541 matched_actions: HashMap::new(),
542 state_actions: HashMap::new(),
543 token_subscribers: Vec::new(),
544 lex_subscribers: Vec::new(),
545 rule_subscribers: Vec::new(),
546 rule_done_subscribers: Vec::new(),
547 parse_guards: Vec::new(),
548 instance: InstanceInfo::default(),
549 }
550 }
551
552 pub fn rules(&self) -> &IndexMap<String, Arc<RuleSpec>> {
557 &self.rules
558 }
559
560 pub fn add_rule(&mut self, spec: RuleSpec) {
561 let mut spec = spec;
567 resolve_slot_names(&mut spec, &self.options);
568 if self.options.rule.include != self.prepared_include
573 || self.options.rule.exclude != self.prepared_exclude
574 {
575 for (row, installed) in self.expected_tins.iter_mut().zip(self.rules.values()) {
576 *row = ExpectedTins::of(installed, &self.options);
577 }
578 }
579 let expected = ExpectedTins::of(&spec, &self.options);
580 let shared = RuleName::from(spec.name.as_str());
581 let (index, _) = self.rules.insert_full(spec.name.clone(), Arc::new(spec));
582 match self.names.get_mut(index) {
589 Some(existing) => *existing = shared,
590 None => self.names.push(shared),
591 }
592 match self.expected_tins.get_mut(index) {
593 Some(existing) => *existing = expected,
594 None => self.expected_tins.push(expected),
595 }
596 self.rebuild_prepared();
597 }
598
599 fn rebuild_prepared(&mut self) {
611 let mut prepared = Vec::with_capacity(self.rules.len());
612 for (index, spec) in self.rules.values().enumerate() {
613 prepared.push(PreparedRule {
614 name: self.names[index].clone(),
615 spec: Arc::clone(spec),
616 open: Self::prepared_alts(&spec.open, &self.rules, &self.names, &self.options),
617 close: Self::prepared_alts(&spec.close, &self.rules, &self.names, &self.options),
618 open_first: AltIndex::of(&spec.open),
619 close_first: AltIndex::of(&spec.close),
620 bo: resolved_action_order(
621 &spec.bo,
622 &spec.bo_fns,
623 &spec.bo_state_fns,
624 &spec.bo_order,
625 ),
626 ao: resolved_action_order(
627 &spec.ao,
628 &spec.ao_fns,
629 &spec.ao_state_fns,
630 &spec.ao_order,
631 ),
632 bc: resolved_action_order(
633 &spec.bc,
634 &spec.bc_fns,
635 &spec.bc_state_fns,
636 &spec.bc_order,
637 ),
638 ac: resolved_action_order(
639 &spec.ac,
640 &spec.ac_fns,
641 &spec.ac_state_fns,
642 &spec.ac_order,
643 ),
644 });
645 }
646 self.prepared = prepared;
647 self.prepared_include.clone_from(&self.options.rule.include);
648 self.prepared_exclude.clone_from(&self.options.rule.exclude);
649 }
650
651 fn prepared_alts(
652 alts: &[AltSpec],
653 rules: &IndexMap<String, Arc<RuleSpec>>,
654 names: &[RuleName],
655 options: &Options,
656 ) -> Vec<PreparedAlt> {
657 alts.iter()
658 .map(|alt| {
659 let actions = resolved_alt_action_order(
664 &alt.a,
665 &alt.action_fns,
666 &alt.matched_action_fns,
667 &alt.action_order,
668 );
669 let observed = alt.c_match.is_some()
670 || alt.c_lex_match.is_some()
671 || alt.e_match.is_some()
672 || alt.p_match.is_some()
673 || alt.r_match.is_some()
674 || alt.b_match.is_some()
675 || alt.h_match.is_some()
676 || actions
677 .iter()
678 .any(|binding| matches!(binding, AltActionBinding::Matched(_)));
679 let named = actions
680 .iter()
681 .any(|binding| matches!(binding, AltActionBinding::Named(_)));
682 PreparedAlt {
683 p: Self::prepared_route(alt.p.as_deref(), rules, names),
684 r: Self::prepared_route(alt.r.as_deref(), rules, names),
685 actions,
686 observed,
687 named,
688 groups: groups_enabled(alt, options),
689 group_tags: listed(&alt.g).map(str::to_owned).collect(),
690 }
691 })
692 .collect()
693 }
694
695 fn prepared_route(
696 route: Option<&str>,
697 rules: &IndexMap<String, Arc<RuleSpec>>,
698 names: &[RuleName],
699 ) -> PreparedRoute {
700 let Some(route) = route.filter(|route| !route.is_empty()) else {
703 return PreparedRoute::ByName;
704 };
705 match rules.get_full(route) {
706 Some((slot, _, spec)) => PreparedRoute::Static {
707 slot,
708 name: names[slot].clone(),
709 spec: Arc::clone(spec),
710 },
711 None => PreparedRoute::ByName,
712 }
713 }
714
715 fn installed(&self, name: &str) -> Option<(usize, RuleName, &Arc<RuleSpec>)> {
726 let (index, _, spec) = self.rules.get_full(name)?;
727 Some((index, self.names[index].clone(), spec))
728 }
729
730 pub fn add_action(&mut self, name: String, action: Action) {
731 self.actions.insert(name, action);
732 }
733
734 pub fn add_context_action(&mut self, name: String, action: ContextAction) {
735 self.context_actions.insert(name, action);
736 }
737
738 pub fn add_matched_action(&mut self, name: String, action: AltAction) {
739 self.matched_actions.insert(name, action);
740 }
741
742 pub fn add_state_action(&mut self, name: String, action: StateAction) {
743 self.state_actions.insert(name, action);
744 }
745
746 pub fn add_token_subscriber(&mut self, subscriber: TokenSubscriber) {
747 self.token_subscribers.push(subscriber);
748 }
749
750 pub fn add_lex_subscriber(&mut self, subscriber: LexSubscriber) {
751 self.lex_subscribers.push(subscriber);
752 }
753
754 pub fn add_rule_subscriber(&mut self, subscriber: RuleSubscriber) {
755 self.rule_subscribers.push(subscriber);
756 }
757
758 pub fn add_parse_guard(&mut self, guard: ParseGuard) {
759 self.parse_guards.push(guard);
760 }
761
762 pub fn add_rule_done_subscriber(&mut self, subscriber: RuleDoneSubscriber) {
763 self.rule_done_subscribers.push(subscriber);
764 }
765
766 pub fn set_instance_info(&mut self, instance: InstanceInfo) {
767 self.instance = instance;
768 }
769
770 fn run_action(
771 &self,
772 name: &str,
773 rule: &mut Rule,
774 context: &mut Context,
775 ) -> Result<(), TabnasError> {
776 self.run_action_with_config(name, rule, context, None)
777 }
778
779 fn run_after_actions(
780 &self,
781 spec: &RuleSpec,
782 prepared: Option<&PreparedRule>,
783 is_open: bool,
784 rule: &mut Rule,
785 context: &mut Context,
786 site: ParseSite<'_>,
787 ) -> Result<(), TabnasError> {
788 if (is_open && !rule.ao) || (!is_open && !rule.ac) {
789 return Ok(());
790 }
791 let by_spec;
798 let bindings: &[ActionBinding] = match prepared {
799 Some(prepared) => prepared.after(is_open),
800 None => {
801 let (actions, callbacks, states, order) = if is_open {
802 (&spec.ao, &spec.ao_fns, &spec.ao_state_fns, &spec.ao_order)
803 } else {
804 (&spec.ac, &spec.ac_fns, &spec.ac_state_fns, &spec.ac_order)
805 };
806 by_spec = resolved_action_order(actions, callbacks, states, order);
807 &by_spec
808 }
809 };
810 if bindings.is_empty() {
811 return Ok(());
812 }
813 let next = rule.next_rule.clone();
814 let mut output = None;
815 for binding in bindings {
816 output = match binding {
817 ActionBinding::Named(action) => {
818 if let Some(callback) = self.state_actions.get(action) {
819 self.run_state_callback(
820 "named lifecycle after action",
821 callback,
822 rule,
823 context,
824 next.as_deref(),
825 output,
826 )
827 .map_err(|error| {
828 self.attach_action_error(
829 error,
830 site.source,
831 rule,
832 site.stack,
833 site.alts,
834 )
835 })?
836 } else {
837 self.run_action(action, rule, context).map_err(|error| {
838 self.attach_action_error(
839 error,
840 site.source,
841 rule,
842 site.stack,
843 site.alts,
844 )
845 })?;
846 None
847 }
848 }
849 ActionBinding::Callback(callback) => {
850 self.run_context_callback("lifecycle after action", callback, rule, context)
851 .map_err(|error| {
852 self.attach_action_error(
853 error,
854 site.source,
855 rule,
856 site.stack,
857 site.alts,
858 )
859 })?;
860 None
861 }
862 ActionBinding::State(callback) => self
863 .run_state_callback(
864 "lifecycle after action",
865 callback,
866 rule,
867 context,
868 next.as_deref(),
869 output,
870 )
871 .map_err(|error| {
872 self.attach_action_error(error, site.source, rule, site.stack, site.alts)
873 })?,
874 };
875 output = self.check_lifecycle_output(output, rule, site)?;
876 }
877 Ok(())
878 }
879
880 fn run_context_callback(
881 &self,
882 label: &str,
883 callback: &ContextAction,
884 rule: &mut Rule,
885 context: &mut Context,
886 ) -> Result<(), TabnasError> {
887 context.set_rule(rule);
888 match catch_unwind(AssertUnwindSafe(|| callback(rule, context))) {
889 Ok(result) => result.map_err(|action_error| {
890 let token = match rule.state {
891 RuleState::Open => rule.o0().or_else(|| rule.c0()),
892 RuleState::Close => rule.c0().or_else(|| rule.o0()),
893 };
894 let mut error = TabnasError::new(
895 action_error.code,
896 token.map_or("", |value| value.src.as_str()),
897 "",
898 token.map_or(0, |value| value.site.pos),
899 token.map_or(1, |value| value.site.ri),
900 token.map_or(1, |value| value.site.ci),
901 );
902 error.detail = action_error.detail;
903 error
904 }),
905 Err(payload) => Err(self.action_panic(payload, label, rule)),
906 }
907 }
908
909 fn run_state_callback(
910 &self,
911 label: &str,
912 callback: &StateAction,
913 rule: &mut Rule,
914 context: &mut Context,
915 next: Option<&RuleSnapshot>,
916 out: Option<Token>,
917 ) -> Result<Option<Token>, TabnasError> {
918 context.set_rule(rule);
919 match catch_unwind(AssertUnwindSafe(|| callback(rule, context, next, out))) {
920 Ok(result) => result.map_err(|action_error| {
921 let token = match rule.state {
922 RuleState::Open => rule.o0().or_else(|| rule.c0()),
923 RuleState::Close => rule.c0().or_else(|| rule.o0()),
924 };
925 let mut error = TabnasError::new(
926 action_error.code,
927 token.map_or("", |value| value.src.as_str()),
928 "",
929 token.map_or(0, |value| value.site.pos),
930 token.map_or(1, |value| value.site.ri),
931 token.map_or(1, |value| value.site.ci),
932 );
933 error.detail = action_error.detail;
934 error
935 }),
936 Err(payload) => Err(self.action_panic(payload, label, rule)),
937 }
938 }
939
940 fn check_lifecycle_output(
941 &self,
942 output: Option<Token>,
943 rule: &Rule,
944 site: ParseSite<'_>,
945 ) -> Result<Option<Token>, TabnasError> {
946 let Some(token) = output.as_ref().filter(|token| !token.err.is_empty()) else {
947 return Ok(output);
948 };
949 Err(self.raised_token_error(token, rule, site))
950 }
951
952 fn raised_token_error(&self, token: &Token, rule: &Rule, site: ParseSite<'_>) -> TabnasError {
953 let error = TabnasError::new(
954 raised_error_code(token),
955 token.src.clone(),
956 site.source,
957 token.site.pos,
958 token.site.ri,
959 token.site.ci,
960 );
961 self.attach_error(error, rule, site.stack, site.alts, Some(token))
962 }
963
964 fn attach_action_error(
965 &self,
966 mut error: TabnasError,
967 src: &str,
968 rule: &Rule,
969 stack: &[Rule],
970 alts: &[AltSpec],
971 ) -> TabnasError {
972 error.full_source = src.into();
973 let token = match rule.state {
974 RuleState::Open => rule.o0().or_else(|| rule.c0()),
975 RuleState::Close => rule.c0().or_else(|| rule.o0()),
976 };
977 self.attach_error(error, rule, stack, alts, token)
978 }
979
980 fn run_action_with_config(
981 &self,
982 name: &str,
983 rule: &mut Rule,
984 context: &mut Context,
985 config: Option<&Value>,
986 ) -> Result<(), TabnasError> {
987 context.set_rule(rule);
988 match catch_unwind(AssertUnwindSafe(|| {
989 run_builtin_action_with_info(name, rule, context, config, &self.options.info)
990 })) {
991 Ok(true) => return Ok(()),
992 Ok(false) => {}
993 Err(payload) => return Err(self.action_panic(payload, name, rule)),
994 }
995 if let Some(action) = self.actions.get(name) {
996 return match catch_unwind(AssertUnwindSafe(|| action(rule))) {
997 Ok(()) => Ok(()),
998 Err(payload) => Err(self.action_panic(payload, name, rule)),
999 };
1000 }
1001 if let Some(action) = self.context_actions.get(name) {
1002 return self.run_context_callback(name, action, rule, context);
1003 }
1004 let token = match rule.state {
1005 RuleState::Open => rule.o0().or_else(|| rule.c0()),
1006 RuleState::Close => rule.c0().or_else(|| rule.o0()),
1007 };
1008 let mut error = TabnasError::new(
1009 "unknown",
1010 name,
1011 "",
1012 token.map_or(0, |value| value.site.pos),
1013 token.map_or(1, |value| value.site.ri),
1014 token.map_or(1, |value| value.site.ci),
1015 );
1016 error.detail = format!("unknown action: {name}");
1017 Err(error)
1018 }
1019
1020 fn action_panic(
1021 &self,
1022 payload: Box<dyn std::any::Any + Send>,
1023 name: &str,
1024 rule: &Rule,
1025 ) -> TabnasError {
1026 let token = match rule.state {
1027 RuleState::Open => rule.o0().or_else(|| rule.c0()),
1028 RuleState::Close => rule.c0().or_else(|| rule.o0()),
1029 };
1030 TabnasError::from_panic(
1031 payload,
1032 &format!("action {name}"),
1033 "",
1034 token.map_or(0, |value| value.site.pos),
1035 token.map_or(1, |value| value.site.ri),
1036 token.map_or(1, |value| value.site.ci),
1037 &self.options,
1038 )
1039 }
1040
1041 fn attach_error(
1042 &self,
1043 mut error: TabnasError,
1044 rule: &Rule,
1045 stack: &[Rule],
1046 alts: &[AltSpec],
1047 token: Option<&Token>,
1048 ) -> TabnasError {
1049 let mut rule_stack: Vec<String> = stack.iter().map(|item| item.name.to_string()).collect();
1050 rule_stack.push(rule.name.to_string());
1051 let expected = alts
1052 .iter()
1053 .filter_map(|alt| alt.s.first())
1054 .flat_map(|tins| tins.iter().copied())
1055 .map(|tin| self.options.token_name(tin))
1056 .collect();
1057 error.attach_context(
1058 &rule.name,
1059 if rule.state == RuleState::Open {
1060 "o"
1061 } else {
1062 "c"
1063 },
1064 rule_stack,
1065 token,
1066 expected,
1067 );
1068 self.decorate_error(&mut error);
1069 error
1070 }
1071
1072 fn decorate_error(&self, error: &mut TabnasError) {
1073 error.apply_options(&self.options);
1074 error.plugins = self.instance.plugins.clone();
1075 }
1076
1077 fn catch_callback<T>(
1078 &self,
1079 api: &str,
1080 src: &str,
1081 callback: impl FnOnce() -> T,
1082 ) -> Result<T, TabnasError> {
1083 catch_unwind(AssertUnwindSafe(callback))
1084 .map_err(|payload| TabnasError::from_panic(payload, api, src, 0, 1, 1, &self.options))
1085 }
1086
1087 fn cancelled(&self, src: &str, context: &Context, rule: &Rule, stack: &[Rule]) -> TabnasError {
1090 let token = context.t.first();
1091 let pnt = token
1092 .map(|token| {
1093 (
1094 token.src.as_str(),
1095 token.site.pos,
1096 token.site.ri,
1097 token.site.ci,
1098 )
1099 })
1100 .unwrap_or(("", 0, 1, 1));
1101 let error = TabnasError::new("cancel", pnt.0, src, pnt.1, pnt.2, pnt.3);
1102 self.attach_active_error(error, rule, stack, token)
1103 }
1104
1105 fn attach_active_error(
1106 &self,
1107 mut error: TabnasError,
1108 rule: &Rule,
1109 stack: &[Rule],
1110 token: Option<&Token>,
1111 ) -> TabnasError {
1112 if let Some(spec) = self.rules.get(&*rule.name) {
1113 let alts = if rule.state == RuleState::Open {
1114 &spec.open
1115 } else {
1116 &spec.close
1117 };
1118 self.attach_error(error, rule, stack, alts, token)
1119 } else {
1120 self.decorate_error(&mut error);
1121 error
1122 }
1123 }
1124
1125 fn phase_token(rule: &Rule) -> Option<&Token> {
1126 match rule.state {
1127 RuleState::Open => rule.o0().or_else(|| rule.c0()),
1128 RuleState::Close => rule.c0().or_else(|| rule.o0()),
1129 }
1130 }
1131
1132 fn ancestors_for<'a>(rule: &Rule, stack: &'a [Rule]) -> &'a [Rule] {
1133 if stack.last().is_some_and(|ancestor| ancestor.i == rule.i) {
1134 &stack[..stack.len() - 1]
1135 } else {
1136 stack
1137 }
1138 }
1139
1140 fn rule_done_copy(&self, rule: &Rule) -> Option<Rule> {
1149 (!self.rule_done_subscribers.is_empty()).then(|| rule.clone())
1150 }
1151
1152 #[allow(clippy::too_many_arguments)]
1153 fn notify_rule_done(
1154 &self,
1155 rule: &Rule,
1156 context: &Context,
1157 state: RuleState,
1158 alt: Option<RuleDoneAlt>,
1159 probe: bool,
1160 src: &str,
1161 stack: &[Rule],
1162 ) -> Result<(), TabnasError> {
1163 if self.rule_done_subscribers.is_empty() {
1164 return Ok(());
1165 }
1166 let done = RuleDone {
1167 state,
1168 alt,
1169 forced: false,
1170 probe,
1171 };
1172 let mut site_rule = rule.clone();
1173 site_rule.state = state;
1174 for subscriber in &self.rule_done_subscribers {
1175 let result = self.catch_callback("ruleDone subscriber", src, || {
1176 subscriber(rule, context, &done)
1177 });
1178 result.map_err(|error| {
1179 self.attach_active_error(
1180 error,
1181 &site_rule,
1182 Self::ancestors_for(&site_rule, stack),
1183 Self::phase_token(&site_rule),
1184 )
1185 })?;
1186 }
1187 Ok(())
1188 }
1189
1190 fn notify_forced_close(
1191 &self,
1192 rule: &Rule,
1193 context: &Context,
1194 probe: bool,
1195 src: &str,
1196 stack: &[Rule],
1197 ) -> Result<(), TabnasError> {
1198 if self.rule_done_subscribers.is_empty() {
1199 return Ok(());
1200 }
1201 let done = RuleDone {
1202 state: RuleState::Close,
1203 alt: None,
1204 forced: true,
1205 probe,
1206 };
1207 let mut site_rule = rule.clone();
1208 site_rule.state = RuleState::Close;
1209 for subscriber in &self.rule_done_subscribers {
1210 let result = self.catch_callback("ruleDone subscriber", src, || {
1211 subscriber(rule, context, &done)
1212 });
1213 result.map_err(|error| {
1214 self.attach_active_error(
1215 error,
1216 &site_rule,
1217 Self::ancestors_for(&site_rule, stack),
1218 Self::phase_token(&site_rule),
1219 )
1220 })?;
1221 }
1222 Ok(())
1223 }
1224
1225 fn attempt_recover(
1226 &self,
1227 error: TabnasError,
1228 current_rule: &mut Rule,
1229 stack: &mut Vec<Rule>,
1230 context: &mut Context,
1231 lexer: &mut Lexer,
1232 mode: &mut ParseMode<'_>,
1233 ) -> Result<bool, TabnasError> {
1234 let src = error.full_source.clone();
1235 let recover = &self.options.parse.recover;
1236
1237 let suppressed = context
1244 .recover_at
1245 .is_some_and(|at| context.v_abs.saturating_sub(at) < recover.suppress);
1246 let recorded = (!suppressed).then(|| {
1247 mode.errors.push(error.clone());
1248 context.errs.push(error.clone());
1249 mode.errors.len() - 1
1250 });
1251 if recover.max_recoveries < mode.errors.len() {
1252 return Ok(false);
1253 }
1254
1255 let no_progress = context.recover_at == Some(context.v_abs);
1256 let last_si = context.recover_si;
1257 context.recover_at = Some(context.v_abs);
1258
1259 let sync = compute_sync_tins(current_rule, stack, &self.rules, &self.options);
1260 let mut pending: std::collections::VecDeque<Token> = std::mem::take(&mut context.t).into();
1261 let mut skipped = 0usize;
1262
1263 let candidate = loop {
1264 let next = if let Some(token) = pending.pop_front() {
1265 Some(token)
1266 } else {
1267 loop {
1268 let next_raw = self.catch_callback("lexer callback", &src, || {
1269 lexer.next_raw_for_rule(current_rule, context)
1270 });
1271 let next_raw = next_raw.map_err(|error| {
1272 self.attach_active_error(
1273 error,
1274 current_rule,
1275 stack,
1276 Self::phase_token(current_rule),
1277 )
1278 })?;
1279 match next_raw {
1280 Ok(mut token) => {
1281 for subscriber in &self.lex_subscribers {
1282 let result = self.catch_callback("lex subscriber", &src, || {
1283 subscriber(&mut token, current_rule, context)
1284 });
1285 result.map_err(|error| {
1286 self.attach_active_error(
1287 error,
1288 current_rule,
1289 stack,
1290 Some(&token),
1291 )
1292 })?;
1293 }
1294 if self.ignore_tins.contains(&token.tin) {
1295 continue;
1296 }
1297 for subscriber in &self.token_subscribers {
1298 let result = self.catch_callback("token subscriber", &src, || {
1299 subscriber(&token)
1300 });
1301 result.map_err(|error| {
1302 self.attach_active_error(
1303 error,
1304 current_rule,
1305 stack,
1306 Some(&token),
1307 )
1308 })?;
1309 }
1310 break Some(token);
1311 }
1312 Err(lex_error) => {
1313 let mut token = error_token(&lex_error);
1314 for subscriber in &self.lex_subscribers {
1315 let result = self.catch_callback("lex subscriber", &src, || {
1316 subscriber(&mut token, current_rule, context)
1317 });
1318 result.map_err(|error| {
1319 self.attach_active_error(
1320 error,
1321 current_rule,
1322 stack,
1323 Some(&token),
1324 )
1325 })?;
1326 }
1327 lexer.skip_bad(&token, mid_construct(&lex_error.code));
1328 if skipped >= recover.max_skip {
1329 break None;
1330 }
1331 skipped += 1;
1332 }
1333 }
1334 }
1335 };
1336 let Some(token) = next else {
1337 return Ok(false);
1338 };
1339 if token.tin == TIN_ZZ
1340 || (sync.contains(&token.tin)
1341 && !(no_progress && last_si.is_some_and(|si| token.site.pos <= si)))
1342 {
1343 break token;
1344 }
1345 if token.tin == TIN_BD {
1351 lexer.skip_bad(&token, mid_construct(&token.why));
1352 }
1353 if skipped >= recover.max_skip {
1354 return Ok(false);
1355 }
1356 skipped += 1;
1357 };
1358
1359 if candidate.tin == TIN_ZZ
1360 && no_progress
1361 && last_si.is_some_and(|si| candidate.site.pos <= si)
1362 {
1363 return Ok(false);
1364 }
1365 context.recover_si = Some(candidate.site.pos);
1366 if let Some(index) = recorded {
1367 let recovered = Some(crate::RecoveredAt {
1368 skipped,
1369 sync: Some(candidate.tin),
1370 bad: false,
1371 });
1372 if let Some(entry) = context.errs.get_mut(index) {
1373 entry.recovered.clone_from(&recovered);
1374 }
1375 if let Some(entry) = mode.errors.get_mut(index) {
1376 entry.recovered = recovered;
1377 }
1378 }
1379
1380 context.t.push(candidate.clone());
1381 context.t.extend(pending);
1382 context.bad_to = None;
1383 context.bad_error = None;
1384
1385 if !recover.pop_until_valid {
1386 if let Some(parent) = stack.pop() {
1392 context.probe_abandon(current_rule);
1394 *current_rule = parent;
1395 return Ok(true);
1396 }
1397 return Ok(false);
1398 }
1399
1400 if accepts_close(current_rule, candidate.tin, &self.rules, &self.options) {
1401 if current_rule.state == RuleState::Open {
1402 current_rule.state = RuleState::Close;
1403 } else {
1404 current_rule.skip_befores = true;
1405 }
1406 return Ok(true);
1407 }
1408
1409 let probe = context.probe_abandon(current_rule);
1411 self.notify_forced_close(current_rule, context, probe, &src, stack)?;
1412 while let Some(mut parent) = stack.pop() {
1413 parent.accept_child(current_rule);
1414 bound_child_link(&mut parent, self.options.rule.history);
1415 if accepts_close(&parent, candidate.tin, &self.rules, &self.options) {
1416 *current_rule = parent;
1417 return Ok(true);
1418 }
1419 let probe = context.probe_abandon(&parent);
1420 self.notify_forced_close(&parent, context, probe, &src, stack)?;
1421 *current_rule = parent;
1422 }
1423 Ok(false)
1424 }
1425
1426 #[allow(clippy::too_many_arguments)]
1427 fn recover_error_pass(
1428 &self,
1429 error: TabnasError,
1430 state: RuleState,
1431 mut alt: Option<RuleDoneAlt>,
1432 fallback_error_token: bool,
1433 src: &str,
1434 current_rule: &mut Rule,
1435 stack: &mut Vec<Rule>,
1436 context: &mut Context,
1437 lexer: &mut Lexer,
1438 mode: &mut ParseMode<'_>,
1439 ) -> Result<(), TabnasError> {
1440 let event_rule = current_rule.clone();
1445 let probe_at_error = 0 < context.probe_depth();
1449 let recovered = mode.recovering
1450 && self.attempt_recover(error.clone(), current_rule, stack, context, lexer, mode)?;
1451 if !recovered && fallback_error_token {
1452 if let Some(alt) = alt.as_mut().filter(|alt| alt.err.is_none()) {
1453 let tin = self.options.token(&error.token.name).unwrap_or(TIN_BD);
1454 let mut token = Token::new(
1455 error.token.name.clone(),
1456 tin,
1457 Value::Undefined,
1458 error.token.src.clone(),
1459 crate::Point {
1460 len: error.len,
1461 site: crate::Site {
1462 si: error.pos,
1463 pos: error.pos,
1464 ri: error.row,
1465 ci: error.col,
1466 },
1467 },
1468 );
1469 token.bad(&error.code);
1470 alt.err = Some(token);
1471 }
1472 }
1473 let probe = context.probe_take() || probe_at_error;
1474 self.notify_rule_done(&event_rule, context, state, alt, probe, src, stack)?;
1475 if recovered {
1476 Ok(())
1477 } else {
1478 if mode.recovering && !mode.errors.is_empty() {
1483 mode.gave_up = true;
1484 }
1485 Err(error)
1486 }
1487 }
1488
1489 #[allow(clippy::too_many_arguments)]
1490 fn recover_after_actions(
1491 &self,
1492 result: Result<(), TabnasError>,
1493 state: RuleState,
1494 alt: Option<RuleDoneAlt>,
1495 src: &str,
1496 current_rule: &mut Rule,
1497 stack: &mut Vec<Rule>,
1498 context: &mut Context,
1499 lexer: &mut Lexer,
1500 mode: &mut ParseMode<'_>,
1501 ) -> Result<bool, TabnasError> {
1502 let Err(error) = result else {
1503 return Ok(false);
1504 };
1505 self.recover_error_pass(
1506 error,
1507 state,
1508 alt,
1509 true,
1510 src,
1511 current_rule,
1512 stack,
1513 context,
1514 lexer,
1515 mode,
1516 )?;
1517 Ok(true)
1518 }
1519
1520 pub fn parse(&self, src: &str) -> Result<Value, TabnasError> {
1521 self.parse_with_meta(src, Value::Undefined)
1522 }
1523
1524 pub fn parse_with_meta(&self, src: &str, meta: Value) -> Result<Value, TabnasError> {
1525 self.parse_with_owner(src, meta, None, None)
1526 }
1527
1528 pub(crate) fn parse_for(
1529 &self,
1530 owner: &crate::Tabnas,
1531 src: &str,
1532 meta: Value,
1533 ) -> Result<Value, TabnasError> {
1534 self.parse_with_owner(src, meta, Some(owner), None)
1535 }
1536
1537 pub(crate) fn parse_for_with_context(
1538 &self,
1539 owner: &crate::Tabnas,
1540 src: &str,
1541 meta: Value,
1542 parent: &ContextSeed,
1543 ) -> Result<Value, TabnasError> {
1544 self.parse_with_owner(src, meta, Some(owner), Some(parent))
1545 }
1546
1547 fn parse_with_owner(
1548 &self,
1549 src: &str,
1550 meta: Value,
1551 owner: Option<&crate::Tabnas>,
1552 parent: Option<&ContextSeed>,
1553 ) -> Result<Value, TabnasError> {
1554 match catch_unwind(AssertUnwindSafe(|| {
1555 self.parse_uncaught(src, meta, owner, parent)
1556 })) {
1557 Ok(result) => result,
1558 Err(payload) => {
1559 let mut error =
1560 TabnasError::from_panic(payload, "Parser::parse", src, 0, 1, 1, &self.options);
1561 self.decorate_error(&mut error);
1562 Err(error)
1563 }
1564 }
1565 }
1566
1567 fn parse_uncaught(
1568 &self,
1569 src: &str,
1570 meta: Value,
1571 owner: Option<&crate::Tabnas>,
1572 parent: Option<&ContextSeed>,
1573 ) -> Result<Value, TabnasError> {
1574 if let Some(result) = self.run_parser_start(src, &meta, owner, parent) {
1575 return result.map_err(|mut error| {
1576 self.decorate_error(&mut error);
1577 error
1578 });
1579 }
1580 let mut errors = Vec::new();
1581 let recovering = self.options.parse.recover.enabled;
1582 let mut mode = ParseMode {
1583 continuation: None,
1584 recovering,
1585 errors: &mut errors,
1586 partial: None,
1587 gave_up: false,
1588 };
1589 let result = self
1590 .parse_inner(src, meta, owner, parent, &mut mode)
1591 .map_err(|mut error| {
1592 self.decorate_error(&mut error);
1593 error
1594 });
1595 match result {
1596 Err(_) if recovering => Ok(mode
1597 .partial
1598 .and_then(PartialValue::into_value)
1599 .unwrap_or(Value::Undefined)),
1600 other => other,
1601 }
1602 }
1603
1604 pub fn parse_recover(&self, src: &str) -> ParseRecovery {
1605 self.parse_recover_with_meta(src, Value::Undefined)
1606 }
1607
1608 pub fn parse_recover_with_meta(&self, src: &str, meta: Value) -> ParseRecovery {
1609 self.parse_recover_with_owner(src, meta, None, None)
1610 }
1611
1612 pub(crate) fn parse_recover_for(
1613 &self,
1614 owner: &crate::Tabnas,
1615 src: &str,
1616 meta: Value,
1617 ) -> ParseRecovery {
1618 self.parse_recover_with_owner(src, meta, Some(owner), None)
1619 }
1620
1621 pub(crate) fn parse_recover_for_with_context(
1622 &self,
1623 owner: &crate::Tabnas,
1624 src: &str,
1625 meta: Value,
1626 parent: &ContextSeed,
1627 ) -> ParseRecovery {
1628 self.parse_recover_with_owner(src, meta, Some(owner), Some(parent))
1629 }
1630
1631 fn parse_recover_with_owner(
1632 &self,
1633 src: &str,
1634 meta: Value,
1635 owner: Option<&crate::Tabnas>,
1636 parent: Option<&ContextSeed>,
1637 ) -> ParseRecovery {
1638 match catch_unwind(AssertUnwindSafe(|| {
1639 self.parse_recover_uncaught(src, meta, owner, parent)
1640 })) {
1641 Ok(result) => result,
1642 Err(payload) => {
1643 let mut error = TabnasError::from_panic(
1644 payload,
1645 "Parser::parse_recover",
1646 src,
1647 0,
1648 1,
1649 1,
1650 &self.options,
1651 );
1652 self.decorate_error(&mut error);
1653 ParseRecovery {
1654 value: None,
1655 errors: Vec::new(),
1656 fatal: Some(error),
1657 }
1658 }
1659 }
1660 }
1661
1662 fn parse_recover_uncaught(
1663 &self,
1664 src: &str,
1665 meta: Value,
1666 owner: Option<&crate::Tabnas>,
1667 parent: Option<&ContextSeed>,
1668 ) -> ParseRecovery {
1669 if let Some(result) = self.run_parser_start(src, &meta, owner, parent) {
1670 return match result {
1671 Ok(value) => ParseRecovery {
1672 value: Some(value),
1673 errors: Vec::new(),
1674 fatal: None,
1675 },
1676 Err(mut error) => {
1677 self.decorate_error(&mut error);
1678 ParseRecovery {
1679 value: None,
1680 errors: Vec::new(),
1681 fatal: Some(error),
1682 }
1683 }
1684 };
1685 }
1686 let mut errors = Vec::new();
1687 let recovering = self.options.parse.recover.enabled;
1688 let (result, partial, gave_up) = {
1689 let mut mode = ParseMode {
1690 continuation: None,
1691 recovering,
1692 errors: &mut errors,
1693 partial: None,
1694 gave_up: false,
1695 };
1696 let result = self
1697 .parse_inner(src, meta, owner, parent, &mut mode)
1698 .map_err(|mut error| {
1699 self.decorate_error(&mut error);
1700 error
1701 });
1702 (
1703 result,
1704 mode.partial.and_then(PartialValue::into_value),
1705 mode.gave_up,
1706 )
1707 };
1708 for error in &mut errors {
1709 self.decorate_error(error);
1710 }
1711 match result {
1712 Ok(value) => ParseRecovery {
1713 value: Some(value),
1714 errors,
1715 fatal: None,
1716 },
1717 Err(error) => {
1718 if !gave_up {
1722 errors.push(error.clone());
1723 }
1724 ParseRecovery {
1725 value: recovering.then_some(partial).flatten(),
1726 errors,
1727 fatal: (!recovering).then_some(error),
1728 }
1729 }
1730 }
1731 }
1732
1733 fn run_parser_start(
1734 &self,
1735 src: &str,
1736 meta: &Value,
1737 owner: Option<&crate::Tabnas>,
1738 parent: Option<&ContextSeed>,
1739 ) -> Option<Result<Value, TabnasError>> {
1740 let result = if let Some(start) = self.options.parser.start_with_context.as_ref() {
1741 let Some(owner) = owner else {
1742 let mut error = TabnasError::new("internal", "", src, 0, 1, 1);
1743 error.detail =
1744 "parser.start requires an owning Tabnas instance; call Tabnas::parse".into();
1745 self.decorate_error(&mut error);
1746 return Some(Err(error));
1747 };
1748 catch_unwind(AssertUnwindSafe(|| start(src, owner, meta, parent)))
1749 } else if let Some(start) = self.options.parser.start_with_instance.as_ref() {
1750 let Some(owner) = owner else {
1751 let mut error = TabnasError::new("internal", "", src, 0, 1, 1);
1752 error.detail =
1753 "parser.start requires an owning Tabnas instance; call Tabnas::parse".into();
1754 self.decorate_error(&mut error);
1755 return Some(Err(error));
1756 };
1757 catch_unwind(AssertUnwindSafe(|| start(src, owner, meta)))
1758 } else {
1759 let start = self.options.parser.start.as_ref()?;
1760 catch_unwind(AssertUnwindSafe(|| start(src)))
1761 };
1762 Some(match result {
1763 Ok(result) => result.map_err(|error| *error),
1764 Err(payload) => Err(TabnasError::from_panic(
1765 payload,
1766 "parser.start",
1767 src,
1768 0,
1769 1,
1770 1,
1771 &self.options,
1772 )),
1773 })
1774 }
1775
1776 pub fn continuations(&self, src: &str) -> Continuations {
1780 self.continuations_with_owner(src, None)
1781 }
1782
1783 pub(crate) fn continuations_for(&self, owner: &crate::Tabnas, src: &str) -> Continuations {
1784 self.continuations_with_owner(src, Some(owner))
1785 }
1786
1787 fn continuations_with_owner(&self, src: &str, owner: Option<&crate::Tabnas>) -> Continuations {
1788 catch_unwind(AssertUnwindSafe(|| self.continuations_uncaught(src, owner)))
1789 .unwrap_or_else(|_| self.start_continuations())
1790 }
1791
1792 fn continuations_uncaught(&self, src: &str, owner: Option<&crate::Tabnas>) -> Continuations {
1793 let mut capture = ContinuationCapture::default();
1794 let mut errors = Vec::new();
1795 let result = {
1796 let mut mode = ParseMode {
1797 continuation: Some(&mut capture),
1798 recovering: false,
1799 errors: &mut errors,
1800 partial: None,
1801 gave_up: false,
1802 };
1803 self.parse_inner(src, Value::Undefined, owner, None, &mut mode)
1804 };
1805 let mut tins = if result.is_ok() {
1806 if capture.have_end {
1807 capture.at_end.insert(TIN_ZZ);
1808 capture.at_end.into_iter().collect()
1809 } else {
1810 self.start_openers()
1811 }
1812 } else if capture.failure.is_empty() {
1813 self.start_openers()
1814 } else {
1815 capture.failure
1816 };
1817 tins.sort_unstable();
1818 tins.dedup();
1819 let tokens = tins
1820 .iter()
1821 .map(|tin| self.options.token_name(*tin))
1822 .collect();
1823 Continuations { tins, tokens }
1824 }
1825
1826 fn start_continuations(&self) -> Continuations {
1827 let tins = self.start_openers();
1828 let tokens = tins
1829 .iter()
1830 .map(|tin| self.options.token_name(*tin))
1831 .collect();
1832 Continuations { tins, tokens }
1833 }
1834
1835 fn start_openers(&self) -> Vec<Tin> {
1836 let start = self.rules.get(&self.options.rule.start);
1837 let mut out = BTreeSet::new();
1838 if let Some(spec) = start {
1839 for alt in &spec.open {
1840 if groups_enabled(alt, &self.options) {
1841 if let Some(slot) = alt.s.first() {
1842 out.extend(completion_tins(slot));
1843 }
1844 }
1845 }
1846 }
1847 out.into_iter().collect()
1848 }
1849
1850 fn expected_match_tins(&self, rule: &Rule, slot: usize) -> Cow<'_, [Tin]> {
1875 if self.options.match_tokens.is_empty() {
1876 return Cow::Borrowed(&[]);
1877 }
1878 let index = match self.names.get(rule.slot) {
1886 Some(installed) if *installed == rule.name => rule.slot,
1887 _ => match self.rules.get_index_of(&*rule.name) {
1888 Some(index) => index,
1889 None => return Cow::Borrowed(&[]),
1890 },
1891 };
1892 let is_open = rule.state == RuleState::Open;
1893 if self.options.rule.include == self.prepared_include
1894 && self.options.rule.exclude == self.prepared_exclude
1895 {
1896 return Cow::Borrowed(self.expected_tins[index].at(is_open, slot));
1897 }
1898 let installed = &self.rules[index];
1899 let alts = if is_open {
1900 &installed.open
1901 } else {
1902 &installed.close
1903 };
1904 Cow::Owned(ExpectedTins::live(alts, &self.options, slot))
1905 }
1906
1907 fn capture_fetch_failure(
1921 &self,
1922 context: &Context,
1923 rule: &Rule,
1924 stack: &[Rule],
1925 mode: &mut ParseMode<'_>,
1926 fetch: Fetch,
1927 ) {
1928 if fetch != Fetch::Rule {
1929 return;
1930 }
1931 if let Some(capture) = mode.continuation.as_deref_mut() {
1932 capture.failure =
1933 continuation_tins(context, rule, stack, &self.rules, &self.options, 0, None);
1934 }
1935 }
1936
1937 #[allow(clippy::too_many_arguments)]
1938 fn ensure_lookahead(
1939 &self,
1940 lexer: &mut Lexer,
1941 context: &mut Context,
1942 rule: &mut Rule,
1943 count: usize,
1944 mode: &mut ParseMode<'_>,
1945 site: ParseSite<'_>,
1946 fetch: Fetch,
1947 ) -> Result<(), TabnasError> {
1948 while context.t.len() < count {
1949 if context.t.last().is_some_and(|token| token.tin == TIN_ZZ) {
1950 break;
1951 }
1952 let expected_match_tins = self.expected_match_tins(rule, context.t.len());
1953 let token = loop {
1954 let next = match context.next_replay() {
1955 Some(token) => Ok(token),
1956 None => {
1957 let result = self.catch_callback("lexer callback", site.source, || {
1958 lexer.next_rule_token(&expected_match_tins, rule, context)
1959 });
1960 result.map_err(|error| {
1961 self.attach_active_error(
1962 error,
1963 rule,
1964 site.stack,
1965 Self::phase_token(rule),
1966 )
1967 })?
1968 }
1969 };
1970 let mut token = match next {
1971 Ok(token) => token,
1972 Err(error) => error_token(&error),
1982 };
1983 for subscriber in &self.lex_subscribers {
1984 let result = self.catch_callback("lex subscriber", site.source, || {
1985 subscriber(&mut token, rule, context)
1986 });
1987 result.map_err(|error| {
1988 self.attach_active_error(error, rule, site.stack, Some(&token))
1989 })?;
1990 }
1991 if token.tin == TIN_BD && !self.options.lex.relex {
2004 let code = if token.why.is_empty() {
2005 "unexpected"
2006 } else {
2007 token.why.as_str()
2008 };
2009 let error = TabnasError::new(
2010 code,
2011 token.src.clone(),
2012 site.source,
2013 token.site.pos,
2014 token.site.ri,
2015 token.site.ci,
2016 );
2017 let error = self.attach_error(error, rule, site.stack, site.alts, Some(&token));
2018 if mode.recovering && fetch == Fetch::Rule {
2019 if absorb_lex_error(&error, context, &self.options, mode.errors) {
2020 lexer.skip_bad(&token, mid_construct(&error.code));
2021 continue;
2022 }
2023 mode.gave_up = true;
2024 }
2025 self.capture_fetch_failure(context, rule, site.stack, mode, fetch);
2026 return Err(error);
2027 }
2028 if token.tin == TIN_ZZ {
2029 if let Some(capture) = mode.continuation.as_deref_mut() {
2030 capture.have_end = true;
2038 if fetch == Fetch::Rule {
2039 capture.at_end.extend(continuation_tins(
2040 context,
2041 rule,
2042 site.stack,
2043 &self.rules,
2044 &self.options,
2045 context.t.len(),
2046 None,
2047 ));
2048 }
2049 }
2050 }
2051 if !self.ignore_tins.contains(&token.tin) {
2052 break token;
2053 }
2054 };
2055 for subscriber in &self.token_subscribers {
2056 let result =
2057 self.catch_callback("token subscriber", site.source, || subscriber(&token));
2058 result.map_err(|error| {
2059 self.attach_active_error(error, rule, site.stack, Some(&token))
2060 })?;
2061 }
2062 let is_end = token.tin == TIN_ZZ;
2063 context.t.push(token);
2064 if is_end {
2065 break;
2066 }
2067 }
2068 Ok(())
2069 }
2070
2071 fn parse_inner(
2072 &self,
2073 src: &str,
2074 meta: Value,
2075 owner: Option<&crate::Tabnas>,
2076 parent: Option<&ContextSeed>,
2077 mode: &mut ParseMode<'_>,
2078 ) -> Result<Value, TabnasError> {
2079 let input_meta = meta.clone();
2080 let mut context = Context::new(
2081 self.options.rewind.history,
2082 src,
2083 meta,
2084 Arc::clone(&self.options),
2085 self.instance.clone(),
2086 );
2087 if let Some(parent) = parent {
2088 context.apply_seed(parent);
2089 }
2090 for prepare in &self.options.parse.prepare {
2091 let outcome = self.catch_callback("parse.prepare", src, || {
2092 prepare.run(owner, &mut context, &input_meta)
2093 })?;
2094 if let Err(detail) = outcome {
2095 let mut error = TabnasError::new("internal", "", src, 0, 1, 1);
2096 error.detail = detail.into();
2097 return Err(error);
2098 }
2099 }
2100 for prepare in self.options.parse.named_prepare.values() {
2101 let outcome = self.catch_callback("parse.prepare", src, || {
2102 prepare.run(owner, &mut context, &input_meta)
2103 })?;
2104 if let Err(detail) = outcome {
2105 let mut error = TabnasError::new("internal", "", src, 0, 1, 1);
2106 error.detail = detail.into();
2107 return Err(error);
2108 }
2109 }
2110
2111 if src.is_empty() {
2112 return if self.options.lex.empty {
2113 Ok(self.options.lex.empty_result.clone())
2114 } else {
2115 Err(TabnasError::new("unexpected", "", src, 0, 1, 1))
2116 };
2117 }
2118
2119 let exclude_regex = if self.exclude_pattern == self.options.number.exclude {
2122 self.exclude_regex.clone()
2123 } else {
2124 compile_number_exclude(&self.options)
2125 };
2126 let mut lexer = Lexer::with_shared(src, Arc::clone(&self.options), exclude_regex);
2127
2128 let start_name = self.options.rule.start.as_str();
2131 let Some((start_slot, start_shared, start_spec)) = self.installed(start_name) else {
2132 return Ok(Value::Undefined);
2133 };
2134
2135 let mut current_rule = Rule::new(start_shared.clone(), Value::Undefined);
2136 current_rule.bind_spec(start_spec, start_shared, start_slot);
2137 current_rule.i = 1;
2140 let root_node = current_rule.node.clone();
2141 context.set_root(root_node.clone());
2142 let mut stack: Vec<Rule> = Vec::new();
2143 let park_child_nodes = self.options.parse.recover.pop_until_valid;
2148 let mut next_rule_id = 2;
2149 #[allow(unused_assignments)]
2150 let mut final_value = None;
2151
2152 let mut iterations = 0usize;
2153 let maxmul = if self.options.rule.maxmul == 0 {
2154 3
2155 } else {
2156 self.options.rule.maxmul
2157 };
2158 let max_iterations = self
2159 .rules
2160 .len()
2161 .saturating_mul(src.encode_utf16().count())
2162 .saturating_mul(4)
2163 .saturating_mul(maxmul)
2164 .max(100);
2165 let budget = &self.options.parse.budget;
2166
2167 let mut matched = AltMatch::default();
2175
2176 'parse: loop {
2177 context.set_active(¤t_rule, &stack);
2178 update_partial(mode, &root_node, ¤t_rule, &stack);
2179 iterations += 1;
2180 if iterations > max_iterations {
2181 let pnt = context
2182 .t
2183 .first()
2184 .map(|t| (t.site.pos, t.site.ri, t.site.ci))
2185 .unwrap_or((0, 1, 1));
2186 return Err(TabnasError::new("unexpected", "", src, pnt.0, pnt.1, pnt.2));
2187 }
2188 context.iteration = iterations - 1;
2189 if context.iteration > 0 {
2192 for guard in &self.parse_guards {
2193 let result = self.catch_callback("parse guard", src, || guard(&context));
2194 let keep_going = result.map_err(|error| {
2195 self.attach_active_error(
2196 error,
2197 ¤t_rule,
2198 &stack,
2199 Self::phase_token(¤t_rule).or_else(|| context.t.first()),
2200 )
2201 })?;
2202 if !keep_going {
2203 return Err(self.cancelled(src, &context, ¤t_rule, &stack));
2204 }
2205 }
2206 }
2207 if budget.check_every_n > 0
2208 && context.iteration > 0
2209 && context.iteration % budget.check_every_n == 0
2210 {
2211 if let Some(check) = &budget.on_check {
2212 let result =
2213 self.catch_callback("parse.budget.onCheck", src, || check(&context));
2214 let keep_going = result.map_err(|error| {
2215 self.attach_active_error(
2216 error,
2217 ¤t_rule,
2218 &stack,
2219 Self::phase_token(¤t_rule).or_else(|| context.t.first()),
2220 )
2221 })?;
2222 if !keep_going {
2223 return Err(self.cancelled(src, &context, ¤t_rule, &stack));
2224 }
2225 }
2226 }
2227
2228 let by_name;
2244 let (prepared, spec) = match self.prepared.get(current_rule.slot).filter(|prepared| {
2245 Arc::ptr_eq(&prepared.spec, ¤t_rule.spec)
2246 && prepared.name == current_rule.name
2247 }) {
2248 Some(prepared) => (Some(prepared), &prepared.spec),
2249 None => {
2250 by_name = if current_rule.spec.name == *current_rule.name {
2251 Arc::clone(¤t_rule.spec)
2252 } else {
2253 match self.rules.get(&*current_rule.name) {
2254 Some(s) => s.clone(),
2255 None => {
2256 let pnt = context
2257 .t
2258 .first()
2259 .map(|t| (t.site.pos, t.site.ri, t.site.ci))
2260 .unwrap_or((0, 1, 1));
2261 return Err(TabnasError::new(
2262 "unknown_rule",
2263 &*current_rule.name,
2264 src,
2265 pnt.0,
2266 pnt.1,
2267 pnt.2,
2268 ));
2269 }
2270 }
2271 };
2272 (None, &by_name)
2273 }
2274 };
2275
2276 let is_open = current_rule.state == RuleState::Open;
2277 let probe_at_start = 0 < context.probe_depth();
2280 let alts = if is_open { &spec.open } else { &spec.close };
2281
2282 for subscriber in &self.rule_subscribers {
2283 let result = self.catch_callback("rule subscriber", src, || {
2284 subscriber(&mut current_rule, &mut context)
2285 });
2286 result.map_err(|error| {
2287 self.attach_error(
2288 error,
2289 ¤t_rule,
2290 &stack,
2291 alts,
2292 Self::phase_token(¤t_rule).or_else(|| context.t.first()),
2293 )
2294 })?;
2295 }
2296 update_partial(mode, &root_node, ¤t_rule, &stack);
2297
2298 let skip_befores = current_rule.skip_befores;
2301 current_rule.skip_befores = false;
2302 let before_enabled = if is_open {
2303 current_rule.bo
2304 } else {
2305 current_rule.bc
2306 };
2307 let by_spec;
2312 let before_bindings: &[ActionBinding] = if skip_befores || !before_enabled {
2313 &[]
2314 } else {
2315 match prepared {
2316 Some(prepared) => prepared.before(is_open),
2317 None => {
2318 let (actions, callbacks, states, order) = if is_open {
2319 (&spec.bo, &spec.bo_fns, &spec.bo_state_fns, &spec.bo_order)
2320 } else {
2321 (&spec.bc, &spec.bc_fns, &spec.bc_state_fns, &spec.bc_order)
2322 };
2323 by_spec = resolved_action_order(actions, callbacks, states, order);
2324 &by_spec
2325 }
2326 }
2327 };
2328 if !before_bindings.is_empty() {
2329 let label = if is_open {
2330 "before-open action"
2331 } else {
2332 "before-close action"
2333 };
2334 let next = is_open.then(|| current_rule.snapshot());
2335 let site = ParseSite {
2336 source: src,
2337 stack: &stack,
2338 alts,
2339 };
2340 let mut output = None;
2341 let mut lifecycle_error = None;
2342 for binding in before_bindings {
2343 output = match binding {
2344 ActionBinding::Named(action) => {
2345 if let Some(callback) = self.state_actions.get(action) {
2346 self.run_state_callback(
2347 label,
2348 callback,
2349 &mut current_rule,
2350 &mut context,
2351 next.as_deref(),
2352 output,
2353 )
2354 .map_err(|error| {
2355 self.attach_action_error(
2356 error,
2357 src,
2358 ¤t_rule,
2359 &stack,
2360 alts,
2361 )
2362 })?
2363 } else {
2364 self.run_action(action, &mut current_rule, &mut context)
2365 .map_err(|error| {
2366 self.attach_action_error(
2367 error,
2368 src,
2369 ¤t_rule,
2370 &stack,
2371 alts,
2372 )
2373 })?;
2374 None
2375 }
2376 }
2377 ActionBinding::Callback(callback) => {
2378 self.run_context_callback(
2379 label,
2380 callback,
2381 &mut current_rule,
2382 &mut context,
2383 )
2384 .map_err(|error| {
2385 self.attach_action_error(error, src, ¤t_rule, &stack, alts)
2386 })?;
2387 None
2388 }
2389 ActionBinding::State(callback) => self
2390 .run_state_callback(
2391 label,
2392 callback,
2393 &mut current_rule,
2394 &mut context,
2395 next.as_deref(),
2396 output,
2397 )
2398 .map_err(|error| {
2399 self.attach_action_error(error, src, ¤t_rule, &stack, alts)
2400 })?,
2401 };
2402 match self.check_lifecycle_output(output, ¤t_rule, site) {
2403 Ok(next_output) => output = next_output,
2404 Err(error) => {
2405 lifecycle_error = Some(error);
2406 break;
2407 }
2408 }
2409 }
2410 if let Some(error) = lifecycle_error {
2411 update_partial(mode, &root_node, ¤t_rule, &stack);
2412 self.recover_error_pass(
2413 error,
2414 if is_open {
2415 RuleState::Open
2416 } else {
2417 RuleState::Close
2418 },
2419 None,
2420 false,
2421 src,
2422 &mut current_rule,
2423 &mut stack,
2424 &mut context,
2425 &mut lexer,
2426 mode,
2427 )?;
2428 continue 'parse;
2429 }
2430 }
2431 update_partial(mode, &root_node, ¤t_rule, &stack);
2432
2433 let mut matched_alt_idx: Option<usize> = None;
2435 let mut matched_count = 0;
2436 matched.reset();
2439 let mut record_written = false;
2445 let mut matched_tokens: Option<Rc<Vec<Token>>> = None;
2448
2449 let groups_prepared = self.options.rule.include == self.prepared_include
2455 && self.options.rule.exclude == self.prepared_exclude;
2456
2457 let first_index = if self.options.lex.relex {
2466 None
2467 } else {
2468 prepared.map(|prepared| prepared.first(is_open))
2469 };
2470 let mut lists: Option<(&[usize], &[usize])> = None;
2474 let mut key_tin = TIN_BD;
2475 let (mut ni, mut wi) = (0, 0);
2476 let mut next_idx = 0;
2477 loop {
2478 if lists.is_none() {
2479 if let (Some(index), Some(t0)) = (first_index, context.t.first()) {
2480 if t0.tin != TIN_BD {
2481 key_tin = t0.tin;
2482 let named = index.named(key_tin);
2483 let wild = index.wild.as_slice();
2484 (ni, wi) = (0, 0);
2485 while ni < named.len() && named[ni] < next_idx {
2486 ni += 1;
2487 }
2488 while wi < wild.len() && wild[wi] < next_idx {
2489 wi += 1;
2490 }
2491 lists = Some((named, wild));
2492 }
2493 }
2494 }
2495 let idx = match lists {
2496 Some((named, wild)) => {
2497 let n = named.get(ni).copied().unwrap_or(alts.len());
2498 let w = wild.get(wi).copied().unwrap_or(alts.len());
2499 if alts.len() <= n && alts.len() <= w {
2500 break;
2502 }
2503 if n < w {
2504 ni += 1;
2505 n
2506 } else {
2507 wi += 1;
2508 w
2509 }
2510 }
2511 None => {
2512 if alts.len() <= next_idx {
2513 break;
2514 }
2515 next_idx += 1;
2516 next_idx - 1
2517 }
2518 };
2519 let alt = &alts[idx];
2520 let enabled = match prepared
2521 .filter(|_| groups_prepared)
2522 .and_then(|prepared| prepared.alt(is_open, idx))
2523 {
2524 Some(prepared_alt) => prepared_alt.groups,
2525 None => groups_enabled(alt, &self.options),
2526 };
2527 if !enabled {
2528 continue;
2529 }
2530 let s_len = alt.s.len();
2531 let mut alt_matches = true;
2532 if record_written {
2533 matched.reset();
2534 record_written = false;
2535 }
2536 let mut relex_undo: Option<RelexUndo> = None;
2537 for (pos, pos_tins) in alt.s.iter().enumerate() {
2538 if let Err(error) = self.ensure_lookahead(
2539 &mut lexer,
2540 &mut context,
2541 &mut current_rule,
2542 pos + 1,
2543 mode,
2544 ParseSite {
2545 source: src,
2546 stack: &stack,
2547 alts,
2548 },
2549 Fetch::Rule,
2550 ) {
2551 return Err(self.attach_error(error, ¤t_rule, &stack, alts, None));
2552 }
2553 let Some(token) = context.t.get(pos).cloned() else {
2554 alt_matches = false;
2555 break;
2556 };
2557 if !slot_matches(pos_tins, token.tin) {
2558 let recut = if self.options.lex.relex
2559 && !token.src.is_empty()
2560 && !pos_tins.is_empty()
2561 {
2562 let result = self.catch_callback("lexer relex callback", src, || {
2563 lexer.relex(&token, pos_tins, &mut current_rule, &mut context)
2564 });
2565 result.map_err(|error| {
2566 self.attach_error(error, ¤t_rule, &stack, alts, Some(&token))
2567 })?
2568 } else {
2569 None
2570 };
2571 let Some((mut recut, checkpoint)) = recut else {
2572 alt_matches = false;
2573 break;
2574 };
2575 for subscriber in &self.lex_subscribers {
2576 let result = self.catch_callback("lex subscriber", src, || {
2577 subscriber(&mut recut, &mut current_rule, &mut context)
2578 });
2579 result.map_err(|error| {
2580 self.attach_error(error, ¤t_rule, &stack, alts, Some(&recut))
2581 })?;
2582 }
2583 if !pos_tins.contains(&recut.tin) {
2584 lexer.unrelex(checkpoint, &mut context);
2585 alt_matches = false;
2586 break;
2587 }
2588 if relex_undo.is_none() {
2589 relex_undo = Some(RelexUndo {
2590 position: pos,
2591 token,
2592 checkpoint,
2593 tokens: context.t.clone(),
2594 });
2595 }
2596 context.t[pos] = recut;
2597 context.t.truncate(pos + 1);
2598 }
2599 }
2600
2601 if alt_matches {
2602 let tokens: Rc<Vec<Token>> =
2603 Rc::new(context.t.iter().take(s_len).cloned().collect());
2604 if alt.c_ref.is_some() || !alt.c.is_empty() {
2612 let mut candidate = current_rule.clone();
2613 if is_open {
2614 candidate.o = Rc::clone(&tokens);
2615 } else {
2616 candidate.c = Rc::clone(&tokens);
2617 }
2618 if !builtin_condition_matches(alt.c_ref.as_deref(), &candidate)
2619 || !conditions_match(&alt.c, &candidate, &stack)
2620 {
2621 alt_matches = false;
2622 }
2623 }
2624 if alt_matches {
2625 if is_open {
2626 current_rule.o = Rc::clone(&tokens);
2627 } else {
2628 current_rule.c = Rc::clone(&tokens);
2629 }
2630 if let Some(condition) = &alt.c_fn {
2631 context.set_rule(¤t_rule);
2632 let result = self.catch_callback("alternate condition", src, || {
2633 condition(&mut current_rule, &mut context)
2634 });
2635 alt_matches = result.map_err(|error| {
2636 self.attach_error(
2637 error,
2638 ¤t_rule,
2639 &stack,
2640 alts,
2641 Self::phase_token(¤t_rule),
2642 )
2643 })?;
2644 }
2645 if alt_matches {
2646 if let Some(condition) = &alt.c_match {
2647 context.set_rule(¤t_rule);
2648 record_written = true;
2649 let result =
2650 self.catch_callback("matched alternate condition", src, || {
2651 condition(&mut current_rule, &mut context, &mut matched)
2652 });
2653 alt_matches = result.map_err(|error| {
2654 self.attach_error(
2655 error,
2656 ¤t_rule,
2657 &stack,
2658 alts,
2659 Self::phase_token(¤t_rule),
2660 )
2661 })?;
2662 }
2663 }
2664 if alt_matches {
2665 if let Some(condition) = &alt.c_lex_match {
2666 context.set_rule(¤t_rule);
2667 record_written = true;
2668 let result = self.catch_callback(
2669 "matched alternate lexer condition",
2670 src,
2671 || {
2672 condition(
2673 &mut current_rule,
2674 &mut context,
2675 &mut matched,
2676 &mut lexer,
2677 )
2678 },
2679 );
2680 alt_matches = result.map_err(|error| {
2681 self.attach_error(
2682 error,
2683 ¤t_rule,
2684 &stack,
2685 alts,
2686 Self::phase_token(¤t_rule),
2687 )
2688 })?;
2689 }
2690 }
2691 if alt_matches {
2692 if let Some(condition) = &alt.c_lex {
2693 context.set_rule(¤t_rule);
2694 let result =
2695 self.catch_callback("alternate lexer condition", src, || {
2696 condition(&mut current_rule, &mut context, &mut lexer)
2697 });
2698 alt_matches = result.map_err(|error| {
2699 self.attach_error(
2700 error,
2701 ¤t_rule,
2702 &stack,
2703 alts,
2704 Self::phase_token(¤t_rule),
2705 )
2706 })?;
2707 }
2708 }
2709 }
2710 if alt_matches {
2711 matched_alt_idx = Some(idx);
2712 matched_count = s_len;
2713 if alt.c_fn.is_none() && alt.c_match.is_none() {
2723 matched_tokens = Some(Rc::clone(&tokens));
2724 }
2725 break;
2726 }
2727 }
2728 if let Some(undo) = relex_undo {
2729 lexer.unrelex(undo.checkpoint, &mut context);
2730 context.t = undo.tokens;
2731 for subscriber in &self.lex_subscribers {
2732 let mut restored = undo.token.clone();
2733 let result = self.catch_callback("lex subscriber", src, || {
2734 subscriber(&mut restored, &mut current_rule, &mut context)
2735 });
2736 result.map_err(|error| {
2737 self.attach_error(error, ¤t_rule, &stack, alts, Some(&restored))
2738 })?;
2739 }
2740 debug_assert_eq!(context.t.get(undo.position), Some(&undo.token));
2741 }
2742 if lists.is_some() && context.t.first().map(|t0| t0.tin) != Some(key_tin) {
2748 lists = None;
2749 next_idx = idx + 1;
2750 }
2751 }
2752
2753 if let Some(idx) = matched_alt_idx {
2754 let matched_tokens = matched_tokens.unwrap_or_else(|| {
2756 Rc::new(context.t.iter().take(matched_count).cloned().collect())
2757 });
2758 if is_open {
2759 current_rule.o = matched_tokens;
2760 } else {
2761 current_rule.c = matched_tokens;
2762 }
2763
2764 let rewritten: AltSpec;
2775 let alt: &AltSpec = if let Some(modifier) = alts[idx].h.clone() {
2776 context.set_rule(¤t_rule);
2777 let source = alts[idx].clone();
2778 let result = self.catch_callback("alternate modifier", src, || {
2779 modifier(source, &mut current_rule, &mut context)
2780 });
2781 rewritten = result.map_err(|error| {
2782 self.attach_error(
2783 error,
2784 ¤t_rule,
2785 &stack,
2786 alts,
2787 Self::phase_token(¤t_rule),
2788 )
2789 })?;
2790 &rewritten
2791 } else {
2792 &alts[idx]
2793 };
2794
2795 matched.h = alt.h_match.clone();
2796 if !alt.n.is_empty() {
2797 matched.n = alt.n.clone();
2798 }
2799 if !alt.u.is_empty() {
2800 matched.u = alt.u.clone();
2801 }
2802 if !alt.k.is_empty() {
2803 matched.k = alt.k.clone();
2804 }
2805 let prepared_alt = if alts[idx].h.is_some() {
2811 None
2812 } else {
2813 prepared.and_then(|prepared| prepared.alt(is_open, idx))
2814 };
2815 match prepared_alt {
2816 Some(prepared_alt) => matched.g.clone_from(&prepared_alt.group_tags),
2820 None if !alt.g.is_empty() => {
2821 matched.g = listed(&alt.g).map(str::to_owned).collect();
2822 }
2823 None => {}
2824 }
2825 let prepared_alt = prepared_alt.filter(|prepared_alt| {
2835 !prepared_alt.observed
2836 && (!prepared_alt.named || self.matched_actions.is_empty())
2837 });
2838 if prepared_alt.is_none() {
2839 let actions = resolved_alt_action_order(
2840 &alt.a,
2841 &alt.action_fns,
2842 &alt.matched_action_fns,
2843 &alt.action_order,
2844 );
2845 if !actions.is_empty() {
2846 matched.actions = actions;
2847 }
2848 }
2849 if !alt.action_configs.is_empty() {
2850 matched.action_configs = alt.action_configs.clone();
2851 }
2852
2853 if let Some(route) = &alt.p_fn {
2854 context.set_rule(¤t_rule);
2855 matched.p = self
2856 .catch_callback("alternate push", src, || {
2857 route(&mut current_rule, &mut context)
2858 })
2859 .map_err(|error| {
2860 self.attach_error(
2861 error,
2862 ¤t_rule,
2863 &stack,
2864 alts,
2865 Self::phase_token(¤t_rule),
2866 )
2867 })?
2868 .filter(|name| !name.is_empty());
2869 }
2870 if let Some(route) = &alt.p_match {
2871 context.set_rule(¤t_rule);
2872 matched.p = self
2873 .catch_callback("matched alternate push", src, || {
2874 route(&mut current_rule, &mut context, &mut matched)
2875 })
2876 .map_err(|error| {
2877 self.attach_error(
2878 error,
2879 ¤t_rule,
2880 &stack,
2881 alts,
2882 Self::phase_token(¤t_rule),
2883 )
2884 })?
2885 .filter(|name| !name.is_empty());
2886 } else if alt.p_fn.is_none() {
2887 if let Some(route) = alt.p.clone() {
2888 matched.p = (!route.is_empty()).then_some(route);
2889 }
2890 }
2891 if let Some(route) = &alt.r_fn {
2892 context.set_rule(¤t_rule);
2893 matched.r = self
2894 .catch_callback("alternate replace", src, || {
2895 route(&mut current_rule, &mut context)
2896 })
2897 .map_err(|error| {
2898 self.attach_error(
2899 error,
2900 ¤t_rule,
2901 &stack,
2902 alts,
2903 Self::phase_token(¤t_rule),
2904 )
2905 })?
2906 .filter(|name| !name.is_empty());
2907 }
2908 if let Some(route) = &alt.r_match {
2909 context.set_rule(¤t_rule);
2910 matched.r = self
2911 .catch_callback("matched alternate replace", src, || {
2912 route(&mut current_rule, &mut context, &mut matched)
2913 })
2914 .map_err(|error| {
2915 self.attach_error(
2916 error,
2917 ¤t_rule,
2918 &stack,
2919 alts,
2920 Self::phase_token(¤t_rule),
2921 )
2922 })?
2923 .filter(|name| !name.is_empty());
2924 } else if alt.r_fn.is_none() {
2925 if let Some(route) = alt.r.clone() {
2926 matched.r = (!route.is_empty()).then_some(route);
2927 }
2928 }
2929 if let Some(backtrack) = &alt.b_fn {
2930 context.set_rule(¤t_rule);
2931 matched.b = self
2932 .catch_callback("alternate backtrack", src, || {
2933 backtrack(&mut current_rule, &mut context)
2934 })
2935 .map_err(|error| {
2936 self.attach_error(
2937 error,
2938 ¤t_rule,
2939 &stack,
2940 alts,
2941 Self::phase_token(¤t_rule),
2942 )
2943 })?;
2944 }
2945 if let Some(backtrack) = &alt.b_match {
2946 context.set_rule(¤t_rule);
2947 matched.b = self
2948 .catch_callback("matched alternate backtrack", src, || {
2949 backtrack(&mut current_rule, &mut context, &mut matched)
2950 })
2951 .map_err(|error| {
2952 self.attach_error(
2953 error,
2954 ¤t_rule,
2955 &stack,
2956 alts,
2957 Self::phase_token(¤t_rule),
2958 )
2959 })?;
2960 } else if alt.b_fn.is_none() && alt.b != 0 {
2961 matched.b = alt.b;
2962 }
2963
2964 if let Some(modifier) = alt.h_match.clone() {
2965 context.set_rule(¤t_rule);
2966 let next = is_open.then(|| current_rule.snapshot());
2967 matched = self
2968 .catch_callback("matched alternate modifier", src, || {
2969 modifier(
2970 std::mem::take(&mut matched),
2971 &mut current_rule,
2972 &mut context,
2973 next.as_deref(),
2974 )
2975 })
2976 .map_err(|error| {
2977 self.attach_error(
2978 error,
2979 ¤t_rule,
2980 &stack,
2981 alts,
2982 Self::phase_token(¤t_rule),
2983 )
2984 })?;
2985 }
2986
2987 if let Some(error_hook) = alt.e.clone() {
2994 context.set_rule(¤t_rule);
2995 let result = self.catch_callback("alternate error", src, || {
2996 error_hook(&mut current_rule, &mut context)
2997 });
2998 matched.e = result
2999 .map_err(|error| {
3000 self.attach_error(
3001 error,
3002 ¤t_rule,
3003 &stack,
3004 alts,
3005 Self::phase_token(¤t_rule),
3006 )
3007 })?
3008 .map(Box::new);
3009 }
3010 if let Some(error_hook) = alt.e_match.clone() {
3011 context.set_rule(¤t_rule);
3012 let result = self.catch_callback("matched alternate error", src, || {
3013 error_hook(&mut current_rule, &mut context, &mut matched)
3014 });
3015 matched.e = result
3016 .map_err(|error| {
3017 self.attach_error(
3018 error,
3019 ¤t_rule,
3020 &stack,
3021 alts,
3022 Self::phase_token(¤t_rule),
3023 )
3024 })?
3025 .map(Box::new);
3026 }
3027 if let Some(token) = matched.e.clone() {
3030 let code = raised_error_code(&token);
3031 let error = TabnasError::new(
3032 code,
3033 token.src.clone(),
3034 src,
3035 token.site.pos,
3036 token.site.ri,
3037 token.site.ci,
3038 );
3039 let done_alt = (!self.rule_done_subscribers.is_empty()).then(|| RuleDoneAlt {
3040 b: matched.b,
3041 g: matched.g.clone(),
3042 p: matched.p.clone().unwrap_or_default(),
3043 r: matched.r.clone().unwrap_or_default(),
3044 err: Some((*token).clone()),
3045 });
3046 let error = self.attach_error(error, ¤t_rule, &stack, alts, Some(&token));
3047 self.recover_error_pass(
3048 error,
3049 if is_open {
3050 RuleState::Open
3051 } else {
3052 RuleState::Close
3053 },
3054 done_alt,
3055 false,
3056 src,
3057 &mut current_rule,
3058 &mut stack,
3059 &mut context,
3060 &mut lexer,
3061 mode,
3062 )?;
3063 continue;
3064 }
3065
3066 for (k, v) in &matched.n {
3068 if *v == 0 {
3069 current_rule.n_mut().insert(k.clone(), 0);
3070 } else {
3071 *current_rule.n_mut().entry(k.clone()).or_insert(0) += *v;
3072 }
3073 }
3074
3075 for (k, v) in &matched.u {
3077 current_rule.u_mut().insert(k.clone(), v.clone());
3078 }
3079
3080 for (k, v) in &matched.k {
3082 current_rule.k_mut().insert(k.clone(), v.clone());
3083 }
3084
3085 let backtrack = matched.b;
3086 let consumed = matched_count.saturating_sub(backtrack);
3087 context.record_consumed(consumed);
3088
3089 let mut matched_action_error = None;
3093 let mut matched_action_token = None;
3094 let published;
3100 let bindings: &[AltActionBinding] = match prepared_alt {
3101 Some(prepared_alt) => &prepared_alt.actions,
3102 None => {
3103 published = matched.actions.clone();
3104 &published
3105 }
3106 };
3107 for binding in bindings {
3108 let act_name = match binding {
3109 AltActionBinding::Context(callback) => {
3110 self.run_context_callback(
3111 "alternate action",
3112 callback,
3113 &mut current_rule,
3114 &mut context,
3115 )
3116 .map_err(|error| {
3117 self.attach_action_error(error, src, ¤t_rule, &stack, alts)
3118 })?;
3119 continue;
3120 }
3121 AltActionBinding::Matched(callback) => {
3122 context.set_rule(¤t_rule);
3123 let result = self
3124 .catch_callback("matched alternate action", src, || {
3125 callback(&mut current_rule, &mut context, &mut matched)
3126 })
3127 .map_err(|error| {
3128 self.attach_action_error(
3129 error,
3130 src,
3131 ¤t_rule,
3132 &stack,
3133 alts,
3134 )
3135 })?;
3136 let token = result.map_err(|action_error| {
3137 self.attach_action_error(
3138 action_error.into(),
3139 src,
3140 ¤t_rule,
3141 &stack,
3142 alts,
3143 )
3144 })?;
3145 if let Some(token) = token.filter(|token| !token.err.is_empty()) {
3146 matched_action_error = Some(self.raised_token_error(
3147 &token,
3148 ¤t_rule,
3149 ParseSite {
3150 source: src,
3151 stack: &stack,
3152 alts,
3153 },
3154 ));
3155 matched_action_token = Some(token);
3156 break;
3157 }
3158 continue;
3159 }
3160 AltActionBinding::Named(name) => name,
3161 };
3162 if let Some(callback) = self.matched_actions.get(act_name) {
3163 context.set_rule(¤t_rule);
3164 let result = self
3165 .catch_callback("named matched alternate action", src, || {
3166 callback(&mut current_rule, &mut context, &mut matched)
3167 })
3168 .map_err(|error| {
3169 self.attach_action_error(error, src, ¤t_rule, &stack, alts)
3170 })?;
3171 let token = result.map_err(|action_error| {
3172 self.attach_action_error(
3173 action_error.into(),
3174 src,
3175 ¤t_rule,
3176 &stack,
3177 alts,
3178 )
3179 })?;
3180 if let Some(token) = token.filter(|token| !token.err.is_empty()) {
3181 matched_action_error = Some(self.raised_token_error(
3182 &token,
3183 ¤t_rule,
3184 ParseSite {
3185 source: src,
3186 stack: &stack,
3187 alts,
3188 },
3189 ));
3190 matched_action_token = Some(token);
3191 break;
3192 }
3193 continue;
3194 }
3195 match act_name.as_str() {
3196 "@probeInit$" => {
3197 current_rule
3198 .k_mut()
3199 .insert("pd_phase".into(), Value::Number(0.0));
3200 let mark = Value::Number(context.mark() as f64);
3201 current_rule.k_mut().insert("pd_mark".into(), mark);
3202 context.probe_open(¤t_rule);
3204 }
3205 "@probeDecide$" => {
3206 let mark = current_rule.k.get("pd_mark").and_then(|value| {
3207 if let Value::Number(mark) = value {
3208 usize::try_from(*mark as u64).ok()
3209 } else {
3210 None
3211 }
3212 });
3213 let Some(mark) = mark.filter(|mark| *mark <= context.v_abs) else {
3214 let mut error = TabnasError::new("internal", "", src, 0, 1, 1);
3215 error.detail =
3216 "@probeDecide$: phase-0 @probeInit$ did not record a valid mark"
3217 .into();
3218 return Err(error);
3219 };
3220 if let Err(error) = self.ensure_lookahead(
3221 &mut lexer,
3222 &mut context,
3223 &mut current_rule,
3224 1,
3225 mode,
3226 ParseSite {
3227 source: src,
3228 stack: &stack,
3229 alts,
3230 },
3231 Fetch::Rule,
3232 ) {
3233 return Err(self.attach_error(
3234 error,
3235 ¤t_rule,
3236 &stack,
3237 alts,
3238 None,
3239 ));
3240 }
3241 let disambiguator =
3242 current_rule.k.get("pd_d").and_then(|value| match value {
3243 Value::String(name) => Some(name.as_str()),
3244 _ => None,
3245 });
3246 let phase = if context
3247 .t
3248 .first()
3249 .is_some_and(|token| Some(token.name.as_str()) == disambiguator)
3250 {
3251 1.0
3252 } else {
3253 2.0
3254 };
3255 context.rewind(mark)?;
3256 current_rule
3257 .k_mut()
3258 .insert("pd_phase".into(), Value::Number(phase));
3259 context.probe_close();
3260 }
3261 _ => self
3262 .run_action_with_config(
3263 act_name,
3264 &mut current_rule,
3265 &mut context,
3266 matched.action_configs.get(act_name),
3267 )
3268 .map_err(|error| {
3269 self.attach_action_error(error, src, ¤t_rule, &stack, alts)
3270 })?,
3271 }
3272 }
3273 if let Some(error) = matched_action_error {
3274 let recovered_alt = Some(RuleDoneAlt {
3275 b: matched.b,
3276 g: matched.g.clone(),
3277 p: matched.p.clone().unwrap_or_default(),
3278 r: matched.r.clone().unwrap_or_default(),
3279 err: None,
3280 });
3281 self.recover_error_pass(
3282 error,
3283 if is_open {
3284 RuleState::Open
3285 } else {
3286 RuleState::Close
3287 },
3288 recovered_alt,
3289 matched_action_token.is_some(),
3290 src,
3291 &mut current_rule,
3292 &mut stack,
3293 &mut context,
3294 &mut lexer,
3295 mode,
3296 )?;
3297 update_partial(mode, &root_node, ¤t_rule, &stack);
3298 continue 'parse;
3299 }
3300 update_partial(mode, &root_node, ¤t_rule, &stack);
3301
3302 let push_name = matched.p.take();
3310 let replace_name = matched.r.take();
3311 let done_alt = (!self.rule_done_subscribers.is_empty()).then(|| RuleDoneAlt {
3316 b: matched.b,
3317 g: matched.g.clone(),
3318 p: push_name.clone().unwrap_or_default(),
3319 r: replace_name.clone().unwrap_or_default(),
3320 err: None,
3321 });
3322
3323 let mut route = match push_name.as_deref().or(replace_name.as_deref()) {
3342 Some(name) => match prepared
3343 .and_then(|prepared| prepared.alt(is_open, idx))
3344 .map(|alt| if push_name.is_some() { &alt.p } else { &alt.r })
3345 .and_then(|route| route.resolved(name))
3346 .or_else(|| self.installed(name))
3347 {
3348 Some(resolved) => Some(resolved),
3349 None => {
3350 let mut token = Self::phase_token(¤t_rule)
3351 .cloned()
3352 .or_else(|| context.t.first().cloned())
3353 .unwrap_or_else(Token::no_token);
3354 token.bad("unknown_rule");
3355 token
3356 .use_data_mut()
3357 .insert("rulename".into(), Value::String(name.to_string()));
3358 let error = self.raised_token_error(
3359 &token,
3360 ¤t_rule,
3361 ParseSite {
3362 source: src,
3363 stack: &stack,
3364 alts,
3365 },
3366 );
3367 self.recover_error_pass(
3368 error,
3369 if is_open {
3370 RuleState::Open
3371 } else {
3372 RuleState::Close
3373 },
3374 done_alt,
3375 false,
3376 src,
3377 &mut current_rule,
3378 &mut stack,
3379 &mut context,
3380 &mut lexer,
3381 mode,
3382 )?;
3383 update_partial(mode, &root_node, ¤t_rule, &stack);
3384 continue 'parse;
3385 }
3386 },
3387 None => None,
3388 };
3389
3390 let completed_rule: Option<Rule>;
3394 let mut completed_value = None;
3395 if push_name.is_some() {
3396 let (push_slot, push_shared, push_spec) =
3397 route.take().expect("a push route was resolved above");
3398 let mut child = Rule::bound(
3399 push_shared.clone(),
3400 current_rule.node.clone(),
3401 Some(push_spec),
3402 push_slot,
3403 );
3404 child.i = next_rule_id;
3405 next_rule_id += 1;
3406 child.d = stack.len() + 1;
3407 child.parent_node = Some(current_rule.node.clone());
3408 child.n = Rc::clone(¤t_rule.n);
3409 child.k = Rc::clone(¤t_rule.k);
3410 child.parent_rule = Some(bounded_history(
3411 current_rule.snapshot(),
3412 self.options.rule.history,
3413 Link::PusherBefore,
3414 ));
3415 current_rule.next_rule_name = Some(push_shared);
3416 current_rule.child_rule = Some(child.snapshot());
3417 current_rule.next_rule = current_rule.child_rule.clone();
3418 current_rule.note_child_push(&child);
3419 let linked = current_rule.child_rule.clone();
3422 let after = self.run_after_actions(
3423 spec,
3424 prepared,
3425 is_open,
3426 &mut current_rule,
3427 &mut context,
3428 ParseSite {
3429 source: src,
3430 stack: &stack,
3431 alts,
3432 },
3433 );
3434 update_partial(mode, &root_node, ¤t_rule, &stack);
3435 if self.recover_after_actions(
3436 after,
3437 if is_open {
3438 RuleState::Open
3439 } else {
3440 RuleState::Close
3441 },
3442 done_alt.clone(),
3443 src,
3444 &mut current_rule,
3445 &mut stack,
3446 &mut context,
3447 &mut lexer,
3448 mode,
3449 )? {
3450 continue 'parse;
3451 }
3452 if is_open {
3453 current_rule.state = RuleState::Close;
3454 }
3455 child.parent_rule = Some(bounded_history(
3456 current_rule.snapshot(),
3457 self.options.rule.history,
3458 Link::Parent,
3459 ));
3460 if crate::options::effective_rule_history(self.options.rule.history).is_none()
3480 && current_rule.links_unchanged(&linked)
3481 {
3482 current_rule.relink_child(&child);
3483 child.parent_rule = Some(current_rule.snapshot());
3484 }
3485 completed_rule = self.rule_done_copy(¤t_rule);
3486 if park_child_nodes {
3495 current_rule.park_child_node();
3496 }
3497 stack.push(current_rule);
3498 current_rule = child;
3499 } else if replace_name.is_some() {
3500 let (replace_slot, replace_shared, replace_spec) =
3501 route.take().expect("a replace route was resolved above");
3502 let mut next = Rule::bound(
3503 replace_shared.clone(),
3504 current_rule.node.clone(),
3505 Some(replace_spec),
3506 replace_slot,
3507 );
3508 next.i = next_rule_id;
3509 next_rule_id += 1;
3510 next.d = current_rule.d;
3511 next.parent_node = current_rule.parent_node.clone();
3512 next.parent_rule = current_rule.parent_rule.clone();
3513 next.n = Rc::clone(¤t_rule.n);
3514 next.k = Rc::clone(¤t_rule.k);
3515 current_rule.next_rule_name = Some(replace_shared);
3516 current_rule.next_rule = Some(next.snapshot());
3517 let after = self.run_after_actions(
3518 spec,
3519 prepared,
3520 is_open,
3521 &mut current_rule,
3522 &mut context,
3523 ParseSite {
3524 source: src,
3525 stack: &stack,
3526 alts,
3527 },
3528 );
3529 update_partial(mode, &root_node, ¤t_rule, &stack);
3530 if self.recover_after_actions(
3531 after,
3532 if is_open {
3533 RuleState::Open
3534 } else {
3535 RuleState::Close
3536 },
3537 done_alt.clone(),
3538 src,
3539 &mut current_rule,
3540 &mut stack,
3541 &mut context,
3542 &mut lexer,
3543 mode,
3544 )? {
3545 continue 'parse;
3546 }
3547 if is_open {
3548 current_rule.state = RuleState::Close;
3549 }
3550 next.prev_rule = Some(bounded_history(
3551 current_rule.snapshot(),
3552 self.options.rule.history,
3553 Link::Prev,
3554 ));
3555 if let Some(parent) = stack.last_mut() {
3562 parent.freeze_child(¤t_rule);
3563 }
3564 completed_rule = Some(current_rule);
3568 current_rule = next;
3569 } else if is_open {
3570 current_rule.next_rule_name = Some(current_rule.name.clone());
3571 current_rule.next_rule = Some(current_rule.snapshot());
3572 let after = self.run_after_actions(
3573 spec,
3574 prepared,
3575 true,
3576 &mut current_rule,
3577 &mut context,
3578 ParseSite {
3579 source: src,
3580 stack: &stack,
3581 alts,
3582 },
3583 );
3584 update_partial(mode, &root_node, ¤t_rule, &stack);
3585 if self.recover_after_actions(
3586 after,
3587 RuleState::Open,
3588 done_alt.clone(),
3589 src,
3590 &mut current_rule,
3591 &mut stack,
3592 &mut context,
3593 &mut lexer,
3594 mode,
3595 )? {
3596 continue 'parse;
3597 }
3598 current_rule.state = RuleState::Close;
3599 completed_rule = self.rule_done_copy(¤t_rule);
3600 } else {
3601 current_rule.next_rule_name = stack.last().map(|rule| rule.name.clone());
3603 current_rule.next_rule = stack.last().map(Rule::snapshot);
3604 let after = self.run_after_actions(
3605 spec,
3606 prepared,
3607 false,
3608 &mut current_rule,
3609 &mut context,
3610 ParseSite {
3611 source: src,
3612 stack: &stack,
3613 alts,
3614 },
3615 );
3616 update_partial(mode, &root_node, ¤t_rule, &stack);
3617 if self.recover_after_actions(
3618 after,
3619 RuleState::Close,
3620 done_alt.clone(),
3621 src,
3622 &mut current_rule,
3623 &mut stack,
3624 &mut context,
3625 &mut lexer,
3626 mode,
3627 )? {
3628 continue 'parse;
3629 }
3630 let parent = stack.pop();
3631 completed_rule = self.rule_done_copy(¤t_rule);
3632 if let Some(mut parent) = parent {
3633 parent.accept_child(¤t_rule);
3634 bound_child_link(&mut parent, self.options.rule.history);
3635 current_rule = parent;
3636 } else {
3637 completed_value = Some(current_rule.node.borrow().clone());
3639 }
3640 }
3641 let probe = context.probe_take() || probe_at_start;
3645 if let Some(completed_rule) = &completed_rule {
3646 self.notify_rule_done(
3647 completed_rule,
3648 &context,
3649 if is_open {
3650 RuleState::Open
3651 } else {
3652 RuleState::Close
3653 },
3654 done_alt,
3655 probe,
3656 src,
3657 &stack,
3658 )?;
3659 }
3660 if let Some(value) = completed_value {
3661 final_value = Some(value);
3662 break;
3663 }
3664 update_partial(mode, &root_node, ¤t_rule, &stack);
3665 } else if alts.is_empty() {
3666 let completed_rule: Option<Rule>;
3669 let mut completed_value = None;
3670 if is_open {
3671 current_rule.next_rule_name = Some(current_rule.name.clone());
3672 current_rule.next_rule = Some(current_rule.snapshot());
3673 let after = self.run_after_actions(
3674 spec,
3675 prepared,
3676 true,
3677 &mut current_rule,
3678 &mut context,
3679 ParseSite {
3680 source: src,
3681 stack: &stack,
3682 alts,
3683 },
3684 );
3685 update_partial(mode, &root_node, ¤t_rule, &stack);
3686 if self.recover_after_actions(
3687 after,
3688 RuleState::Open,
3689 None,
3690 src,
3691 &mut current_rule,
3692 &mut stack,
3693 &mut context,
3694 &mut lexer,
3695 mode,
3696 )? {
3697 continue 'parse;
3698 }
3699 current_rule.state = RuleState::Close;
3700 completed_rule = self.rule_done_copy(¤t_rule);
3701 } else {
3702 current_rule.next_rule_name = stack.last().map(|rule| rule.name.clone());
3703 current_rule.next_rule = stack.last().map(Rule::snapshot);
3704 let after = self.run_after_actions(
3705 spec,
3706 prepared,
3707 false,
3708 &mut current_rule,
3709 &mut context,
3710 ParseSite {
3711 source: src,
3712 stack: &stack,
3713 alts,
3714 },
3715 );
3716 update_partial(mode, &root_node, ¤t_rule, &stack);
3717 if self.recover_after_actions(
3718 after,
3719 RuleState::Close,
3720 None,
3721 src,
3722 &mut current_rule,
3723 &mut stack,
3724 &mut context,
3725 &mut lexer,
3726 mode,
3727 )? {
3728 continue 'parse;
3729 }
3730 let parent = stack.pop();
3731 completed_rule = self.rule_done_copy(¤t_rule);
3732 if let Some(mut parent) = parent {
3733 parent.accept_child(¤t_rule);
3734 bound_child_link(&mut parent, self.options.rule.history);
3735 current_rule = parent;
3736 } else {
3737 completed_value = Some(current_rule.node.borrow().clone());
3738 }
3739 }
3740 let probe = context.probe_take() || probe_at_start;
3741 if let Some(completed_rule) = &completed_rule {
3742 self.notify_rule_done(
3743 completed_rule,
3744 &context,
3745 if is_open {
3746 RuleState::Open
3747 } else {
3748 RuleState::Close
3749 },
3750 None,
3751 probe,
3752 src,
3753 &stack,
3754 )?;
3755 }
3756 if let Some(value) = completed_value {
3757 final_value = Some(value);
3758 break;
3759 }
3760 update_partial(mode, &root_node, ¤t_rule, &stack);
3761 } else {
3762 if is_open {
3764 if let Err(error) = self.ensure_lookahead(
3765 &mut lexer,
3766 &mut context,
3767 &mut current_rule,
3768 1,
3769 mode,
3770 ParseSite {
3771 source: src,
3772 stack: &stack,
3773 alts,
3774 },
3775 Fetch::Rule,
3776 ) {
3777 return Err(self.attach_error(error, ¤t_rule, &stack, alts, None));
3778 }
3779 if let Some(capture) = mode.continuation.as_deref_mut() {
3780 let base = failed_alt_tins(&context, alts, &self.options);
3781 capture.failure = continuation_tins(
3782 &context,
3783 ¤t_rule,
3784 &stack,
3785 &self.rules,
3786 &self.options,
3787 0,
3788 Some(&base),
3789 );
3790 }
3791 let t0 = context.t.first().cloned();
3792 let (src_token, si, ri, ci) = if let Some(t) = t0.as_ref() {
3793 (t.src.to_string(), t.site.pos, t.site.ri, t.site.ci)
3794 } else {
3795 (String::new(), src.len(), 1, 1)
3796 };
3797 let code = t0
3798 .as_ref()
3799 .map_or("unexpected", |t| deferred_error_code(t, mode.recovering));
3800 let error = TabnasError::new(code, src_token, src, si, ri, ci);
3801 let done_alt = (!alts.is_empty() && !self.rule_done_subscribers.is_empty())
3802 .then(|| RuleDoneAlt {
3803 b: 0,
3804 g: Vec::new(),
3805 p: String::new(),
3806 r: String::new(),
3807 err: t0.clone(),
3808 });
3809 let error = self.attach_error(error, ¤t_rule, &stack, alts, t0.as_ref());
3810 self.recover_error_pass(
3811 error,
3812 RuleState::Open,
3813 done_alt,
3814 false,
3815 src,
3816 &mut current_rule,
3817 &mut stack,
3818 &mut context,
3819 &mut lexer,
3820 mode,
3821 )?;
3822 continue;
3823 } else {
3824 if let Err(error) = self.ensure_lookahead(
3825 &mut lexer,
3826 &mut context,
3827 &mut current_rule,
3828 1,
3829 mode,
3830 ParseSite {
3831 source: src,
3832 stack: &stack,
3833 alts,
3834 },
3835 Fetch::Rule,
3836 ) {
3837 return Err(self.attach_error(error, ¤t_rule, &stack, alts, None));
3838 }
3839 if let Some(capture) = mode.continuation.as_deref_mut() {
3840 let base = failed_alt_tins(&context, alts, &self.options);
3841 capture.failure = continuation_tins(
3842 &context,
3843 ¤t_rule,
3844 &stack,
3845 &self.rules,
3846 &self.options,
3847 0,
3848 Some(&base),
3849 );
3850 }
3851 let token = context.t.first().cloned();
3852 let (source, pos, row, col) = token.as_ref().map_or_else(
3853 || (String::new(), src.chars().count(), 1, 1),
3854 |value| {
3855 (
3856 value.src.to_string(),
3857 value.site.pos,
3858 value.site.ri,
3859 value.site.ci,
3860 )
3861 },
3862 );
3863 let code = token
3864 .as_ref()
3865 .map_or("unexpected", |t| deferred_error_code(t, mode.recovering));
3866 let error = TabnasError::new(code, source, src, pos, row, col);
3867 let done_alt = Some(RuleDoneAlt {
3868 b: 0,
3869 g: Vec::new(),
3870 p: String::new(),
3871 r: String::new(),
3872 err: token.clone(),
3873 });
3874 let error =
3875 self.attach_error(error, ¤t_rule, &stack, alts, token.as_ref());
3876 self.recover_error_pass(
3877 error,
3878 RuleState::Close,
3879 done_alt,
3880 false,
3881 src,
3882 &mut current_rule,
3883 &mut stack,
3884 &mut context,
3885 &mut lexer,
3886 mode,
3887 )?;
3888 continue;
3889 }
3890 }
3891 }
3892
3893 let res = final_value.unwrap_or(Value::Null).unwrap_undefined();
3894 if mode.recovering {
3895 mode.partial = Some(PartialValue::Complete(res.clone()));
3896 }
3897
3898 if let Err(error) = self.ensure_lookahead(
3904 &mut lexer,
3905 &mut context,
3906 &mut current_rule,
3907 1,
3908 mode,
3909 ParseSite {
3910 source: src,
3911 stack: &stack,
3912 alts: &[],
3913 },
3914 Fetch::Trailing,
3915 ) {
3916 let error = self.attach_error(error, ¤t_rule, &stack, &[], None);
3917 if mode.recovering {
3918 mode.errors.push(error.clone());
3919 context.errs.push(error);
3920 return Ok(res);
3921 }
3922 return Err(error);
3923 }
3924 if let Some(t0) = context.t.first() {
3925 if t0.tin != TIN_ZZ {
3926 let code = if t0.tin == TIN_BD && !t0.why.is_empty() {
3927 t0.why.as_str()
3928 } else {
3929 "unexpected"
3930 };
3931 let error =
3932 TabnasError::new(code, &*t0.src, src, t0.site.pos, t0.site.ri, t0.site.ci);
3933 let error = self.attach_error(
3934 error,
3935 ¤t_rule,
3936 &stack,
3937 &[AltSpec {
3938 s: vec![vec![TIN_ZZ]],
3939 ..Default::default()
3940 }],
3941 Some(t0),
3942 );
3943 if mode.recovering {
3944 mode.errors.push(error.clone());
3945 context.errs.push(error);
3946 return Ok(res);
3947 }
3948 return Err(error);
3949 }
3950 }
3951 if self
3952 .options
3953 .result
3954 .fail
3955 .iter()
3956 .any(|failed| failed.deep_equal(&res))
3957 {
3958 let token = context.t.first();
3959 let error = token.map_or_else(
3960 || TabnasError::new("unexpected", "", src, 0, 1, 1),
3961 |token| {
3962 TabnasError::new(
3963 "unexpected",
3964 &*token.src,
3965 src,
3966 token.site.pos,
3967 token.site.ri,
3968 token.site.ci,
3969 )
3970 },
3971 );
3972 if mode.recovering {
3973 mode.errors.push(error.clone());
3974 context.errs.push(error);
3975 return Ok(res);
3976 }
3977 return Err(error);
3978 }
3979 Ok(res)
3980 }
3981}
3982
3983#[inline]
4003fn update_partial(
4004 mode: &mut ParseMode<'_>,
4005 root_node: &Rc<RefCell<Value>>,
4006 current_rule: &Rule,
4007 stack: &[Rule],
4008) {
4009 if mode.recovering {
4010 mode.partial = best_partial_node(root_node, current_rule, stack).map(PartialValue::Node);
4011 }
4012}
4013
4014#[inline(never)]
4015fn best_partial_node(
4016 root_node: &Rc<RefCell<Value>>,
4017 current_rule: &Rule,
4018 stack: &[Rule],
4019) -> Option<Rc<RefCell<Value>>> {
4020 let usable = |node: &Rc<RefCell<Value>>| {
4021 (!matches!(*node.borrow(), Value::Undefined | Value::Null)).then(|| Rc::clone(node))
4022 };
4023
4024 usable(root_node)
4025 .or_else(|| stack.iter().find_map(|rule| usable(&rule.node)))
4026 .or_else(|| usable(¤t_rule.node))
4027}
4028
4029fn error_token(error: &TabnasError) -> Token {
4030 let byte_position = error
4031 .full_source
4032 .char_indices()
4033 .nth(error.pos)
4034 .map_or(error.full_source.len(), |(index, _)| index);
4035 let mut token = Token::new(
4036 "#BD",
4037 TIN_BD,
4038 Value::Undefined,
4039 error.src.clone(),
4040 crate::Point {
4041 len: error.len,
4042 site: crate::Site {
4043 si: byte_position,
4044 pos: error.pos,
4045 ri: error.row,
4046 ci: error.col,
4047 },
4048 },
4049 );
4050 token.err = crate::TokenCode::from(error.code.as_str());
4051 token.why = token.err.clone();
4052 token
4053}
4054
4055fn deferred_error_code(token: &Token, recovering: bool) -> &str {
4065 if token.tin != TIN_BD {
4066 "unexpected"
4067 } else if recovering && !token.err.is_empty() {
4068 &token.err
4069 } else if !token.why.is_empty() {
4070 &token.why
4071 } else {
4072 "unexpected"
4073 }
4074}
4075
4076fn raised_error_code(token: &Token) -> &str {
4077 if !token.err.is_empty() {
4078 &token.err
4079 } else if !token.why.is_empty() {
4080 &token.why
4081 } else {
4082 "unexpected"
4083 }
4084}
4085
4086fn mid_construct(code: &str) -> bool {
4087 matches!(code, "unprintable" | "invalid_unicode" | "invalid_ascii")
4088}
4089
4090fn absorb_lex_error(
4099 error: &TabnasError,
4100 context: &mut Context,
4101 options: &Options,
4102 errors: &mut Vec<TabnasError>,
4103) -> bool {
4104 let recover = &options.parse.recover;
4105 let run = context
4106 .bad_error
4107 .filter(|index| *index < errors.len())
4108 .filter(|_| context.bad_to.is_some_and(|bad_to| error.pos <= bad_to));
4109 if let Some(index) = run {
4110 let previous = &mut errors[index];
4111 let recovered = previous.recovered.get_or_insert(crate::RecoveredAt {
4112 skipped: 0,
4113 sync: None,
4114 bad: true,
4115 });
4116 recovered.skipped = recovered.skipped.saturating_add(1);
4117 let skipped = recovered.skipped;
4118 if let Some(context_previous) = context.errs.get_mut(index) {
4119 *context_previous = previous.clone();
4120 }
4121 if recover.max_skip < skipped {
4122 return false;
4123 }
4124 } else if context
4125 .recover_at
4126 .is_some_and(|at| context.v_abs.saturating_sub(at) < recover.suppress)
4127 {
4128 context.bad_error = None;
4129 } else {
4130 let mut recorded = error.clone();
4131 recorded.recovered = Some(crate::RecoveredAt {
4132 skipped: 1,
4133 sync: None,
4134 bad: true,
4135 });
4136 errors.push(recorded.clone());
4137 context.errs.push(recorded);
4138 context.bad_error = Some(errors.len() - 1);
4139 context.recover_at = Some(context.v_abs);
4140 }
4141 context.bad_to = Some(error.pos.saturating_add(error.len.max(1)));
4142 errors.len() <= recover.max_recoveries
4143}
4144
4145fn slot_matches(slot: &[Tin], tin: Tin) -> bool {
4146 tin != TIN_BD && (slot.is_empty() || slot.contains(&tin) || slot.contains(&TIN_AA))
4147}
4148
4149fn alt_match_depth(alt: &AltSpec, context: &Context) -> usize {
4150 let mut depth = 0;
4151 while depth < alt.s.len() {
4152 let Some(token) = context.t.get(depth) else {
4153 break;
4154 };
4155 if !slot_matches(&alt.s[depth], token.tin) {
4156 break;
4157 }
4158 depth += 1;
4159 }
4160 depth
4161}
4162
4163fn completion_tins(slot: &[Tin]) -> impl Iterator<Item = Tin> + '_ {
4164 slot.iter()
4165 .copied()
4166 .chain(slot.is_empty().then_some(TIN_AA))
4167}
4168
4169fn failed_alt_tins(context: &Context, alts: &[AltSpec], options: &Options) -> Vec<Tin> {
4170 let mut out = BTreeSet::new();
4171 for alt in alts {
4172 if !groups_enabled(alt, options) {
4173 continue;
4174 }
4175 let depth = alt_match_depth(alt, context);
4176 if let Some(slot) = alt.s.get(depth) {
4177 out.extend(completion_tins(slot));
4178 }
4179 }
4180 out.into_iter().collect()
4181}
4182
4183fn lead_tins(alts: &[AltSpec], options: &Options, out: &mut BTreeSet<Tin>) {
4184 for alt in alts {
4185 if !groups_enabled(alt, options) {
4186 continue;
4187 }
4188 if let Some(slot) = alt.s.first() {
4189 out.extend(completion_tins(slot));
4190 }
4191 }
4192}
4193
4194fn has_empty_close(spec: &RuleSpec, options: &Options) -> bool {
4195 spec.close
4196 .iter()
4197 .any(|alt| groups_enabled(alt, options) && alt.s.is_empty())
4198}
4199
4200fn alt_has_sync_group(alt: &AltSpec, sync_groups: &[String]) -> bool {
4201 alt.g
4202 .split(',')
4203 .map(str::trim)
4204 .any(|tag| sync_groups.iter().any(|wanted| wanted == tag))
4205}
4206
4207fn add_close_tins(
4208 rule: &Rule,
4209 rules: &IndexMap<String, Arc<RuleSpec>>,
4210 options: &Options,
4211 tagged_only: bool,
4212 out: &mut BTreeSet<Tin>,
4213) {
4214 let Some(spec) = rules.get(&*rule.name) else {
4215 return;
4216 };
4217 for alt in &spec.close {
4218 if !groups_enabled(alt, options)
4219 || (tagged_only && !alt_has_sync_group(alt, &options.parse.recover.sync_groups))
4220 {
4221 continue;
4222 }
4223 if let Some(slot) = alt.s.first() {
4224 out.extend(completion_tins(slot));
4225 }
4226 }
4227}
4228
4229fn compute_sync_tins(
4230 rule: &Rule,
4231 stack: &[Rule],
4232 rules: &IndexMap<String, Arc<RuleSpec>>,
4233 options: &Options,
4234) -> BTreeSet<Tin> {
4235 let mut out = BTreeSet::new();
4236 add_close_tins(rule, rules, options, true, &mut out);
4237 for parent in stack.iter().rev() {
4238 add_close_tins(parent, rules, options, true, &mut out);
4239 }
4240 if out.is_empty() {
4241 add_close_tins(rule, rules, options, false, &mut out);
4242 for parent in stack.iter().rev() {
4243 add_close_tins(parent, rules, options, false, &mut out);
4244 }
4245 }
4246 for name in &options.parse.recover.sync_tokens {
4247 if let Some(tin) = options.token(name) {
4248 out.insert(tin);
4249 }
4250 if let Some(tins) = options.token_set.get(name.trim_start_matches('#')) {
4251 out.extend(tins.iter().copied());
4252 }
4253 }
4254 out
4255}
4256
4257fn accepts_close(
4258 rule: &Rule,
4259 tin: Tin,
4260 rules: &IndexMap<String, Arc<RuleSpec>>,
4261 options: &Options,
4262) -> bool {
4263 rules.get(&*rule.name).is_some_and(|spec| {
4264 spec.close.iter().any(|alt| {
4265 groups_enabled(alt, options)
4266 && (alt.s.is_empty() || alt.s.first().is_some_and(|slot| slot_matches(slot, tin)))
4267 })
4268 })
4269}
4270
4271fn add_openers(
4272 name: &str,
4273 rules: &IndexMap<String, Arc<RuleSpec>>,
4274 options: &Options,
4275 opened: &mut BTreeSet<String>,
4276 out: &mut BTreeSet<Tin>,
4277) {
4278 if name.is_empty() || !opened.insert(name.to_owned()) {
4279 return;
4280 }
4281 let Some(spec) = rules.get(name) else {
4282 return;
4283 };
4284 lead_tins(&spec.open, options, out);
4285 for alt in &spec.open {
4286 if !groups_enabled(alt, options) || !alt.s.is_empty() {
4287 continue;
4288 }
4289 if let Some(push) = alt.p.as_deref() {
4290 add_openers(push, rules, options, opened, out);
4291 }
4292 if let Some(replace) = alt.r.as_deref() {
4293 add_openers(replace, rules, options, opened, out);
4294 }
4295 }
4296}
4297
4298fn continuation_tins(
4299 context: &Context,
4300 rule: &Rule,
4301 stack: &[Rule],
4302 rules: &IndexMap<String, Arc<RuleSpec>>,
4303 options: &Options,
4304 query_pos: usize,
4305 failed: Option<&[Tin]>,
4306) -> Vec<Tin> {
4307 let Some(spec) = rules.get(&*rule.name) else {
4308 return Vec::new();
4309 };
4310 let state_alts = if rule.state == RuleState::Open {
4311 &spec.open
4312 } else {
4313 &spec.close
4314 };
4315 let mut out = BTreeSet::new();
4316
4317 if let Some(failed) = failed.filter(|tins| !tins.is_empty()) {
4318 out.extend(failed.iter().copied());
4319 } else {
4320 for alt in state_alts {
4321 if !groups_enabled(alt, options) {
4322 continue;
4323 }
4324 let depth = alt_match_depth(alt, context);
4325 if depth == query_pos {
4326 if let Some(slot) = alt.s.get(depth) {
4327 out.extend(completion_tins(slot));
4328 }
4329 }
4330 }
4331 }
4332
4333 let mut close_rule = rule;
4336 let mut parent_index = stack.len();
4337 while let Some(close_spec) = rules.get(&*close_rule.name) {
4338 if !has_empty_close(close_spec, options) || parent_index == 0 {
4339 break;
4340 }
4341 parent_index -= 1;
4342 let parent = &stack[parent_index];
4343 if let Some(parent_spec) = rules.get(&*parent.name) {
4344 lead_tins(&parent_spec.close, options, &mut out);
4345 }
4346 close_rule = parent;
4347 }
4348
4349 let mut opened = BTreeSet::new();
4352 for alt in state_alts {
4353 if !groups_enabled(alt, options) || alt_match_depth(alt, context) != alt.s.len() {
4354 continue;
4355 }
4356 if alt.b_fn.is_some() {
4359 continue;
4360 }
4361 if alt.s.len().checked_sub(alt.b) != Some(query_pos) {
4362 continue;
4363 }
4364 if let Some(push) = alt.p.as_deref() {
4365 add_openers(push, rules, options, &mut opened, &mut out);
4366 }
4367 if let Some(replace) = alt.r.as_deref() {
4368 add_openers(replace, rules, options, &mut opened, &mut out);
4369 }
4370 }
4371
4372 out.into_iter().collect()
4373}
4374
4375fn listed(list: &str) -> impl Iterator<Item = &str> {
4381 list.split(',')
4382 .map(str::trim)
4383 .filter(|entry| !entry.is_empty())
4384}
4385
4386pub(crate) fn groups_enabled(alt: &AltSpec, options: &Options) -> bool {
4387 let include = options.rule.include.as_str();
4392 let exclude = options.rule.exclude.as_str();
4393 if include.is_empty() && exclude.is_empty() {
4394 return true;
4395 }
4396 let declares = |wanted: &str| listed(&alt.g).any(|group| group == wanted);
4403 let included = listed(include).next().is_none() || listed(include).any(&declares);
4404 included && !listed(exclude).any(&declares)
4405}
4406
4407fn builtin_condition_matches(reference: Option<&str>, rule: &Rule) -> bool {
4408 let phase = match rule.k.get("pd_phase") {
4409 Some(Value::Number(value)) => *value as i32,
4410 _ => 0,
4411 };
4412 match reference {
4413 None => true,
4414 Some("@probePhase0$") => phase == 0,
4415 Some("@probePhase1$") => phase == 1,
4416 Some("@probePhase2$") => phase == 2,
4417 Some(_) => false,
4418 }
4419}
4420
4421fn conditions_match(conditions: &[Condition], rule: &Rule, ancestors: &[Rule]) -> bool {
4422 conditions.iter().all(|condition| {
4423 let resolved = resolve_condition_path(rule, ancestors, &condition.path);
4424 if condition.op == CompareOp::Exist {
4425 let exists = condition_exists(rule, ancestors, &condition.path);
4426 let wanted = matches!(condition.value, Value::Bool(true));
4427 return exists == wanted;
4428 }
4429 let Some(actual) = resolved else {
4430 return !matches!(condition.op, CompareOp::Eq);
4431 };
4432 match condition.op {
4433 CompareOp::Eq => actual.deep_equal(&condition.value),
4434 CompareOp::Ne => !actual.deep_equal(&condition.value),
4435 CompareOp::Lt => ordered(&actual, &condition.value).is_none_or(|value| value < 0),
4436 CompareOp::Lte => ordered(&actual, &condition.value).is_none_or(|value| value <= 0),
4437 CompareOp::Gt => ordered(&actual, &condition.value).is_none_or(|value| value > 0),
4438 CompareOp::Gte => ordered(&actual, &condition.value).is_none_or(|value| value >= 0),
4439 CompareOp::Exist => unreachable!("handled above"),
4440 }
4441 })
4442}
4443
4444fn ordered(left: &Value, right: &Value) -> Option<i8> {
4445 match (left, right) {
4446 (Value::Number(left), Value::Number(right)) => Some(if left < right {
4447 -1
4448 } else if left > right {
4449 1
4450 } else {
4451 0
4452 }),
4453 (Value::String(left), Value::String(right)) => Some(match left.cmp(right) {
4454 std::cmp::Ordering::Less => -1,
4455 std::cmp::Ordering::Equal => 0,
4456 std::cmp::Ordering::Greater => 1,
4457 }),
4458 _ => None,
4459 }
4460}
4461
4462fn condition_exists(rule: &Rule, ancestors: &[Rule], path: &[String]) -> bool {
4463 if path.first().map(String::as_str) == Some("n") && path.len() == 2 {
4464 rule.n.contains_key(&path[1])
4465 } else if path.first().map(String::as_str) == Some("parent") {
4466 ancestors
4467 .split_last()
4468 .is_some_and(|(parent, parent_ancestors)| {
4469 condition_exists(parent, parent_ancestors, &path[1..])
4470 })
4471 } else if path.first().map(String::as_str) == Some("child") {
4472 rule.child_rule
4473 .as_deref()
4474 .is_some_and(|child| snapshot_condition_exists(child, &path[1..]))
4475 } else if path.first().map(String::as_str) == Some("prev") {
4476 rule.prev_rule
4477 .as_deref()
4478 .is_some_and(|prev| snapshot_condition_exists(prev, &path[1..]))
4479 } else if path.first().map(String::as_str) == Some("next") {
4480 if let Some(next) = rule.next_rule.as_deref() {
4481 snapshot_condition_exists(next, &path[1..])
4482 } else if rule.next_rule_name.as_deref() == Some(&*rule.name) {
4483 condition_exists(rule, ancestors, &path[1..])
4484 } else {
4485 false
4486 }
4487 } else {
4488 resolve_condition_path(rule, ancestors, path).is_some()
4489 }
4490}
4491
4492fn resolve_condition_path(rule: &Rule, ancestors: &[Rule], path: &[String]) -> Option<Value> {
4493 let root = path.first()?.as_str();
4494 let rest = &path[1..];
4495 match root {
4496 "n" if rest.len() == 1 => Some(Value::Number(*rule.n.get(&rest[0]).unwrap_or(&0) as f64)),
4497 "u" => map_path(&rule.u, rest),
4498 "k" => map_path(&rule.k, rest),
4499 "d" if rest.is_empty() => Some(Value::Number(rule.d as f64)),
4500 "i" if rest.is_empty() => Some(Value::Number(rule.i as f64)),
4501 "name" if rest.is_empty() => Some(Value::String(rule.name.to_string())),
4502 "state" if rest.is_empty() => Some(Value::String(
4503 match rule.state {
4504 RuleState::Open => "o",
4505 RuleState::Close => "c",
4506 }
4507 .into(),
4508 )),
4509 "node" => value_path(rule.node.borrow().clone(), rest),
4510 "need" if rest.is_empty() => Some(Value::Number(rule.need as f64)),
4511 "oN" if rest.is_empty() => Some(Value::Number(rule.o.len() as f64)),
4512 "cN" if rest.is_empty() => Some(Value::Number(rule.c.len() as f64)),
4513 "o" => token_list_path(&rule.o, rest),
4514 "c" => token_list_path(&rule.c, rest),
4515 "o0" => token_path(rule.o.first(), rest),
4516 "o1" => token_path(rule.o.get(1), rest),
4517 "c0" => token_path(rule.c.first(), rest),
4518 "c1" => token_path(rule.c.get(1), rest),
4519 "parent" => {
4520 let (parent, parent_ancestors) = ancestors.split_last()?;
4521 resolve_condition_path(parent, parent_ancestors, rest)
4522 }
4523 "child" => resolve_snapshot_path(rule.child_rule.as_deref()?, rest),
4524 "prev" => resolve_snapshot_path(rule.prev_rule.as_deref()?, rest),
4525 "next" => {
4526 if let Some(next) = rule.next_rule.as_deref() {
4527 resolve_snapshot_path(next, rest)
4528 } else if rule.next_rule_name.as_deref() == Some(&*rule.name) {
4529 resolve_condition_path(rule, ancestors, rest)
4530 } else {
4531 None
4532 }
4533 }
4534 "spec" if rest == ["name"] => Some(Value::String(rule.name.to_string())),
4535 _ => None,
4536 }
4537}
4538
4539#[derive(Clone, Copy, PartialEq, Eq)]
4541enum Link {
4542 Parent,
4545 PusherBefore,
4557 Prev,
4559}
4560
4561fn bounded_history(
4594 snapshot: Rc<RuleSnapshot>,
4595 history: Option<usize>,
4596 link: Link,
4597) -> Rc<RuleSnapshot> {
4598 let Some(history) = crate::options::effective_rule_history(history) else {
4599 return snapshot;
4600 };
4601 let mut links: Vec<&Rc<RuleSnapshot>> = Vec::with_capacity(history);
4607 let mut current = Some(&snapshot);
4608 while let Some(snapshot) = current {
4609 if links.len() == history {
4610 break;
4611 }
4612 links.push(snapshot);
4613 current = snapshot.prev_rule.as_ref();
4614 }
4615 let mut prev: Option<Rc<RuleSnapshot>> = None;
4616 for (depth, original) in links.into_iter().enumerate().rev() {
4618 let mut copy = (**original).clone();
4619 if depth != 0 || link != Link::Parent {
4620 copy.child_rule = None;
4621 copy.next_rule = None;
4622 copy.next_rule_name = None;
4623 }
4624 copy.prev_rule = prev.take();
4625 prev = Some(Rc::new(copy));
4626 }
4627 prev.expect("at least the snapshot itself is copied")
4628}
4629
4630fn bound_child_link(rule: &mut Rule, history: Option<usize>) {
4638 if crate::options::effective_rule_history(history).is_none() {
4639 return;
4640 }
4641 if let Some(record) = rule.child_rule.take() {
4642 let bounded = bounded_history(record, history, Link::Prev);
4643 rule.next_rule = Some(Rc::clone(&bounded));
4644 rule.child_rule = Some(bounded);
4645 }
4646}
4647
4648fn snapshot_condition_exists(rule: &RuleSnapshot, path: &[String]) -> bool {
4649 if path.first().map(String::as_str) == Some("n") && path.len() == 2 {
4650 rule.n.contains_key(&path[1])
4651 } else if path.first().map(String::as_str) == Some("parent") {
4652 rule.parent_rule
4653 .as_deref()
4654 .is_some_and(|parent| snapshot_condition_exists(parent, &path[1..]))
4655 } else if path.first().map(String::as_str) == Some("child") {
4656 rule.child_rule
4657 .as_deref()
4658 .is_some_and(|child| snapshot_condition_exists(child, &path[1..]))
4659 } else if path.first().map(String::as_str) == Some("prev") {
4660 rule.prev_rule
4661 .as_deref()
4662 .is_some_and(|prev| snapshot_condition_exists(prev, &path[1..]))
4663 } else if path.first().map(String::as_str) == Some("next") {
4664 if let Some(next) = rule.next_rule.as_deref() {
4665 snapshot_condition_exists(next, &path[1..])
4666 } else if rule.next_rule_name.as_deref() == Some(&*rule.name) {
4667 snapshot_condition_exists(rule, &path[1..])
4668 } else {
4669 false
4670 }
4671 } else {
4672 resolve_snapshot_path(rule, path).is_some()
4673 }
4674}
4675
4676fn resolve_snapshot_path(rule: &RuleSnapshot, path: &[String]) -> Option<Value> {
4677 let root = path.first()?.as_str();
4678 let rest = &path[1..];
4679 match root {
4680 "n" if rest.len() == 1 => Some(Value::Number(*rule.n.get(&rest[0]).unwrap_or(&0) as f64)),
4681 "u" => map_path(&rule.u, rest),
4682 "k" => map_path(&rule.k, rest),
4683 "d" if rest.is_empty() => Some(Value::Number(rule.d as f64)),
4684 "i" if rest.is_empty() => Some(Value::Number(rule.i as f64)),
4685 "name" if rest.is_empty() => Some(Value::String(rule.name.to_string())),
4686 "state" if rest.is_empty() => Some(Value::String(
4687 match rule.state {
4688 RuleState::Open => "o",
4689 RuleState::Close => "c",
4690 }
4691 .into(),
4692 )),
4693 "node" => value_path(rule.node.borrow().clone(), rest),
4694 "need" if rest.is_empty() => Some(Value::Number(rule.need as f64)),
4695 "oN" if rest.is_empty() => Some(Value::Number(rule.o.len() as f64)),
4696 "cN" if rest.is_empty() => Some(Value::Number(rule.c.len() as f64)),
4697 "o" => token_list_path(&rule.o, rest),
4698 "c" => token_list_path(&rule.c, rest),
4699 "o0" => token_path(rule.o.first(), rest),
4700 "o1" => token_path(rule.o.get(1), rest),
4701 "c0" => token_path(rule.c.first(), rest),
4702 "c1" => token_path(rule.c.get(1), rest),
4703 "parent" => resolve_snapshot_path(rule.parent_rule.as_deref()?, rest),
4704 "child" => resolve_snapshot_path(rule.child_rule.as_deref()?, rest),
4705 "prev" => resolve_snapshot_path(rule.prev_rule.as_deref()?, rest),
4706 "next" => {
4707 if let Some(next) = rule.next_rule.as_deref() {
4708 resolve_snapshot_path(next, rest)
4709 } else if rule.next_rule_name.as_deref() == Some(&*rule.name) {
4710 resolve_snapshot_path(rule, rest)
4711 } else {
4712 None
4713 }
4714 }
4715 "spec" if rest == ["name"] => Some(Value::String(rule.name.to_string())),
4716 _ => None,
4717 }
4718}
4719
4720fn map_path(map: &HashMap<String, Value>, path: &[String]) -> Option<Value> {
4721 let (name, rest) = path.split_first()?;
4722 value_path(map.get(name)?.clone(), rest)
4723}
4724
4725fn value_path(mut value: Value, path: &[String]) -> Option<Value> {
4726 for part in path {
4727 value = match value {
4728 Value::Object(map) => map.get(part)?.clone(),
4729 Value::Array(items) => items.get(part.parse::<usize>().ok()?)?.clone(),
4730 _ => return None,
4731 };
4732 }
4733 Some(value)
4734}
4735
4736fn token_list_path(tokens: &[Token], path: &[String]) -> Option<Value> {
4737 let (index, rest) = path.split_first()?;
4738 token_path(tokens.get(index.parse::<usize>().ok()?), rest)
4739}
4740
4741fn token_path(token: Option<&Token>, path: &[String]) -> Option<Value> {
4742 let token = token?;
4743 if path.is_empty() {
4744 let mut value = IndexMap::new();
4745 value.insert("tin".into(), Value::Number(token.tin as f64));
4746 value.insert("name".into(), Value::String(token.name.to_string()));
4747 value.insert("src".into(), Value::String(token.src.to_string()));
4748 value.insert("val".into(), token.val.clone());
4749 value.insert("why".into(), Value::String(token.why.to_string()));
4750 return Some(Value::object(value));
4751 }
4752 let (field, rest) = path.split_first()?;
4753 let value = match field.as_str() {
4754 "tin" => Value::Number(token.tin as f64),
4755 "name" => Value::String(token.name.to_string()),
4756 "src" => Value::String(token.src.to_string()),
4757 "val" => token.val.clone(),
4758 "why" => Value::String(token.why.to_string()),
4759 _ => return None,
4760 };
4761 value_path(value, rest)
4762}
4763
4764#[cfg(test)]
4765mod tests {
4766 use super::*;
4767
4768 #[test]
4778 fn replacing_a_rule_replaces_the_tables_derived_from_it() {
4779 let mut parser = Parser::new(crate::Options::default());
4780
4781 let mut first = RuleSpec::new("val");
4782 first.bo.push("@enter".into());
4783 first.open.push(AltSpec {
4784 s: vec![vec![crate::TIN_NR]],
4785 a: vec!["@act".into()],
4786 ..Default::default()
4787 });
4788 parser.add_rule(first);
4789 let slot = parser
4790 .rules()
4791 .get_index_of("val")
4792 .expect("the rule was just installed");
4793 assert_eq!(parser.expected_tins[slot].at(true, 0), [crate::TIN_NR]);
4794 assert_eq!(&*parser.names[slot], "val");
4795 assert_eq!(parser.prepared[slot].before(true).len(), 1);
4796 assert_eq!(parser.prepared[slot].open[0].actions.len(), 1);
4797
4798 let mut second = RuleSpec::new("val");
4799 second.open.push(AltSpec {
4800 s: vec![vec![crate::TIN_ST]],
4801 ..Default::default()
4802 });
4803 parser.add_rule(second);
4804
4805 assert_eq!(parser.rules().len(), 1, "a replacement, not an addition");
4806 assert_eq!(
4807 parser.expected_tins[slot].at(true, 0),
4808 [crate::TIN_ST],
4809 "lookahead would still expect the replaced rule's tokens"
4810 );
4811 assert_eq!(parser.names.len(), 1, "one rule, one shared name");
4816 assert_eq!(parser.rules().get_index_of("val"), Some(slot));
4817 assert_eq!(&*parser.names[slot], "val");
4818 assert_eq!(parser.prepared.len(), 1);
4824 assert_eq!(&*parser.prepared[slot].name, "val");
4825 assert!(Arc::ptr_eq(
4826 &parser.prepared[slot].spec,
4827 &parser.rules()["val"]
4828 ));
4829 assert!(parser.prepared[slot].before(true).is_empty());
4834 assert!(parser.prepared[slot].open[0].actions.is_empty());
4835 assert!(!parser.prepared[slot].open[0].named);
4836 }
4837
4838 #[test]
4846 fn expected_match_tins_follows_the_rule_name_when_the_slot_goes_stale() {
4847 fn rule_named(name: &str, tin: Tin) -> RuleSpec {
4848 let mut spec = RuleSpec::new(name);
4849 spec.open.push(AltSpec {
4850 s: vec![vec![tin]],
4851 ..Default::default()
4852 });
4853 spec
4854 }
4855
4856 let mut options = crate::Options::default();
4857 let tin = options.register_token("#QQ");
4858 options.match_tokens.insert(
4859 "#QQ".into(),
4860 crate::options::MatchToken {
4861 name: "#QQ".into(),
4862 tin,
4863 matcher: crate::options::MatchTokenMatcher::Regex(regex::Regex::new("^q").unwrap()),
4864 eager: false,
4865 },
4866 );
4867 let mut parser = Parser::new(options);
4868 parser.add_rule(rule_named("val", crate::TIN_NR));
4869 parser.add_rule(rule_named("other", crate::TIN_ST));
4870
4871 let val_slot = parser.rules().get_index_of("val").expect("installed");
4872 let other_slot = parser.rules().get_index_of("other").expect("installed");
4873 assert_ne!(val_slot, other_slot);
4874
4875 let mut rule = Rule::new("val", Value::Undefined);
4878 rule.bind_spec(
4879 &parser.rules()["val"],
4880 parser.names[val_slot].clone(),
4881 val_slot,
4882 );
4883 assert_eq!(&*parser.expected_match_tins(&rule, 0), [crate::TIN_NR]);
4884
4885 rule.name = parser.names[other_slot].clone();
4890 assert_eq!(
4891 &*parser.expected_match_tins(&rule, 0),
4892 [crate::TIN_ST],
4893 "the rule is called `other` now, so `other`'s row answers"
4894 );
4895
4896 rule.name = parser.names[val_slot].clone();
4900 rule.spec = Arc::clone(&parser.rules()["other"]);
4901 assert_eq!(
4902 &*parser.expected_match_tins(&rule, 0),
4903 [crate::TIN_NR],
4904 "still called `val`, so still gated by `val`'s row"
4905 );
4906
4907 let ghost = Rule::new("ghost", Value::Undefined);
4910 assert_eq!(
4911 &*parser.expected_match_tins(&ghost, 0),
4912 &[] as &[Tin],
4913 "an uninstalled name has no row, not another rule's"
4914 );
4915 }
4916
4917 #[test]
4925 fn expected_match_tins_is_empty_until_a_match_token_exists() {
4926 fn val_rule() -> RuleSpec {
4927 let mut spec = RuleSpec::new("val");
4928 spec.open.push(AltSpec {
4929 s: vec![vec![crate::TIN_NR]],
4930 ..Default::default()
4931 });
4932 spec
4933 }
4934 let rule = Rule::new("val", Value::Undefined);
4935
4936 let mut without = Parser::new(crate::Options::default());
4937 without.add_rule(val_rule());
4938 assert!(without.options.match_tokens.is_empty());
4939 assert_eq!(without.expected_tins[0].at(true, 0), [crate::TIN_NR]);
4940 assert_eq!(
4941 &*without.expected_match_tins(&rule, 0),
4942 &[] as &[Tin],
4943 "no custom matcher: nothing to gate, so nothing to look up"
4944 );
4945
4946 let mut options = crate::Options::default();
4947 let tin = options.register_token("#QQ");
4948 options.match_tokens.insert(
4949 "#QQ".into(),
4950 crate::options::MatchToken {
4951 name: "#QQ".into(),
4952 tin,
4953 matcher: crate::options::MatchTokenMatcher::Regex(regex::Regex::new("^q").unwrap()),
4954 eager: false,
4955 },
4956 );
4957 let mut with = Parser::new(options);
4958 with.add_rule(val_rule());
4959 assert_eq!(
4960 &*with.expected_match_tins(&rule, 0),
4961 [crate::TIN_NR],
4962 "a custom matcher is present, so the slot's tins gate it"
4963 );
4964 assert_eq!(
4965 &*with.expected_match_tins(&rule, 1),
4966 &[] as &[Tin],
4967 "a slot the rule never fills expects nothing"
4968 );
4969 }
4970}