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 self.parse_with_owner_from(src, None, meta, owner, parent)
1555 }
1556
1557 pub(crate) fn parse_reader_for(
1564 &self,
1565 owner: Option<&crate::Tabnas>,
1566 mut reader: Box<dyn std::io::Read + '_>,
1567 sizes: crate::lexer::WindowSizes,
1568 meta: Value,
1569 ) -> Result<Value, TabnasError> {
1570 let whole = !self.options.lex.window
1571 || self.options.parser.start_with_context.is_some()
1572 || self.options.parser.start_with_instance.is_some()
1573 || self.options.parser.start.is_some()
1574 || self.options.parse.recover.enabled;
1575 if whole {
1576 let text = read_whole(&mut reader).map_err(|mut error| {
1577 self.decorate_error(&mut error);
1578 error
1579 })?;
1580 return self.parse_with_owner(&text, meta, owner, None);
1581 }
1582 let source = crate::lexer::ReaderSource::new(reader, sizes);
1583 self.parse_with_owner_from("", Some(source), meta, owner, None)
1584 }
1585
1586 fn parse_with_owner_from(
1587 &self,
1588 src: &str,
1589 reader: Option<crate::lexer::ReaderSource<'_>>,
1590 meta: Value,
1591 owner: Option<&crate::Tabnas>,
1592 parent: Option<&ContextSeed>,
1593 ) -> Result<Value, TabnasError> {
1594 match catch_unwind(AssertUnwindSafe(|| {
1595 self.parse_uncaught(src, reader, meta, owner, parent)
1596 })) {
1597 Ok(result) => result,
1598 Err(payload) => {
1599 let mut error =
1600 TabnasError::from_panic(payload, "Parser::parse", src, 0, 1, 1, &self.options);
1601 self.decorate_error(&mut error);
1602 Err(error)
1603 }
1604 }
1605 }
1606
1607 fn parse_uncaught(
1608 &self,
1609 src: &str,
1610 reader: Option<crate::lexer::ReaderSource<'_>>,
1611 meta: Value,
1612 owner: Option<&crate::Tabnas>,
1613 parent: Option<&ContextSeed>,
1614 ) -> Result<Value, TabnasError> {
1615 if let Some(result) = self.run_parser_start(src, &meta, owner, parent) {
1616 return result.map_err(|mut error| {
1617 self.decorate_error(&mut error);
1618 error
1619 });
1620 }
1621 let mut errors = Vec::new();
1622 let recovering = self.options.parse.recover.enabled;
1623 let mut mode = ParseMode {
1624 continuation: None,
1625 recovering,
1626 errors: &mut errors,
1627 partial: None,
1628 gave_up: false,
1629 };
1630 let excerpt = reader
1634 .as_ref()
1635 .map(|source| std::rc::Rc::clone(&source.excerpt));
1636 let result = self
1637 .parse_inner(src, reader, meta, owner, parent, &mut mode)
1638 .map_err(|mut error| {
1639 if error.full_source.is_empty() {
1640 if let Some((text, row, col)) =
1641 excerpt.and_then(|cell| cell.borrow_mut().take())
1642 {
1643 error.set_excerpt(text, row, col);
1644 }
1645 }
1646 self.decorate_error(&mut error);
1647 error
1648 });
1649 match result {
1650 Err(_) if recovering => Ok(mode
1651 .partial
1652 .and_then(PartialValue::into_value)
1653 .unwrap_or(Value::Undefined)),
1654 other => other,
1655 }
1656 }
1657
1658 pub fn parse_recover(&self, src: &str) -> ParseRecovery {
1659 self.parse_recover_with_meta(src, Value::Undefined)
1660 }
1661
1662 pub fn parse_recover_with_meta(&self, src: &str, meta: Value) -> ParseRecovery {
1663 self.parse_recover_with_owner(src, meta, None, None)
1664 }
1665
1666 pub(crate) fn parse_recover_for(
1667 &self,
1668 owner: &crate::Tabnas,
1669 src: &str,
1670 meta: Value,
1671 ) -> ParseRecovery {
1672 self.parse_recover_with_owner(src, meta, Some(owner), None)
1673 }
1674
1675 pub(crate) fn parse_recover_for_with_context(
1676 &self,
1677 owner: &crate::Tabnas,
1678 src: &str,
1679 meta: Value,
1680 parent: &ContextSeed,
1681 ) -> ParseRecovery {
1682 self.parse_recover_with_owner(src, meta, Some(owner), Some(parent))
1683 }
1684
1685 fn parse_recover_with_owner(
1686 &self,
1687 src: &str,
1688 meta: Value,
1689 owner: Option<&crate::Tabnas>,
1690 parent: Option<&ContextSeed>,
1691 ) -> ParseRecovery {
1692 match catch_unwind(AssertUnwindSafe(|| {
1693 self.parse_recover_uncaught(src, meta, owner, parent)
1694 })) {
1695 Ok(result) => result,
1696 Err(payload) => {
1697 let mut error = TabnasError::from_panic(
1698 payload,
1699 "Parser::parse_recover",
1700 src,
1701 0,
1702 1,
1703 1,
1704 &self.options,
1705 );
1706 self.decorate_error(&mut error);
1707 ParseRecovery {
1708 value: None,
1709 errors: Vec::new(),
1710 fatal: Some(error),
1711 }
1712 }
1713 }
1714 }
1715
1716 fn parse_recover_uncaught(
1717 &self,
1718 src: &str,
1719 meta: Value,
1720 owner: Option<&crate::Tabnas>,
1721 parent: Option<&ContextSeed>,
1722 ) -> ParseRecovery {
1723 if let Some(result) = self.run_parser_start(src, &meta, owner, parent) {
1724 return match result {
1725 Ok(value) => ParseRecovery {
1726 value: Some(value),
1727 errors: Vec::new(),
1728 fatal: None,
1729 },
1730 Err(mut error) => {
1731 self.decorate_error(&mut error);
1732 ParseRecovery {
1733 value: None,
1734 errors: Vec::new(),
1735 fatal: Some(error),
1736 }
1737 }
1738 };
1739 }
1740 let mut errors = Vec::new();
1741 let recovering = self.options.parse.recover.enabled;
1742 let (result, partial, gave_up) = {
1743 let mut mode = ParseMode {
1744 continuation: None,
1745 recovering,
1746 errors: &mut errors,
1747 partial: None,
1748 gave_up: false,
1749 };
1750 let result = self
1751 .parse_inner(src, None, meta, owner, parent, &mut mode)
1752 .map_err(|mut error| {
1753 self.decorate_error(&mut error);
1754 error
1755 });
1756 (
1757 result,
1758 mode.partial.and_then(PartialValue::into_value),
1759 mode.gave_up,
1760 )
1761 };
1762 for error in &mut errors {
1763 self.decorate_error(error);
1764 }
1765 match result {
1766 Ok(value) => ParseRecovery {
1767 value: Some(value),
1768 errors,
1769 fatal: None,
1770 },
1771 Err(error) => {
1772 if !gave_up {
1776 errors.push(error.clone());
1777 }
1778 ParseRecovery {
1779 value: recovering.then_some(partial).flatten(),
1780 errors,
1781 fatal: (!recovering).then_some(error),
1782 }
1783 }
1784 }
1785 }
1786
1787 fn run_parser_start(
1788 &self,
1789 src: &str,
1790 meta: &Value,
1791 owner: Option<&crate::Tabnas>,
1792 parent: Option<&ContextSeed>,
1793 ) -> Option<Result<Value, TabnasError>> {
1794 let result = if let Some(start) = self.options.parser.start_with_context.as_ref() {
1795 let Some(owner) = owner else {
1796 let mut error = TabnasError::new("internal", "", src, 0, 1, 1);
1797 error.detail =
1798 "parser.start requires an owning Tabnas instance; call Tabnas::parse".into();
1799 self.decorate_error(&mut error);
1800 return Some(Err(error));
1801 };
1802 catch_unwind(AssertUnwindSafe(|| start(src, owner, meta, parent)))
1803 } else if let Some(start) = self.options.parser.start_with_instance.as_ref() {
1804 let Some(owner) = owner else {
1805 let mut error = TabnasError::new("internal", "", src, 0, 1, 1);
1806 error.detail =
1807 "parser.start requires an owning Tabnas instance; call Tabnas::parse".into();
1808 self.decorate_error(&mut error);
1809 return Some(Err(error));
1810 };
1811 catch_unwind(AssertUnwindSafe(|| start(src, owner, meta)))
1812 } else {
1813 let start = self.options.parser.start.as_ref()?;
1814 catch_unwind(AssertUnwindSafe(|| start(src)))
1815 };
1816 Some(match result {
1817 Ok(result) => result.map_err(|error| *error),
1818 Err(payload) => Err(TabnasError::from_panic(
1819 payload,
1820 "parser.start",
1821 src,
1822 0,
1823 1,
1824 1,
1825 &self.options,
1826 )),
1827 })
1828 }
1829
1830 pub fn continuations(&self, src: &str) -> Continuations {
1834 self.continuations_with_owner(src, None)
1835 }
1836
1837 pub(crate) fn continuations_for(&self, owner: &crate::Tabnas, src: &str) -> Continuations {
1838 self.continuations_with_owner(src, Some(owner))
1839 }
1840
1841 fn continuations_with_owner(&self, src: &str, owner: Option<&crate::Tabnas>) -> Continuations {
1842 catch_unwind(AssertUnwindSafe(|| self.continuations_uncaught(src, owner)))
1843 .unwrap_or_else(|_| self.start_continuations())
1844 }
1845
1846 fn continuations_uncaught(&self, src: &str, owner: Option<&crate::Tabnas>) -> Continuations {
1847 let mut capture = ContinuationCapture::default();
1848 let mut errors = Vec::new();
1849 let result = {
1850 let mut mode = ParseMode {
1851 continuation: Some(&mut capture),
1852 recovering: false,
1853 errors: &mut errors,
1854 partial: None,
1855 gave_up: false,
1856 };
1857 self.parse_inner(src, None, Value::Undefined, owner, None, &mut mode)
1858 };
1859 let mut tins = if result.is_ok() {
1860 if capture.have_end {
1861 capture.at_end.insert(TIN_ZZ);
1862 capture.at_end.into_iter().collect()
1863 } else {
1864 self.start_openers()
1865 }
1866 } else if capture.failure.is_empty() {
1867 self.start_openers()
1868 } else {
1869 capture.failure
1870 };
1871 tins.sort_unstable();
1872 tins.dedup();
1873 let tokens = tins
1874 .iter()
1875 .map(|tin| self.options.token_name(*tin))
1876 .collect();
1877 Continuations { tins, tokens }
1878 }
1879
1880 fn start_continuations(&self) -> Continuations {
1881 let tins = self.start_openers();
1882 let tokens = tins
1883 .iter()
1884 .map(|tin| self.options.token_name(*tin))
1885 .collect();
1886 Continuations { tins, tokens }
1887 }
1888
1889 fn start_openers(&self) -> Vec<Tin> {
1890 let start = self.rules.get(&self.options.rule.start);
1891 let mut out = BTreeSet::new();
1892 if let Some(spec) = start {
1893 for alt in &spec.open {
1894 if groups_enabled(alt, &self.options) {
1895 if let Some(slot) = alt.s.first() {
1896 out.extend(completion_tins(slot));
1897 }
1898 }
1899 }
1900 }
1901 out.into_iter().collect()
1902 }
1903
1904 fn expected_match_tins(&self, rule: &Rule, slot: usize) -> Cow<'_, [Tin]> {
1929 if self.options.match_tokens.is_empty() {
1930 return Cow::Borrowed(&[]);
1931 }
1932 let index = match self.names.get(rule.slot) {
1940 Some(installed) if *installed == rule.name => rule.slot,
1941 _ => match self.rules.get_index_of(&*rule.name) {
1942 Some(index) => index,
1943 None => return Cow::Borrowed(&[]),
1944 },
1945 };
1946 let is_open = rule.state == RuleState::Open;
1947 if self.options.rule.include == self.prepared_include
1948 && self.options.rule.exclude == self.prepared_exclude
1949 {
1950 return Cow::Borrowed(self.expected_tins[index].at(is_open, slot));
1951 }
1952 let installed = &self.rules[index];
1953 let alts = if is_open {
1954 &installed.open
1955 } else {
1956 &installed.close
1957 };
1958 Cow::Owned(ExpectedTins::live(alts, &self.options, slot))
1959 }
1960
1961 fn capture_fetch_failure(
1975 &self,
1976 context: &Context,
1977 rule: &Rule,
1978 stack: &[Rule],
1979 mode: &mut ParseMode<'_>,
1980 fetch: Fetch,
1981 ) {
1982 if fetch != Fetch::Rule {
1983 return;
1984 }
1985 if let Some(capture) = mode.continuation.as_deref_mut() {
1986 capture.failure =
1987 continuation_tins(context, rule, stack, &self.rules, &self.options, 0, None);
1988 }
1989 }
1990
1991 #[allow(clippy::too_many_arguments)]
1992 fn ensure_lookahead(
1993 &self,
1994 lexer: &mut Lexer,
1995 context: &mut Context,
1996 rule: &mut Rule,
1997 count: usize,
1998 mode: &mut ParseMode<'_>,
1999 site: ParseSite<'_>,
2000 fetch: Fetch,
2001 ) -> Result<(), TabnasError> {
2002 if lexer.may_release() {
2007 let floor = lexer.release_floor();
2008 lexer.release_before(context.oldest_held(floor).unwrap_or(usize::MAX));
2009 }
2010 while context.t.len() < count {
2011 if context.t.last().is_some_and(|token| token.tin == TIN_ZZ) {
2012 break;
2013 }
2014 let expected_match_tins = self.expected_match_tins(rule, context.t.len());
2015 let token = loop {
2016 let next = match context.next_replay() {
2017 Some(token) => Ok(token),
2018 None => {
2019 let result = self.catch_callback("lexer callback", site.source, || {
2020 lexer.next_rule_token(&expected_match_tins, rule, context)
2021 });
2022 result.map_err(|error| {
2023 self.attach_active_error(
2024 error,
2025 rule,
2026 site.stack,
2027 Self::phase_token(rule),
2028 )
2029 })?
2030 }
2031 };
2032 let mut token = match next {
2033 Ok(token) => token,
2034 Err(error) => error_token(&error),
2044 };
2045 for subscriber in &self.lex_subscribers {
2046 let result = self.catch_callback("lex subscriber", site.source, || {
2047 subscriber(&mut token, rule, context)
2048 });
2049 result.map_err(|error| {
2050 self.attach_active_error(error, rule, site.stack, Some(&token))
2051 })?;
2052 }
2053 if token.tin == TIN_BD && !self.options.lex.relex {
2066 let code = if token.why.is_empty() {
2067 "unexpected"
2068 } else {
2069 token.why.as_str()
2070 };
2071 let error = TabnasError::new(
2072 code,
2073 token.src.clone(),
2074 site.source,
2075 token.site.pos,
2076 token.site.ri,
2077 token.site.ci,
2078 );
2079 let error = self.attach_error(error, rule, site.stack, site.alts, Some(&token));
2080 if mode.recovering && fetch == Fetch::Rule {
2081 if absorb_lex_error(&error, context, &self.options, mode.errors) {
2082 lexer.skip_bad(&token, mid_construct(&error.code));
2083 continue;
2084 }
2085 mode.gave_up = true;
2086 }
2087 self.capture_fetch_failure(context, rule, site.stack, mode, fetch);
2088 return Err(error);
2089 }
2090 if token.tin == TIN_ZZ {
2091 if let Some(capture) = mode.continuation.as_deref_mut() {
2092 capture.have_end = true;
2100 if fetch == Fetch::Rule {
2101 capture.at_end.extend(continuation_tins(
2102 context,
2103 rule,
2104 site.stack,
2105 &self.rules,
2106 &self.options,
2107 context.t.len(),
2108 None,
2109 ));
2110 }
2111 }
2112 }
2113 if !self.ignore_tins.contains(&token.tin) {
2114 break token;
2115 }
2116 };
2117 for subscriber in &self.token_subscribers {
2118 let result =
2119 self.catch_callback("token subscriber", site.source, || subscriber(&token));
2120 result.map_err(|error| {
2121 self.attach_active_error(error, rule, site.stack, Some(&token))
2122 })?;
2123 }
2124 let is_end = token.tin == TIN_ZZ;
2125 context.t.push(token);
2126 if is_end {
2127 break;
2128 }
2129 }
2130 Ok(())
2131 }
2132
2133 fn parse_inner(
2134 &self,
2135 src: &str,
2136 reader: Option<crate::lexer::ReaderSource<'_>>,
2137 meta: Value,
2138 owner: Option<&crate::Tabnas>,
2139 parent: Option<&ContextSeed>,
2140 mode: &mut ParseMode<'_>,
2141 ) -> Result<Value, TabnasError> {
2142 let input_meta = meta.clone();
2143 let mut context = Context::new(
2144 self.options.rewind.history,
2145 src,
2146 meta,
2147 Arc::clone(&self.options),
2148 self.instance.clone(),
2149 );
2150 if let Some(parent) = parent {
2151 context.apply_seed(parent);
2152 }
2153 for prepare in &self.options.parse.prepare {
2154 let outcome = self.catch_callback("parse.prepare", src, || {
2155 prepare.run(owner, &mut context, &input_meta)
2156 })?;
2157 if let Err(detail) = outcome {
2158 let mut error = TabnasError::new("internal", "", src, 0, 1, 1);
2159 error.detail = detail.into();
2160 return Err(error);
2161 }
2162 }
2163 for prepare in self.options.parse.named_prepare.values() {
2164 let outcome = self.catch_callback("parse.prepare", src, || {
2165 prepare.run(owner, &mut context, &input_meta)
2166 })?;
2167 if let Err(detail) = outcome {
2168 let mut error = TabnasError::new("internal", "", src, 0, 1, 1);
2169 error.detail = detail.into();
2170 return Err(error);
2171 }
2172 }
2173
2174 if src.is_empty() && reader.is_none() {
2175 return if self.options.lex.empty {
2176 Ok(self.options.lex.empty_result.clone())
2177 } else {
2178 Err(TabnasError::new("unexpected", "", src, 0, 1, 1))
2179 };
2180 }
2181
2182 let exclude_regex = if self.exclude_pattern == self.options.number.exclude {
2185 self.exclude_regex.clone()
2186 } else {
2187 compile_number_exclude(&self.options)
2188 };
2189 let mut lexer = match reader {
2190 Some(source) => Lexer::with_reader(source, Arc::clone(&self.options), exclude_regex),
2191 None => Lexer::with_shared(src, Arc::clone(&self.options), exclude_regex),
2192 };
2193 if lexer.windowed() && lexer.is_empty_source() {
2195 return if self.options.lex.empty {
2196 Ok(self.options.lex.empty_result.clone())
2197 } else {
2198 Err(TabnasError::new("unexpected", "", src, 0, 1, 1))
2199 };
2200 }
2201
2202 let start_name = self.options.rule.start.as_str();
2205 let Some((start_slot, start_shared, start_spec)) = self.installed(start_name) else {
2206 return Ok(Value::Undefined);
2207 };
2208
2209 let mut current_rule = Rule::new(start_shared.clone(), Value::Undefined);
2210 current_rule.bind_spec(start_spec, start_shared, start_slot);
2211 current_rule.i = 1;
2214 let root_node = current_rule.node.clone();
2215 context.set_root(root_node.clone());
2216 let mut stack: Vec<Rule> = Vec::new();
2217 let park_child_nodes = self.options.parse.recover.pop_until_valid;
2222 let mut next_rule_id = 2;
2223 #[allow(unused_assignments)]
2224 let mut final_value = None;
2225
2226 let mut iterations = 0usize;
2227 let maxmul = if self.options.rule.maxmul == 0 {
2228 3
2229 } else {
2230 self.options.rule.maxmul
2231 };
2232 let step_budget = |read: usize| {
2236 self.rules
2237 .len()
2238 .saturating_mul(read)
2239 .saturating_mul(4)
2240 .saturating_mul(maxmul)
2241 .max(100)
2242 };
2243 let mut max_iterations = step_budget(lexer.utf16_read());
2244 let budget = &self.options.parse.budget;
2245
2246 let mut matched = AltMatch::default();
2254
2255 'parse: loop {
2256 context.set_active(¤t_rule, &stack);
2257 update_partial(mode, &root_node, ¤t_rule, &stack);
2258 iterations += 1;
2259 if iterations > max_iterations && lexer.windowed() {
2260 max_iterations = step_budget(lexer.utf16_read());
2261 }
2262 if iterations > max_iterations {
2263 let pnt = context
2264 .t
2265 .first()
2266 .map(|t| (t.site.pos, t.site.ri, t.site.ci))
2267 .unwrap_or((0, 1, 1));
2268 return Err(TabnasError::new("unexpected", "", src, pnt.0, pnt.1, pnt.2));
2269 }
2270 context.iteration = iterations - 1;
2271 if context.iteration > 0 {
2274 for guard in &self.parse_guards {
2275 let result = self.catch_callback("parse guard", src, || guard(&context));
2276 let keep_going = result.map_err(|error| {
2277 self.attach_active_error(
2278 error,
2279 ¤t_rule,
2280 &stack,
2281 Self::phase_token(¤t_rule).or_else(|| context.t.first()),
2282 )
2283 })?;
2284 if !keep_going {
2285 return Err(self.cancelled(src, &context, ¤t_rule, &stack));
2286 }
2287 }
2288 }
2289 if budget.check_every_n > 0
2290 && context.iteration > 0
2291 && context.iteration % budget.check_every_n == 0
2292 {
2293 if let Some(check) = &budget.on_check {
2294 let result =
2295 self.catch_callback("parse.budget.onCheck", src, || check(&context));
2296 let keep_going = result.map_err(|error| {
2297 self.attach_active_error(
2298 error,
2299 ¤t_rule,
2300 &stack,
2301 Self::phase_token(¤t_rule).or_else(|| context.t.first()),
2302 )
2303 })?;
2304 if !keep_going {
2305 return Err(self.cancelled(src, &context, ¤t_rule, &stack));
2306 }
2307 }
2308 }
2309
2310 let by_name;
2326 let (prepared, spec) = match self.prepared.get(current_rule.slot).filter(|prepared| {
2327 Arc::ptr_eq(&prepared.spec, ¤t_rule.spec)
2328 && prepared.name == current_rule.name
2329 }) {
2330 Some(prepared) => (Some(prepared), &prepared.spec),
2331 None => {
2332 by_name = if current_rule.spec.name == *current_rule.name {
2333 Arc::clone(¤t_rule.spec)
2334 } else {
2335 match self.rules.get(&*current_rule.name) {
2336 Some(s) => s.clone(),
2337 None => {
2338 let pnt = context
2339 .t
2340 .first()
2341 .map(|t| (t.site.pos, t.site.ri, t.site.ci))
2342 .unwrap_or((0, 1, 1));
2343 return Err(TabnasError::new(
2344 "unknown_rule",
2345 &*current_rule.name,
2346 src,
2347 pnt.0,
2348 pnt.1,
2349 pnt.2,
2350 ));
2351 }
2352 }
2353 };
2354 (None, &by_name)
2355 }
2356 };
2357
2358 let is_open = current_rule.state == RuleState::Open;
2359 let probe_at_start = 0 < context.probe_depth();
2362 let alts = if is_open { &spec.open } else { &spec.close };
2363
2364 for subscriber in &self.rule_subscribers {
2365 let result = self.catch_callback("rule subscriber", src, || {
2366 subscriber(&mut current_rule, &mut context)
2367 });
2368 result.map_err(|error| {
2369 self.attach_error(
2370 error,
2371 ¤t_rule,
2372 &stack,
2373 alts,
2374 Self::phase_token(¤t_rule).or_else(|| context.t.first()),
2375 )
2376 })?;
2377 }
2378 update_partial(mode, &root_node, ¤t_rule, &stack);
2379
2380 let skip_befores = current_rule.skip_befores;
2383 current_rule.skip_befores = false;
2384 let before_enabled = if is_open {
2385 current_rule.bo
2386 } else {
2387 current_rule.bc
2388 };
2389 let by_spec;
2394 let before_bindings: &[ActionBinding] = if skip_befores || !before_enabled {
2395 &[]
2396 } else {
2397 match prepared {
2398 Some(prepared) => prepared.before(is_open),
2399 None => {
2400 let (actions, callbacks, states, order) = if is_open {
2401 (&spec.bo, &spec.bo_fns, &spec.bo_state_fns, &spec.bo_order)
2402 } else {
2403 (&spec.bc, &spec.bc_fns, &spec.bc_state_fns, &spec.bc_order)
2404 };
2405 by_spec = resolved_action_order(actions, callbacks, states, order);
2406 &by_spec
2407 }
2408 }
2409 };
2410 if !before_bindings.is_empty() {
2411 let label = if is_open {
2412 "before-open action"
2413 } else {
2414 "before-close action"
2415 };
2416 let next = is_open.then(|| current_rule.snapshot());
2417 let site = ParseSite {
2418 source: src,
2419 stack: &stack,
2420 alts,
2421 };
2422 let mut output = None;
2423 let mut lifecycle_error = None;
2424 for binding in before_bindings {
2425 output = match binding {
2426 ActionBinding::Named(action) => {
2427 if let Some(callback) = self.state_actions.get(action) {
2428 self.run_state_callback(
2429 label,
2430 callback,
2431 &mut current_rule,
2432 &mut context,
2433 next.as_deref(),
2434 output,
2435 )
2436 .map_err(|error| {
2437 self.attach_action_error(
2438 error,
2439 src,
2440 ¤t_rule,
2441 &stack,
2442 alts,
2443 )
2444 })?
2445 } else {
2446 self.run_action(action, &mut current_rule, &mut context)
2447 .map_err(|error| {
2448 self.attach_action_error(
2449 error,
2450 src,
2451 ¤t_rule,
2452 &stack,
2453 alts,
2454 )
2455 })?;
2456 None
2457 }
2458 }
2459 ActionBinding::Callback(callback) => {
2460 self.run_context_callback(
2461 label,
2462 callback,
2463 &mut current_rule,
2464 &mut context,
2465 )
2466 .map_err(|error| {
2467 self.attach_action_error(error, src, ¤t_rule, &stack, alts)
2468 })?;
2469 None
2470 }
2471 ActionBinding::State(callback) => self
2472 .run_state_callback(
2473 label,
2474 callback,
2475 &mut current_rule,
2476 &mut context,
2477 next.as_deref(),
2478 output,
2479 )
2480 .map_err(|error| {
2481 self.attach_action_error(error, src, ¤t_rule, &stack, alts)
2482 })?,
2483 };
2484 match self.check_lifecycle_output(output, ¤t_rule, site) {
2485 Ok(next_output) => output = next_output,
2486 Err(error) => {
2487 lifecycle_error = Some(error);
2488 break;
2489 }
2490 }
2491 }
2492 if let Some(error) = lifecycle_error {
2493 update_partial(mode, &root_node, ¤t_rule, &stack);
2494 self.recover_error_pass(
2495 error,
2496 if is_open {
2497 RuleState::Open
2498 } else {
2499 RuleState::Close
2500 },
2501 None,
2502 false,
2503 src,
2504 &mut current_rule,
2505 &mut stack,
2506 &mut context,
2507 &mut lexer,
2508 mode,
2509 )?;
2510 continue 'parse;
2511 }
2512 }
2513 update_partial(mode, &root_node, ¤t_rule, &stack);
2514
2515 let mut matched_alt_idx: Option<usize> = None;
2517 let mut matched_count = 0;
2518 matched.reset();
2521 let mut record_written = false;
2527 let mut matched_tokens: Option<Rc<Vec<Token>>> = None;
2530
2531 let groups_prepared = self.options.rule.include == self.prepared_include
2537 && self.options.rule.exclude == self.prepared_exclude;
2538
2539 let first_index = if self.options.lex.relex {
2548 None
2549 } else {
2550 prepared.map(|prepared| prepared.first(is_open))
2551 };
2552 let mut lists: Option<(&[usize], &[usize])> = None;
2556 let mut key_tin = TIN_BD;
2557 let (mut ni, mut wi) = (0, 0);
2558 let mut next_idx = 0;
2559 loop {
2560 if lists.is_none() {
2561 if let (Some(index), Some(t0)) = (first_index, context.t.first()) {
2562 if t0.tin != TIN_BD {
2563 key_tin = t0.tin;
2564 let named = index.named(key_tin);
2565 let wild = index.wild.as_slice();
2566 (ni, wi) = (0, 0);
2567 while ni < named.len() && named[ni] < next_idx {
2568 ni += 1;
2569 }
2570 while wi < wild.len() && wild[wi] < next_idx {
2571 wi += 1;
2572 }
2573 lists = Some((named, wild));
2574 }
2575 }
2576 }
2577 let idx = match lists {
2578 Some((named, wild)) => {
2579 let n = named.get(ni).copied().unwrap_or(alts.len());
2580 let w = wild.get(wi).copied().unwrap_or(alts.len());
2581 if alts.len() <= n && alts.len() <= w {
2582 break;
2584 }
2585 if n < w {
2586 ni += 1;
2587 n
2588 } else {
2589 wi += 1;
2590 w
2591 }
2592 }
2593 None => {
2594 if alts.len() <= next_idx {
2595 break;
2596 }
2597 next_idx += 1;
2598 next_idx - 1
2599 }
2600 };
2601 let alt = &alts[idx];
2602 let enabled = match prepared
2603 .filter(|_| groups_prepared)
2604 .and_then(|prepared| prepared.alt(is_open, idx))
2605 {
2606 Some(prepared_alt) => prepared_alt.groups,
2607 None => groups_enabled(alt, &self.options),
2608 };
2609 if !enabled {
2610 continue;
2611 }
2612 let s_len = alt.s.len();
2613 let mut alt_matches = true;
2614 if record_written {
2615 matched.reset();
2616 record_written = false;
2617 }
2618 let mut relex_undo: Option<RelexUndo> = None;
2619 for (pos, pos_tins) in alt.s.iter().enumerate() {
2620 if let Err(error) = self.ensure_lookahead(
2621 &mut lexer,
2622 &mut context,
2623 &mut current_rule,
2624 pos + 1,
2625 mode,
2626 ParseSite {
2627 source: src,
2628 stack: &stack,
2629 alts,
2630 },
2631 Fetch::Rule,
2632 ) {
2633 return Err(self.attach_error(error, ¤t_rule, &stack, alts, None));
2634 }
2635 let Some(token) = context.t.get(pos).cloned() else {
2636 alt_matches = false;
2637 break;
2638 };
2639 if !slot_matches(pos_tins, token.tin) {
2640 let recut = if self.options.lex.relex
2641 && !token.src.is_empty()
2642 && !pos_tins.is_empty()
2643 {
2644 let result = self.catch_callback("lexer relex callback", src, || {
2645 lexer.relex(&token, pos_tins, &mut current_rule, &mut context)
2646 });
2647 result.map_err(|error| {
2648 self.attach_error(error, ¤t_rule, &stack, alts, Some(&token))
2649 })?
2650 } else {
2651 None
2652 };
2653 let Some((mut recut, checkpoint)) = recut else {
2654 alt_matches = false;
2655 break;
2656 };
2657 for subscriber in &self.lex_subscribers {
2658 let result = self.catch_callback("lex subscriber", src, || {
2659 subscriber(&mut recut, &mut current_rule, &mut context)
2660 });
2661 result.map_err(|error| {
2662 self.attach_error(error, ¤t_rule, &stack, alts, Some(&recut))
2663 })?;
2664 }
2665 if !pos_tins.contains(&recut.tin) {
2666 lexer.unrelex(checkpoint, &mut context);
2667 alt_matches = false;
2668 break;
2669 }
2670 if relex_undo.is_none() {
2671 relex_undo = Some(RelexUndo {
2672 position: pos,
2673 token,
2674 checkpoint,
2675 tokens: context.t.clone(),
2676 });
2677 }
2678 context.t[pos] = recut;
2679 context.t.truncate(pos + 1);
2680 }
2681 }
2682
2683 if alt_matches {
2684 let tokens: Rc<Vec<Token>> =
2685 Rc::new(context.t.iter().take(s_len).cloned().collect());
2686 if alt.c_ref.is_some() || !alt.c.is_empty() {
2694 let mut candidate = current_rule.clone();
2695 if is_open {
2696 candidate.o = Rc::clone(&tokens);
2697 } else {
2698 candidate.c = Rc::clone(&tokens);
2699 }
2700 if !builtin_condition_matches(alt.c_ref.as_deref(), &candidate)
2701 || !conditions_match(&alt.c, &candidate, &stack)
2702 {
2703 alt_matches = false;
2704 }
2705 }
2706 if alt_matches {
2707 if is_open {
2708 current_rule.o = Rc::clone(&tokens);
2709 } else {
2710 current_rule.c = Rc::clone(&tokens);
2711 }
2712 if let Some(condition) = &alt.c_fn {
2713 context.set_rule(¤t_rule);
2714 let result = self.catch_callback("alternate condition", src, || {
2715 condition(&mut current_rule, &mut context)
2716 });
2717 alt_matches = result.map_err(|error| {
2718 self.attach_error(
2719 error,
2720 ¤t_rule,
2721 &stack,
2722 alts,
2723 Self::phase_token(¤t_rule),
2724 )
2725 })?;
2726 }
2727 if alt_matches {
2728 if let Some(condition) = &alt.c_match {
2729 context.set_rule(¤t_rule);
2730 record_written = true;
2731 let result =
2732 self.catch_callback("matched alternate condition", src, || {
2733 condition(&mut current_rule, &mut context, &mut matched)
2734 });
2735 alt_matches = result.map_err(|error| {
2736 self.attach_error(
2737 error,
2738 ¤t_rule,
2739 &stack,
2740 alts,
2741 Self::phase_token(¤t_rule),
2742 )
2743 })?;
2744 }
2745 }
2746 if alt_matches {
2747 if let Some(condition) = &alt.c_lex_match {
2748 context.set_rule(¤t_rule);
2749 record_written = true;
2750 let result = self.catch_callback(
2751 "matched alternate lexer condition",
2752 src,
2753 || {
2754 condition(
2755 &mut current_rule,
2756 &mut context,
2757 &mut matched,
2758 &mut lexer,
2759 )
2760 },
2761 );
2762 alt_matches = result.map_err(|error| {
2763 self.attach_error(
2764 error,
2765 ¤t_rule,
2766 &stack,
2767 alts,
2768 Self::phase_token(¤t_rule),
2769 )
2770 })?;
2771 }
2772 }
2773 if alt_matches {
2774 if let Some(condition) = &alt.c_lex {
2775 context.set_rule(¤t_rule);
2776 let result =
2777 self.catch_callback("alternate lexer condition", src, || {
2778 condition(&mut current_rule, &mut context, &mut lexer)
2779 });
2780 alt_matches = result.map_err(|error| {
2781 self.attach_error(
2782 error,
2783 ¤t_rule,
2784 &stack,
2785 alts,
2786 Self::phase_token(¤t_rule),
2787 )
2788 })?;
2789 }
2790 }
2791 }
2792 if alt_matches {
2793 matched_alt_idx = Some(idx);
2794 matched_count = s_len;
2795 if alt.c_fn.is_none() && alt.c_match.is_none() {
2805 matched_tokens = Some(Rc::clone(&tokens));
2806 }
2807 break;
2808 }
2809 }
2810 if let Some(undo) = relex_undo {
2811 lexer.unrelex(undo.checkpoint, &mut context);
2812 context.t = undo.tokens;
2813 for subscriber in &self.lex_subscribers {
2814 let mut restored = undo.token.clone();
2815 let result = self.catch_callback("lex subscriber", src, || {
2816 subscriber(&mut restored, &mut current_rule, &mut context)
2817 });
2818 result.map_err(|error| {
2819 self.attach_error(error, ¤t_rule, &stack, alts, Some(&restored))
2820 })?;
2821 }
2822 debug_assert_eq!(context.t.get(undo.position), Some(&undo.token));
2823 }
2824 if lists.is_some() && context.t.first().map(|t0| t0.tin) != Some(key_tin) {
2830 lists = None;
2831 next_idx = idx + 1;
2832 }
2833 }
2834
2835 if let Some(idx) = matched_alt_idx {
2836 let matched_tokens = matched_tokens.unwrap_or_else(|| {
2838 Rc::new(context.t.iter().take(matched_count).cloned().collect())
2839 });
2840 if is_open {
2841 current_rule.o = matched_tokens;
2842 } else {
2843 current_rule.c = matched_tokens;
2844 }
2845
2846 let rewritten: AltSpec;
2857 let alt: &AltSpec = if let Some(modifier) = alts[idx].h.clone() {
2858 context.set_rule(¤t_rule);
2859 let source = alts[idx].clone();
2860 let result = self.catch_callback("alternate modifier", src, || {
2861 modifier(source, &mut current_rule, &mut context)
2862 });
2863 rewritten = result.map_err(|error| {
2864 self.attach_error(
2865 error,
2866 ¤t_rule,
2867 &stack,
2868 alts,
2869 Self::phase_token(¤t_rule),
2870 )
2871 })?;
2872 &rewritten
2873 } else {
2874 &alts[idx]
2875 };
2876
2877 matched.h = alt.h_match.clone();
2878 if !alt.n.is_empty() {
2879 matched.n = alt.n.clone();
2880 }
2881 if !alt.u.is_empty() {
2882 matched.u = alt.u.clone();
2883 }
2884 if !alt.k.is_empty() {
2885 matched.k = alt.k.clone();
2886 }
2887 let prepared_alt = if alts[idx].h.is_some() {
2893 None
2894 } else {
2895 prepared.and_then(|prepared| prepared.alt(is_open, idx))
2896 };
2897 match prepared_alt {
2898 Some(prepared_alt) => matched.g.clone_from(&prepared_alt.group_tags),
2902 None if !alt.g.is_empty() => {
2903 matched.g = listed(&alt.g).map(str::to_owned).collect();
2904 }
2905 None => {}
2906 }
2907 let prepared_alt = prepared_alt.filter(|prepared_alt| {
2917 !prepared_alt.observed
2918 && (!prepared_alt.named || self.matched_actions.is_empty())
2919 });
2920 if prepared_alt.is_none() {
2921 let actions = resolved_alt_action_order(
2922 &alt.a,
2923 &alt.action_fns,
2924 &alt.matched_action_fns,
2925 &alt.action_order,
2926 );
2927 if !actions.is_empty() {
2928 matched.actions = actions;
2929 }
2930 }
2931 if !alt.action_configs.is_empty() {
2932 matched.action_configs = alt.action_configs.clone();
2933 }
2934
2935 if let Some(route) = &alt.p_fn {
2936 context.set_rule(¤t_rule);
2937 matched.p = self
2938 .catch_callback("alternate push", src, || {
2939 route(&mut current_rule, &mut context)
2940 })
2941 .map_err(|error| {
2942 self.attach_error(
2943 error,
2944 ¤t_rule,
2945 &stack,
2946 alts,
2947 Self::phase_token(¤t_rule),
2948 )
2949 })?
2950 .filter(|name| !name.is_empty());
2951 }
2952 if let Some(route) = &alt.p_match {
2953 context.set_rule(¤t_rule);
2954 matched.p = self
2955 .catch_callback("matched alternate push", src, || {
2956 route(&mut current_rule, &mut context, &mut matched)
2957 })
2958 .map_err(|error| {
2959 self.attach_error(
2960 error,
2961 ¤t_rule,
2962 &stack,
2963 alts,
2964 Self::phase_token(¤t_rule),
2965 )
2966 })?
2967 .filter(|name| !name.is_empty());
2968 } else if alt.p_fn.is_none() {
2969 if let Some(route) = alt.p.clone() {
2970 matched.p = (!route.is_empty()).then_some(route);
2971 }
2972 }
2973 if let Some(route) = &alt.r_fn {
2974 context.set_rule(¤t_rule);
2975 matched.r = self
2976 .catch_callback("alternate replace", src, || {
2977 route(&mut current_rule, &mut context)
2978 })
2979 .map_err(|error| {
2980 self.attach_error(
2981 error,
2982 ¤t_rule,
2983 &stack,
2984 alts,
2985 Self::phase_token(¤t_rule),
2986 )
2987 })?
2988 .filter(|name| !name.is_empty());
2989 }
2990 if let Some(route) = &alt.r_match {
2991 context.set_rule(¤t_rule);
2992 matched.r = self
2993 .catch_callback("matched alternate replace", src, || {
2994 route(&mut current_rule, &mut context, &mut matched)
2995 })
2996 .map_err(|error| {
2997 self.attach_error(
2998 error,
2999 ¤t_rule,
3000 &stack,
3001 alts,
3002 Self::phase_token(¤t_rule),
3003 )
3004 })?
3005 .filter(|name| !name.is_empty());
3006 } else if alt.r_fn.is_none() {
3007 if let Some(route) = alt.r.clone() {
3008 matched.r = (!route.is_empty()).then_some(route);
3009 }
3010 }
3011 if let Some(backtrack) = &alt.b_fn {
3012 context.set_rule(¤t_rule);
3013 matched.b = self
3014 .catch_callback("alternate backtrack", src, || {
3015 backtrack(&mut current_rule, &mut context)
3016 })
3017 .map_err(|error| {
3018 self.attach_error(
3019 error,
3020 ¤t_rule,
3021 &stack,
3022 alts,
3023 Self::phase_token(¤t_rule),
3024 )
3025 })?;
3026 }
3027 if let Some(backtrack) = &alt.b_match {
3028 context.set_rule(¤t_rule);
3029 matched.b = self
3030 .catch_callback("matched alternate backtrack", src, || {
3031 backtrack(&mut current_rule, &mut context, &mut matched)
3032 })
3033 .map_err(|error| {
3034 self.attach_error(
3035 error,
3036 ¤t_rule,
3037 &stack,
3038 alts,
3039 Self::phase_token(¤t_rule),
3040 )
3041 })?;
3042 } else if alt.b_fn.is_none() && alt.b != 0 {
3043 matched.b = alt.b;
3044 }
3045
3046 if let Some(modifier) = alt.h_match.clone() {
3047 context.set_rule(¤t_rule);
3048 let next = is_open.then(|| current_rule.snapshot());
3049 matched = self
3050 .catch_callback("matched alternate modifier", src, || {
3051 modifier(
3052 std::mem::take(&mut matched),
3053 &mut current_rule,
3054 &mut context,
3055 next.as_deref(),
3056 )
3057 })
3058 .map_err(|error| {
3059 self.attach_error(
3060 error,
3061 ¤t_rule,
3062 &stack,
3063 alts,
3064 Self::phase_token(¤t_rule),
3065 )
3066 })?;
3067 }
3068
3069 if let Some(error_hook) = alt.e.clone() {
3076 context.set_rule(¤t_rule);
3077 let result = self.catch_callback("alternate error", src, || {
3078 error_hook(&mut current_rule, &mut context)
3079 });
3080 matched.e = result
3081 .map_err(|error| {
3082 self.attach_error(
3083 error,
3084 ¤t_rule,
3085 &stack,
3086 alts,
3087 Self::phase_token(¤t_rule),
3088 )
3089 })?
3090 .map(Box::new);
3091 }
3092 if let Some(error_hook) = alt.e_match.clone() {
3093 context.set_rule(¤t_rule);
3094 let result = self.catch_callback("matched alternate error", src, || {
3095 error_hook(&mut current_rule, &mut context, &mut matched)
3096 });
3097 matched.e = result
3098 .map_err(|error| {
3099 self.attach_error(
3100 error,
3101 ¤t_rule,
3102 &stack,
3103 alts,
3104 Self::phase_token(¤t_rule),
3105 )
3106 })?
3107 .map(Box::new);
3108 }
3109 if let Some(token) = matched.e.clone() {
3112 let code = raised_error_code(&token);
3113 let error = TabnasError::new(
3114 code,
3115 token.src.clone(),
3116 src,
3117 token.site.pos,
3118 token.site.ri,
3119 token.site.ci,
3120 );
3121 let done_alt = (!self.rule_done_subscribers.is_empty()).then(|| RuleDoneAlt {
3122 b: matched.b,
3123 g: matched.g.clone(),
3124 p: matched.p.clone().unwrap_or_default(),
3125 r: matched.r.clone().unwrap_or_default(),
3126 err: Some((*token).clone()),
3127 });
3128 let error = self.attach_error(error, ¤t_rule, &stack, alts, Some(&token));
3129 self.recover_error_pass(
3130 error,
3131 if is_open {
3132 RuleState::Open
3133 } else {
3134 RuleState::Close
3135 },
3136 done_alt,
3137 false,
3138 src,
3139 &mut current_rule,
3140 &mut stack,
3141 &mut context,
3142 &mut lexer,
3143 mode,
3144 )?;
3145 continue;
3146 }
3147
3148 for (k, v) in &matched.n {
3150 if *v == 0 {
3151 current_rule.n_mut().insert(k.clone(), 0);
3152 } else {
3153 *current_rule.n_mut().entry(k.clone()).or_insert(0) += *v;
3154 }
3155 }
3156
3157 for (k, v) in &matched.u {
3159 current_rule.u_mut().insert(k.clone(), v.clone());
3160 }
3161
3162 for (k, v) in &matched.k {
3164 current_rule.k_mut().insert(k.clone(), v.clone());
3165 }
3166
3167 let backtrack = matched.b;
3168 let consumed = matched_count.saturating_sub(backtrack);
3169 context.record_consumed(consumed);
3170
3171 let mut matched_action_error = None;
3175 let mut matched_action_token = None;
3176 let published;
3182 let bindings: &[AltActionBinding] = match prepared_alt {
3183 Some(prepared_alt) => &prepared_alt.actions,
3184 None => {
3185 published = matched.actions.clone();
3186 &published
3187 }
3188 };
3189 for binding in bindings {
3190 let act_name = match binding {
3191 AltActionBinding::Context(callback) => {
3192 self.run_context_callback(
3193 "alternate action",
3194 callback,
3195 &mut current_rule,
3196 &mut context,
3197 )
3198 .map_err(|error| {
3199 self.attach_action_error(error, src, ¤t_rule, &stack, alts)
3200 })?;
3201 continue;
3202 }
3203 AltActionBinding::Matched(callback) => {
3204 context.set_rule(¤t_rule);
3205 let result = self
3206 .catch_callback("matched alternate action", src, || {
3207 callback(&mut current_rule, &mut context, &mut matched)
3208 })
3209 .map_err(|error| {
3210 self.attach_action_error(
3211 error,
3212 src,
3213 ¤t_rule,
3214 &stack,
3215 alts,
3216 )
3217 })?;
3218 let token = result.map_err(|action_error| {
3219 self.attach_action_error(
3220 action_error.into(),
3221 src,
3222 ¤t_rule,
3223 &stack,
3224 alts,
3225 )
3226 })?;
3227 if let Some(token) = token.filter(|token| !token.err.is_empty()) {
3228 matched_action_error = Some(self.raised_token_error(
3229 &token,
3230 ¤t_rule,
3231 ParseSite {
3232 source: src,
3233 stack: &stack,
3234 alts,
3235 },
3236 ));
3237 matched_action_token = Some(token);
3238 break;
3239 }
3240 continue;
3241 }
3242 AltActionBinding::Named(name) => name,
3243 };
3244 if let Some(callback) = self.matched_actions.get(act_name) {
3245 context.set_rule(¤t_rule);
3246 let result = self
3247 .catch_callback("named matched alternate action", src, || {
3248 callback(&mut current_rule, &mut context, &mut matched)
3249 })
3250 .map_err(|error| {
3251 self.attach_action_error(error, src, ¤t_rule, &stack, alts)
3252 })?;
3253 let token = result.map_err(|action_error| {
3254 self.attach_action_error(
3255 action_error.into(),
3256 src,
3257 ¤t_rule,
3258 &stack,
3259 alts,
3260 )
3261 })?;
3262 if let Some(token) = token.filter(|token| !token.err.is_empty()) {
3263 matched_action_error = Some(self.raised_token_error(
3264 &token,
3265 ¤t_rule,
3266 ParseSite {
3267 source: src,
3268 stack: &stack,
3269 alts,
3270 },
3271 ));
3272 matched_action_token = Some(token);
3273 break;
3274 }
3275 continue;
3276 }
3277 match act_name.as_str() {
3278 "@probeInit$" => {
3279 current_rule
3280 .k_mut()
3281 .insert("pd_phase".into(), Value::Number(0.0));
3282 let mark = Value::Number(context.mark() as f64);
3283 current_rule.k_mut().insert("pd_mark".into(), mark);
3284 context.probe_open(¤t_rule);
3286 }
3287 "@probeDecide$" => {
3288 let mark = current_rule.k.get("pd_mark").and_then(|value| {
3289 if let Value::Number(mark) = value {
3290 usize::try_from(*mark as u64).ok()
3291 } else {
3292 None
3293 }
3294 });
3295 let Some(mark) = mark.filter(|mark| *mark <= context.v_abs) else {
3296 let mut error = TabnasError::new("internal", "", src, 0, 1, 1);
3297 error.detail =
3298 "@probeDecide$: phase-0 @probeInit$ did not record a valid mark"
3299 .into();
3300 return Err(error);
3301 };
3302 if let Err(error) = self.ensure_lookahead(
3303 &mut lexer,
3304 &mut context,
3305 &mut current_rule,
3306 1,
3307 mode,
3308 ParseSite {
3309 source: src,
3310 stack: &stack,
3311 alts,
3312 },
3313 Fetch::Rule,
3314 ) {
3315 return Err(self.attach_error(
3316 error,
3317 ¤t_rule,
3318 &stack,
3319 alts,
3320 None,
3321 ));
3322 }
3323 let disambiguator =
3324 current_rule.k.get("pd_d").and_then(|value| match value {
3325 Value::String(name) => Some(name.as_str()),
3326 _ => None,
3327 });
3328 let phase = if context
3329 .t
3330 .first()
3331 .is_some_and(|token| Some(token.name.as_str()) == disambiguator)
3332 {
3333 1.0
3334 } else {
3335 2.0
3336 };
3337 context.rewind(mark)?;
3338 current_rule
3339 .k_mut()
3340 .insert("pd_phase".into(), Value::Number(phase));
3341 context.probe_close();
3342 }
3343 _ => self
3344 .run_action_with_config(
3345 act_name,
3346 &mut current_rule,
3347 &mut context,
3348 matched.action_configs.get(act_name),
3349 )
3350 .map_err(|error| {
3351 self.attach_action_error(error, src, ¤t_rule, &stack, alts)
3352 })?,
3353 }
3354 }
3355 if let Some(error) = matched_action_error {
3356 let recovered_alt = Some(RuleDoneAlt {
3357 b: matched.b,
3358 g: matched.g.clone(),
3359 p: matched.p.clone().unwrap_or_default(),
3360 r: matched.r.clone().unwrap_or_default(),
3361 err: None,
3362 });
3363 self.recover_error_pass(
3364 error,
3365 if is_open {
3366 RuleState::Open
3367 } else {
3368 RuleState::Close
3369 },
3370 recovered_alt,
3371 matched_action_token.is_some(),
3372 src,
3373 &mut current_rule,
3374 &mut stack,
3375 &mut context,
3376 &mut lexer,
3377 mode,
3378 )?;
3379 update_partial(mode, &root_node, ¤t_rule, &stack);
3380 continue 'parse;
3381 }
3382 update_partial(mode, &root_node, ¤t_rule, &stack);
3383
3384 let push_name = matched.p.take();
3392 let replace_name = matched.r.take();
3393 let done_alt = (!self.rule_done_subscribers.is_empty()).then(|| RuleDoneAlt {
3398 b: matched.b,
3399 g: matched.g.clone(),
3400 p: push_name.clone().unwrap_or_default(),
3401 r: replace_name.clone().unwrap_or_default(),
3402 err: None,
3403 });
3404
3405 let mut route = match push_name.as_deref().or(replace_name.as_deref()) {
3424 Some(name) => match prepared
3425 .and_then(|prepared| prepared.alt(is_open, idx))
3426 .map(|alt| if push_name.is_some() { &alt.p } else { &alt.r })
3427 .and_then(|route| route.resolved(name))
3428 .or_else(|| self.installed(name))
3429 {
3430 Some(resolved) => Some(resolved),
3431 None => {
3432 let mut token = Self::phase_token(¤t_rule)
3433 .cloned()
3434 .or_else(|| context.t.first().cloned())
3435 .unwrap_or_else(Token::no_token);
3436 token.bad("unknown_rule");
3437 token
3438 .use_data_mut()
3439 .insert("rulename".into(), Value::String(name.to_string()));
3440 let error = self.raised_token_error(
3441 &token,
3442 ¤t_rule,
3443 ParseSite {
3444 source: src,
3445 stack: &stack,
3446 alts,
3447 },
3448 );
3449 self.recover_error_pass(
3450 error,
3451 if is_open {
3452 RuleState::Open
3453 } else {
3454 RuleState::Close
3455 },
3456 done_alt,
3457 false,
3458 src,
3459 &mut current_rule,
3460 &mut stack,
3461 &mut context,
3462 &mut lexer,
3463 mode,
3464 )?;
3465 update_partial(mode, &root_node, ¤t_rule, &stack);
3466 continue 'parse;
3467 }
3468 },
3469 None => None,
3470 };
3471
3472 let completed_rule: Option<Rule>;
3476 let mut completed_value = None;
3477 if push_name.is_some() {
3478 let (push_slot, push_shared, push_spec) =
3479 route.take().expect("a push route was resolved above");
3480 let mut child = Rule::bound(
3481 push_shared.clone(),
3482 current_rule.node.clone(),
3483 Some(push_spec),
3484 push_slot,
3485 );
3486 child.i = next_rule_id;
3487 next_rule_id += 1;
3488 child.d = stack.len() + 1;
3489 child.parent_node = Some(current_rule.node.clone());
3490 child.n = Rc::clone(¤t_rule.n);
3491 child.k = Rc::clone(¤t_rule.k);
3492 child.parent_rule = Some(bounded_history(
3493 current_rule.snapshot(),
3494 self.options.rule.history,
3495 Link::PusherBefore,
3496 ));
3497 current_rule.next_rule_name = Some(push_shared);
3498 current_rule.child_rule = Some(child.snapshot());
3499 current_rule.next_rule = current_rule.child_rule.clone();
3500 current_rule.note_child_push(&child);
3501 let linked = current_rule.child_rule.clone();
3504 let after = self.run_after_actions(
3505 spec,
3506 prepared,
3507 is_open,
3508 &mut current_rule,
3509 &mut context,
3510 ParseSite {
3511 source: src,
3512 stack: &stack,
3513 alts,
3514 },
3515 );
3516 update_partial(mode, &root_node, ¤t_rule, &stack);
3517 if self.recover_after_actions(
3518 after,
3519 if is_open {
3520 RuleState::Open
3521 } else {
3522 RuleState::Close
3523 },
3524 done_alt.clone(),
3525 src,
3526 &mut current_rule,
3527 &mut stack,
3528 &mut context,
3529 &mut lexer,
3530 mode,
3531 )? {
3532 continue 'parse;
3533 }
3534 if is_open {
3535 current_rule.state = RuleState::Close;
3536 }
3537 child.parent_rule = Some(bounded_history(
3538 current_rule.snapshot(),
3539 self.options.rule.history,
3540 Link::Parent,
3541 ));
3542 if crate::options::effective_rule_history(self.options.rule.history).is_none()
3562 && current_rule.links_unchanged(&linked)
3563 {
3564 current_rule.relink_child(&child);
3565 child.parent_rule = Some(current_rule.snapshot());
3566 }
3567 completed_rule = self.rule_done_copy(¤t_rule);
3568 if park_child_nodes {
3577 current_rule.park_child_node();
3578 }
3579 stack.push(current_rule);
3580 current_rule = child;
3581 } else if replace_name.is_some() {
3582 let (replace_slot, replace_shared, replace_spec) =
3583 route.take().expect("a replace route was resolved above");
3584 let mut next = Rule::bound(
3585 replace_shared.clone(),
3586 current_rule.node.clone(),
3587 Some(replace_spec),
3588 replace_slot,
3589 );
3590 next.i = next_rule_id;
3591 next_rule_id += 1;
3592 next.d = current_rule.d;
3593 next.parent_node = current_rule.parent_node.clone();
3594 next.parent_rule = current_rule.parent_rule.clone();
3595 next.n = Rc::clone(¤t_rule.n);
3596 next.k = Rc::clone(¤t_rule.k);
3597 current_rule.next_rule_name = Some(replace_shared);
3598 current_rule.next_rule = Some(next.snapshot());
3599 let after = self.run_after_actions(
3600 spec,
3601 prepared,
3602 is_open,
3603 &mut current_rule,
3604 &mut context,
3605 ParseSite {
3606 source: src,
3607 stack: &stack,
3608 alts,
3609 },
3610 );
3611 update_partial(mode, &root_node, ¤t_rule, &stack);
3612 if self.recover_after_actions(
3613 after,
3614 if is_open {
3615 RuleState::Open
3616 } else {
3617 RuleState::Close
3618 },
3619 done_alt.clone(),
3620 src,
3621 &mut current_rule,
3622 &mut stack,
3623 &mut context,
3624 &mut lexer,
3625 mode,
3626 )? {
3627 continue 'parse;
3628 }
3629 if is_open {
3630 current_rule.state = RuleState::Close;
3631 }
3632 next.prev_rule = Some(bounded_history(
3633 current_rule.snapshot(),
3634 self.options.rule.history,
3635 Link::Prev,
3636 ));
3637 if let Some(parent) = stack.last_mut() {
3644 parent.freeze_child(¤t_rule);
3645 }
3646 completed_rule = Some(current_rule);
3650 current_rule = next;
3651 } else if is_open {
3652 current_rule.next_rule_name = Some(current_rule.name.clone());
3653 current_rule.next_rule = Some(current_rule.snapshot());
3654 let after = self.run_after_actions(
3655 spec,
3656 prepared,
3657 true,
3658 &mut current_rule,
3659 &mut context,
3660 ParseSite {
3661 source: src,
3662 stack: &stack,
3663 alts,
3664 },
3665 );
3666 update_partial(mode, &root_node, ¤t_rule, &stack);
3667 if self.recover_after_actions(
3668 after,
3669 RuleState::Open,
3670 done_alt.clone(),
3671 src,
3672 &mut current_rule,
3673 &mut stack,
3674 &mut context,
3675 &mut lexer,
3676 mode,
3677 )? {
3678 continue 'parse;
3679 }
3680 current_rule.state = RuleState::Close;
3681 completed_rule = self.rule_done_copy(¤t_rule);
3682 } else {
3683 current_rule.next_rule_name = stack.last().map(|rule| rule.name.clone());
3685 current_rule.next_rule = stack.last().map(Rule::snapshot);
3686 let after = self.run_after_actions(
3687 spec,
3688 prepared,
3689 false,
3690 &mut current_rule,
3691 &mut context,
3692 ParseSite {
3693 source: src,
3694 stack: &stack,
3695 alts,
3696 },
3697 );
3698 update_partial(mode, &root_node, ¤t_rule, &stack);
3699 if self.recover_after_actions(
3700 after,
3701 RuleState::Close,
3702 done_alt.clone(),
3703 src,
3704 &mut current_rule,
3705 &mut stack,
3706 &mut context,
3707 &mut lexer,
3708 mode,
3709 )? {
3710 continue 'parse;
3711 }
3712 let parent = stack.pop();
3713 completed_rule = self.rule_done_copy(¤t_rule);
3714 if let Some(mut parent) = parent {
3715 parent.accept_child(¤t_rule);
3716 bound_child_link(&mut parent, self.options.rule.history);
3717 current_rule = parent;
3718 } else {
3719 completed_value = Some(current_rule.node.borrow().clone());
3721 }
3722 }
3723 let probe = context.probe_take() || probe_at_start;
3727 if let Some(completed_rule) = &completed_rule {
3728 self.notify_rule_done(
3729 completed_rule,
3730 &context,
3731 if is_open {
3732 RuleState::Open
3733 } else {
3734 RuleState::Close
3735 },
3736 done_alt,
3737 probe,
3738 src,
3739 &stack,
3740 )?;
3741 }
3742 if let Some(value) = completed_value {
3743 final_value = Some(value);
3744 break;
3745 }
3746 update_partial(mode, &root_node, ¤t_rule, &stack);
3747 } else if alts.is_empty() {
3748 let completed_rule: Option<Rule>;
3751 let mut completed_value = None;
3752 if is_open {
3753 current_rule.next_rule_name = Some(current_rule.name.clone());
3754 current_rule.next_rule = Some(current_rule.snapshot());
3755 let after = self.run_after_actions(
3756 spec,
3757 prepared,
3758 true,
3759 &mut current_rule,
3760 &mut context,
3761 ParseSite {
3762 source: src,
3763 stack: &stack,
3764 alts,
3765 },
3766 );
3767 update_partial(mode, &root_node, ¤t_rule, &stack);
3768 if self.recover_after_actions(
3769 after,
3770 RuleState::Open,
3771 None,
3772 src,
3773 &mut current_rule,
3774 &mut stack,
3775 &mut context,
3776 &mut lexer,
3777 mode,
3778 )? {
3779 continue 'parse;
3780 }
3781 current_rule.state = RuleState::Close;
3782 completed_rule = self.rule_done_copy(¤t_rule);
3783 } else {
3784 current_rule.next_rule_name = stack.last().map(|rule| rule.name.clone());
3785 current_rule.next_rule = stack.last().map(Rule::snapshot);
3786 let after = self.run_after_actions(
3787 spec,
3788 prepared,
3789 false,
3790 &mut current_rule,
3791 &mut context,
3792 ParseSite {
3793 source: src,
3794 stack: &stack,
3795 alts,
3796 },
3797 );
3798 update_partial(mode, &root_node, ¤t_rule, &stack);
3799 if self.recover_after_actions(
3800 after,
3801 RuleState::Close,
3802 None,
3803 src,
3804 &mut current_rule,
3805 &mut stack,
3806 &mut context,
3807 &mut lexer,
3808 mode,
3809 )? {
3810 continue 'parse;
3811 }
3812 let parent = stack.pop();
3813 completed_rule = self.rule_done_copy(¤t_rule);
3814 if let Some(mut parent) = parent {
3815 parent.accept_child(¤t_rule);
3816 bound_child_link(&mut parent, self.options.rule.history);
3817 current_rule = parent;
3818 } else {
3819 completed_value = Some(current_rule.node.borrow().clone());
3820 }
3821 }
3822 let probe = context.probe_take() || probe_at_start;
3823 if let Some(completed_rule) = &completed_rule {
3824 self.notify_rule_done(
3825 completed_rule,
3826 &context,
3827 if is_open {
3828 RuleState::Open
3829 } else {
3830 RuleState::Close
3831 },
3832 None,
3833 probe,
3834 src,
3835 &stack,
3836 )?;
3837 }
3838 if let Some(value) = completed_value {
3839 final_value = Some(value);
3840 break;
3841 }
3842 update_partial(mode, &root_node, ¤t_rule, &stack);
3843 } else {
3844 if is_open {
3846 if let Err(error) = self.ensure_lookahead(
3847 &mut lexer,
3848 &mut context,
3849 &mut current_rule,
3850 1,
3851 mode,
3852 ParseSite {
3853 source: src,
3854 stack: &stack,
3855 alts,
3856 },
3857 Fetch::Rule,
3858 ) {
3859 return Err(self.attach_error(error, ¤t_rule, &stack, alts, None));
3860 }
3861 if let Some(capture) = mode.continuation.as_deref_mut() {
3862 let base = failed_alt_tins(&context, alts, &self.options);
3863 capture.failure = continuation_tins(
3864 &context,
3865 ¤t_rule,
3866 &stack,
3867 &self.rules,
3868 &self.options,
3869 0,
3870 Some(&base),
3871 );
3872 }
3873 let t0 = context.t.first().cloned();
3874 let (src_token, si, ri, ci) = if let Some(t) = t0.as_ref() {
3875 (t.src.to_string(), t.site.pos, t.site.ri, t.site.ci)
3876 } else {
3877 (String::new(), src.len(), 1, 1)
3878 };
3879 let code = t0
3880 .as_ref()
3881 .map_or("unexpected", |t| deferred_error_code(t, mode.recovering));
3882 let error = TabnasError::new(code, src_token, src, si, ri, ci);
3883 let done_alt = (!alts.is_empty() && !self.rule_done_subscribers.is_empty())
3884 .then(|| RuleDoneAlt {
3885 b: 0,
3886 g: Vec::new(),
3887 p: String::new(),
3888 r: String::new(),
3889 err: t0.clone(),
3890 });
3891 let error = self.attach_error(error, ¤t_rule, &stack, alts, t0.as_ref());
3892 self.recover_error_pass(
3893 error,
3894 RuleState::Open,
3895 done_alt,
3896 false,
3897 src,
3898 &mut current_rule,
3899 &mut stack,
3900 &mut context,
3901 &mut lexer,
3902 mode,
3903 )?;
3904 continue;
3905 } else {
3906 if let Err(error) = self.ensure_lookahead(
3907 &mut lexer,
3908 &mut context,
3909 &mut current_rule,
3910 1,
3911 mode,
3912 ParseSite {
3913 source: src,
3914 stack: &stack,
3915 alts,
3916 },
3917 Fetch::Rule,
3918 ) {
3919 return Err(self.attach_error(error, ¤t_rule, &stack, alts, None));
3920 }
3921 if let Some(capture) = mode.continuation.as_deref_mut() {
3922 let base = failed_alt_tins(&context, alts, &self.options);
3923 capture.failure = continuation_tins(
3924 &context,
3925 ¤t_rule,
3926 &stack,
3927 &self.rules,
3928 &self.options,
3929 0,
3930 Some(&base),
3931 );
3932 }
3933 let token = context.t.first().cloned();
3934 let (source, pos, row, col) = token.as_ref().map_or_else(
3935 || (String::new(), src.chars().count(), 1, 1),
3936 |value| {
3937 (
3938 value.src.to_string(),
3939 value.site.pos,
3940 value.site.ri,
3941 value.site.ci,
3942 )
3943 },
3944 );
3945 let code = token
3946 .as_ref()
3947 .map_or("unexpected", |t| deferred_error_code(t, mode.recovering));
3948 let error = TabnasError::new(code, source, src, pos, row, col);
3949 let done_alt = Some(RuleDoneAlt {
3950 b: 0,
3951 g: Vec::new(),
3952 p: String::new(),
3953 r: String::new(),
3954 err: token.clone(),
3955 });
3956 let error =
3957 self.attach_error(error, ¤t_rule, &stack, alts, token.as_ref());
3958 self.recover_error_pass(
3959 error,
3960 RuleState::Close,
3961 done_alt,
3962 false,
3963 src,
3964 &mut current_rule,
3965 &mut stack,
3966 &mut context,
3967 &mut lexer,
3968 mode,
3969 )?;
3970 continue;
3971 }
3972 }
3973 }
3974
3975 let res = final_value.unwrap_or(Value::Null).unwrap_undefined();
3976 if mode.recovering {
3977 mode.partial = Some(PartialValue::Complete(res.clone()));
3978 }
3979
3980 if let Err(error) = self.ensure_lookahead(
3986 &mut lexer,
3987 &mut context,
3988 &mut current_rule,
3989 1,
3990 mode,
3991 ParseSite {
3992 source: src,
3993 stack: &stack,
3994 alts: &[],
3995 },
3996 Fetch::Trailing,
3997 ) {
3998 let error = self.attach_error(error, ¤t_rule, &stack, &[], None);
3999 if mode.recovering {
4000 mode.errors.push(error.clone());
4001 context.errs.push(error);
4002 return Ok(res);
4003 }
4004 return Err(error);
4005 }
4006 if let Some(t0) = context.t.first() {
4007 if t0.tin != TIN_ZZ {
4008 let code = if t0.tin == TIN_BD && !t0.why.is_empty() {
4009 t0.why.as_str()
4010 } else {
4011 "unexpected"
4012 };
4013 let error =
4014 TabnasError::new(code, &*t0.src, src, t0.site.pos, t0.site.ri, t0.site.ci);
4015 let error = self.attach_error(
4016 error,
4017 ¤t_rule,
4018 &stack,
4019 &[AltSpec {
4020 s: vec![vec![TIN_ZZ]],
4021 ..Default::default()
4022 }],
4023 Some(t0),
4024 );
4025 if mode.recovering {
4026 mode.errors.push(error.clone());
4027 context.errs.push(error);
4028 return Ok(res);
4029 }
4030 return Err(error);
4031 }
4032 }
4033 if self
4034 .options
4035 .result
4036 .fail
4037 .iter()
4038 .any(|failed| failed.deep_equal(&res))
4039 {
4040 let token = context.t.first();
4041 let error = token.map_or_else(
4042 || TabnasError::new("unexpected", "", src, 0, 1, 1),
4043 |token| {
4044 TabnasError::new(
4045 "unexpected",
4046 &*token.src,
4047 src,
4048 token.site.pos,
4049 token.site.ri,
4050 token.site.ci,
4051 )
4052 },
4053 );
4054 if mode.recovering {
4055 mode.errors.push(error.clone());
4056 context.errs.push(error);
4057 return Ok(res);
4058 }
4059 return Err(error);
4060 }
4061 Ok(res)
4062 }
4063}
4064
4065#[inline]
4085fn update_partial(
4086 mode: &mut ParseMode<'_>,
4087 root_node: &Rc<RefCell<Value>>,
4088 current_rule: &Rule,
4089 stack: &[Rule],
4090) {
4091 if mode.recovering {
4092 mode.partial = best_partial_node(root_node, current_rule, stack).map(PartialValue::Node);
4093 }
4094}
4095
4096#[inline(never)]
4097fn best_partial_node(
4098 root_node: &Rc<RefCell<Value>>,
4099 current_rule: &Rule,
4100 stack: &[Rule],
4101) -> Option<Rc<RefCell<Value>>> {
4102 let usable = |node: &Rc<RefCell<Value>>| {
4103 (!matches!(*node.borrow(), Value::Undefined | Value::Null)).then(|| Rc::clone(node))
4104 };
4105
4106 usable(root_node)
4107 .or_else(|| stack.iter().find_map(|rule| usable(&rule.node)))
4108 .or_else(|| usable(¤t_rule.node))
4109}
4110
4111fn read_whole(reader: &mut dyn std::io::Read) -> Result<String, TabnasError> {
4117 let mut bytes = Vec::new();
4118 let failed = loop {
4119 let mut chunk = [0u8; 64 * 1024];
4120 match reader.read(&mut chunk) {
4121 Ok(0) => break None,
4122 Ok(read) => bytes.extend_from_slice(&chunk[..read]),
4123 Err(e) if e.kind() == std::io::ErrorKind::Interrupted => {}
4124 Err(e) => break Some(e.to_string()),
4125 }
4126 };
4127 let (valid, reason) = match std::str::from_utf8(&bytes) {
4128 Ok(_) => (bytes.len(), failed),
4129 Err(e) => (
4130 e.valid_up_to(),
4131 failed.or_else(|| Some(crate::lexer::NOT_UTF8.to_string())),
4132 ),
4133 };
4134 match reason {
4135 None => Ok(String::from_utf8(bytes).expect("the source is UTF-8")),
4136 Some(reason) => {
4137 let read = std::str::from_utf8(&bytes[..valid]).expect("the prefix is UTF-8");
4138 let (pos, row, col) = crate::lexer::position_after(read);
4139 let mut error = crate::lexer::Unreadable {
4140 reason,
4141 pos,
4142 row,
4143 col,
4144 }
4145 .error();
4146 error.set_excerpt(read.to_string(), 1, 1);
4147 Err(error)
4148 }
4149 }
4150}
4151
4152fn error_token(error: &TabnasError) -> Token {
4153 let byte_position = error
4154 .full_source
4155 .char_indices()
4156 .nth(error.pos)
4157 .map_or(error.full_source.len(), |(index, _)| index);
4158 let mut token = Token::new(
4159 "#BD",
4160 TIN_BD,
4161 Value::Undefined,
4162 error.src.clone(),
4163 crate::Point {
4164 len: error.len,
4165 site: crate::Site {
4166 si: byte_position,
4167 pos: error.pos,
4168 ri: error.row,
4169 ci: error.col,
4170 },
4171 },
4172 );
4173 token.err = crate::TokenCode::from(error.code.as_str());
4174 token.why = token.err.clone();
4175 token
4176}
4177
4178fn deferred_error_code(token: &Token, recovering: bool) -> &str {
4188 if token.tin != TIN_BD {
4189 "unexpected"
4190 } else if recovering && !token.err.is_empty() {
4191 &token.err
4192 } else if !token.why.is_empty() {
4193 &token.why
4194 } else {
4195 "unexpected"
4196 }
4197}
4198
4199fn raised_error_code(token: &Token) -> &str {
4200 if !token.err.is_empty() {
4201 &token.err
4202 } else if !token.why.is_empty() {
4203 &token.why
4204 } else {
4205 "unexpected"
4206 }
4207}
4208
4209fn mid_construct(code: &str) -> bool {
4210 matches!(code, "unprintable" | "invalid_unicode" | "invalid_ascii")
4211}
4212
4213fn absorb_lex_error(
4222 error: &TabnasError,
4223 context: &mut Context,
4224 options: &Options,
4225 errors: &mut Vec<TabnasError>,
4226) -> bool {
4227 let recover = &options.parse.recover;
4228 let run = context
4229 .bad_error
4230 .filter(|index| *index < errors.len())
4231 .filter(|_| context.bad_to.is_some_and(|bad_to| error.pos <= bad_to));
4232 if let Some(index) = run {
4233 let previous = &mut errors[index];
4234 let recovered = previous.recovered.get_or_insert(crate::RecoveredAt {
4235 skipped: 0,
4236 sync: None,
4237 bad: true,
4238 });
4239 recovered.skipped = recovered.skipped.saturating_add(1);
4240 let skipped = recovered.skipped;
4241 if let Some(context_previous) = context.errs.get_mut(index) {
4242 *context_previous = previous.clone();
4243 }
4244 if recover.max_skip < skipped {
4245 return false;
4246 }
4247 } else if context
4248 .recover_at
4249 .is_some_and(|at| context.v_abs.saturating_sub(at) < recover.suppress)
4250 {
4251 context.bad_error = None;
4252 } else {
4253 let mut recorded = error.clone();
4254 recorded.recovered = Some(crate::RecoveredAt {
4255 skipped: 1,
4256 sync: None,
4257 bad: true,
4258 });
4259 errors.push(recorded.clone());
4260 context.errs.push(recorded);
4261 context.bad_error = Some(errors.len() - 1);
4262 context.recover_at = Some(context.v_abs);
4263 }
4264 context.bad_to = Some(error.pos.saturating_add(error.len.max(1)));
4265 errors.len() <= recover.max_recoveries
4266}
4267
4268fn slot_matches(slot: &[Tin], tin: Tin) -> bool {
4269 tin != TIN_BD && (slot.is_empty() || slot.contains(&tin) || slot.contains(&TIN_AA))
4270}
4271
4272fn alt_match_depth(alt: &AltSpec, context: &Context) -> usize {
4273 let mut depth = 0;
4274 while depth < alt.s.len() {
4275 let Some(token) = context.t.get(depth) else {
4276 break;
4277 };
4278 if !slot_matches(&alt.s[depth], token.tin) {
4279 break;
4280 }
4281 depth += 1;
4282 }
4283 depth
4284}
4285
4286fn completion_tins(slot: &[Tin]) -> impl Iterator<Item = Tin> + '_ {
4287 slot.iter()
4288 .copied()
4289 .chain(slot.is_empty().then_some(TIN_AA))
4290}
4291
4292fn failed_alt_tins(context: &Context, alts: &[AltSpec], options: &Options) -> Vec<Tin> {
4293 let mut out = BTreeSet::new();
4294 for alt in alts {
4295 if !groups_enabled(alt, options) {
4296 continue;
4297 }
4298 let depth = alt_match_depth(alt, context);
4299 if let Some(slot) = alt.s.get(depth) {
4300 out.extend(completion_tins(slot));
4301 }
4302 }
4303 out.into_iter().collect()
4304}
4305
4306fn lead_tins(alts: &[AltSpec], options: &Options, out: &mut BTreeSet<Tin>) {
4307 for alt in alts {
4308 if !groups_enabled(alt, options) {
4309 continue;
4310 }
4311 if let Some(slot) = alt.s.first() {
4312 out.extend(completion_tins(slot));
4313 }
4314 }
4315}
4316
4317fn has_empty_close(spec: &RuleSpec, options: &Options) -> bool {
4318 spec.close
4319 .iter()
4320 .any(|alt| groups_enabled(alt, options) && alt.s.is_empty())
4321}
4322
4323fn alt_has_sync_group(alt: &AltSpec, sync_groups: &[String]) -> bool {
4324 alt.g
4325 .split(',')
4326 .map(str::trim)
4327 .any(|tag| sync_groups.iter().any(|wanted| wanted == tag))
4328}
4329
4330fn add_close_tins(
4331 rule: &Rule,
4332 rules: &IndexMap<String, Arc<RuleSpec>>,
4333 options: &Options,
4334 tagged_only: bool,
4335 out: &mut BTreeSet<Tin>,
4336) {
4337 let Some(spec) = rules.get(&*rule.name) else {
4338 return;
4339 };
4340 for alt in &spec.close {
4341 if !groups_enabled(alt, options)
4342 || (tagged_only && !alt_has_sync_group(alt, &options.parse.recover.sync_groups))
4343 {
4344 continue;
4345 }
4346 if let Some(slot) = alt.s.first() {
4347 out.extend(completion_tins(slot));
4348 }
4349 }
4350}
4351
4352fn compute_sync_tins(
4353 rule: &Rule,
4354 stack: &[Rule],
4355 rules: &IndexMap<String, Arc<RuleSpec>>,
4356 options: &Options,
4357) -> BTreeSet<Tin> {
4358 let mut out = BTreeSet::new();
4359 add_close_tins(rule, rules, options, true, &mut out);
4360 for parent in stack.iter().rev() {
4361 add_close_tins(parent, rules, options, true, &mut out);
4362 }
4363 if out.is_empty() {
4364 add_close_tins(rule, rules, options, false, &mut out);
4365 for parent in stack.iter().rev() {
4366 add_close_tins(parent, rules, options, false, &mut out);
4367 }
4368 }
4369 for name in &options.parse.recover.sync_tokens {
4370 if let Some(tin) = options.token(name) {
4371 out.insert(tin);
4372 }
4373 if let Some(tins) = options.token_set.get(name.trim_start_matches('#')) {
4374 out.extend(tins.iter().copied());
4375 }
4376 }
4377 out
4378}
4379
4380fn accepts_close(
4381 rule: &Rule,
4382 tin: Tin,
4383 rules: &IndexMap<String, Arc<RuleSpec>>,
4384 options: &Options,
4385) -> bool {
4386 rules.get(&*rule.name).is_some_and(|spec| {
4387 spec.close.iter().any(|alt| {
4388 groups_enabled(alt, options)
4389 && (alt.s.is_empty() || alt.s.first().is_some_and(|slot| slot_matches(slot, tin)))
4390 })
4391 })
4392}
4393
4394fn add_openers(
4395 name: &str,
4396 rules: &IndexMap<String, Arc<RuleSpec>>,
4397 options: &Options,
4398 opened: &mut BTreeSet<String>,
4399 out: &mut BTreeSet<Tin>,
4400) {
4401 if name.is_empty() || !opened.insert(name.to_owned()) {
4402 return;
4403 }
4404 let Some(spec) = rules.get(name) else {
4405 return;
4406 };
4407 lead_tins(&spec.open, options, out);
4408 for alt in &spec.open {
4409 if !groups_enabled(alt, options) || !alt.s.is_empty() {
4410 continue;
4411 }
4412 if let Some(push) = alt.p.as_deref() {
4413 add_openers(push, rules, options, opened, out);
4414 }
4415 if let Some(replace) = alt.r.as_deref() {
4416 add_openers(replace, rules, options, opened, out);
4417 }
4418 }
4419}
4420
4421fn continuation_tins(
4422 context: &Context,
4423 rule: &Rule,
4424 stack: &[Rule],
4425 rules: &IndexMap<String, Arc<RuleSpec>>,
4426 options: &Options,
4427 query_pos: usize,
4428 failed: Option<&[Tin]>,
4429) -> Vec<Tin> {
4430 let Some(spec) = rules.get(&*rule.name) else {
4431 return Vec::new();
4432 };
4433 let state_alts = if rule.state == RuleState::Open {
4434 &spec.open
4435 } else {
4436 &spec.close
4437 };
4438 let mut out = BTreeSet::new();
4439
4440 if let Some(failed) = failed.filter(|tins| !tins.is_empty()) {
4441 out.extend(failed.iter().copied());
4442 } else {
4443 for alt in state_alts {
4444 if !groups_enabled(alt, options) {
4445 continue;
4446 }
4447 let depth = alt_match_depth(alt, context);
4448 if depth == query_pos {
4449 if let Some(slot) = alt.s.get(depth) {
4450 out.extend(completion_tins(slot));
4451 }
4452 }
4453 }
4454 }
4455
4456 let mut close_rule = rule;
4459 let mut parent_index = stack.len();
4460 while let Some(close_spec) = rules.get(&*close_rule.name) {
4461 if !has_empty_close(close_spec, options) || parent_index == 0 {
4462 break;
4463 }
4464 parent_index -= 1;
4465 let parent = &stack[parent_index];
4466 if let Some(parent_spec) = rules.get(&*parent.name) {
4467 lead_tins(&parent_spec.close, options, &mut out);
4468 }
4469 close_rule = parent;
4470 }
4471
4472 let mut opened = BTreeSet::new();
4475 for alt in state_alts {
4476 if !groups_enabled(alt, options) || alt_match_depth(alt, context) != alt.s.len() {
4477 continue;
4478 }
4479 if alt.b_fn.is_some() {
4482 continue;
4483 }
4484 if alt.s.len().checked_sub(alt.b) != Some(query_pos) {
4485 continue;
4486 }
4487 if let Some(push) = alt.p.as_deref() {
4488 add_openers(push, rules, options, &mut opened, &mut out);
4489 }
4490 if let Some(replace) = alt.r.as_deref() {
4491 add_openers(replace, rules, options, &mut opened, &mut out);
4492 }
4493 }
4494
4495 out.into_iter().collect()
4496}
4497
4498fn listed(list: &str) -> impl Iterator<Item = &str> {
4504 list.split(',')
4505 .map(str::trim)
4506 .filter(|entry| !entry.is_empty())
4507}
4508
4509pub(crate) fn groups_enabled(alt: &AltSpec, options: &Options) -> bool {
4510 let include = options.rule.include.as_str();
4515 let exclude = options.rule.exclude.as_str();
4516 if include.is_empty() && exclude.is_empty() {
4517 return true;
4518 }
4519 let declares = |wanted: &str| listed(&alt.g).any(|group| group == wanted);
4526 let included = listed(include).next().is_none() || listed(include).any(&declares);
4527 included && !listed(exclude).any(&declares)
4528}
4529
4530fn builtin_condition_matches(reference: Option<&str>, rule: &Rule) -> bool {
4531 let phase = match rule.k.get("pd_phase") {
4532 Some(Value::Number(value)) => *value as i32,
4533 _ => 0,
4534 };
4535 match reference {
4536 None => true,
4537 Some("@probePhase0$") => phase == 0,
4538 Some("@probePhase1$") => phase == 1,
4539 Some("@probePhase2$") => phase == 2,
4540 Some(_) => false,
4541 }
4542}
4543
4544fn conditions_match(conditions: &[Condition], rule: &Rule, ancestors: &[Rule]) -> bool {
4545 conditions.iter().all(|condition| {
4546 let resolved = resolve_condition_path(rule, ancestors, &condition.path);
4547 if condition.op == CompareOp::Exist {
4548 let exists = condition_exists(rule, ancestors, &condition.path);
4549 let wanted = matches!(condition.value, Value::Bool(true));
4550 return exists == wanted;
4551 }
4552 let Some(actual) = resolved else {
4553 return !matches!(condition.op, CompareOp::Eq);
4554 };
4555 match condition.op {
4556 CompareOp::Eq => actual.deep_equal(&condition.value),
4557 CompareOp::Ne => !actual.deep_equal(&condition.value),
4558 CompareOp::Lt => ordered(&actual, &condition.value).is_none_or(|value| value < 0),
4559 CompareOp::Lte => ordered(&actual, &condition.value).is_none_or(|value| value <= 0),
4560 CompareOp::Gt => ordered(&actual, &condition.value).is_none_or(|value| value > 0),
4561 CompareOp::Gte => ordered(&actual, &condition.value).is_none_or(|value| value >= 0),
4562 CompareOp::Exist => unreachable!("handled above"),
4563 }
4564 })
4565}
4566
4567fn ordered(left: &Value, right: &Value) -> Option<i8> {
4568 match (left, right) {
4569 (Value::Number(left), Value::Number(right)) => Some(if left < right {
4570 -1
4571 } else if left > right {
4572 1
4573 } else {
4574 0
4575 }),
4576 (Value::String(left), Value::String(right)) => Some(match left.cmp(right) {
4577 std::cmp::Ordering::Less => -1,
4578 std::cmp::Ordering::Equal => 0,
4579 std::cmp::Ordering::Greater => 1,
4580 }),
4581 _ => None,
4582 }
4583}
4584
4585fn condition_exists(rule: &Rule, ancestors: &[Rule], path: &[String]) -> bool {
4586 if path.first().map(String::as_str) == Some("n") && path.len() == 2 {
4587 rule.n.contains_key(&path[1])
4588 } else if path.first().map(String::as_str) == Some("parent") {
4589 ancestors
4590 .split_last()
4591 .is_some_and(|(parent, parent_ancestors)| {
4592 condition_exists(parent, parent_ancestors, &path[1..])
4593 })
4594 } else if path.first().map(String::as_str) == Some("child") {
4595 rule.child_rule
4596 .as_deref()
4597 .is_some_and(|child| snapshot_condition_exists(child, &path[1..]))
4598 } else if path.first().map(String::as_str) == Some("prev") {
4599 rule.prev_rule
4600 .as_deref()
4601 .is_some_and(|prev| snapshot_condition_exists(prev, &path[1..]))
4602 } else if path.first().map(String::as_str) == Some("next") {
4603 if let Some(next) = rule.next_rule.as_deref() {
4604 snapshot_condition_exists(next, &path[1..])
4605 } else if rule.next_rule_name.as_deref() == Some(&*rule.name) {
4606 condition_exists(rule, ancestors, &path[1..])
4607 } else {
4608 false
4609 }
4610 } else {
4611 resolve_condition_path(rule, ancestors, path).is_some()
4612 }
4613}
4614
4615fn resolve_condition_path(rule: &Rule, ancestors: &[Rule], path: &[String]) -> Option<Value> {
4616 let root = path.first()?.as_str();
4617 let rest = &path[1..];
4618 match root {
4619 "n" if rest.len() == 1 => Some(Value::Number(*rule.n.get(&rest[0]).unwrap_or(&0) as f64)),
4620 "u" => map_path(&rule.u, rest),
4621 "k" => map_path(&rule.k, rest),
4622 "d" if rest.is_empty() => Some(Value::Number(rule.d as f64)),
4623 "i" if rest.is_empty() => Some(Value::Number(rule.i as f64)),
4624 "name" if rest.is_empty() => Some(Value::String(rule.name.to_string())),
4625 "state" if rest.is_empty() => Some(Value::String(
4626 match rule.state {
4627 RuleState::Open => "o",
4628 RuleState::Close => "c",
4629 }
4630 .into(),
4631 )),
4632 "node" => value_path(rule.node.borrow().clone(), rest),
4633 "need" if rest.is_empty() => Some(Value::Number(rule.need as f64)),
4634 "oN" if rest.is_empty() => Some(Value::Number(rule.o.len() as f64)),
4635 "cN" if rest.is_empty() => Some(Value::Number(rule.c.len() as f64)),
4636 "o" => token_list_path(&rule.o, rest),
4637 "c" => token_list_path(&rule.c, rest),
4638 "o0" => token_path(rule.o.first(), rest),
4639 "o1" => token_path(rule.o.get(1), rest),
4640 "c0" => token_path(rule.c.first(), rest),
4641 "c1" => token_path(rule.c.get(1), rest),
4642 "parent" => {
4643 let (parent, parent_ancestors) = ancestors.split_last()?;
4644 resolve_condition_path(parent, parent_ancestors, rest)
4645 }
4646 "child" => resolve_snapshot_path(rule.child_rule.as_deref()?, rest),
4647 "prev" => resolve_snapshot_path(rule.prev_rule.as_deref()?, rest),
4648 "next" => {
4649 if let Some(next) = rule.next_rule.as_deref() {
4650 resolve_snapshot_path(next, rest)
4651 } else if rule.next_rule_name.as_deref() == Some(&*rule.name) {
4652 resolve_condition_path(rule, ancestors, rest)
4653 } else {
4654 None
4655 }
4656 }
4657 "spec" if rest == ["name"] => Some(Value::String(rule.name.to_string())),
4658 _ => None,
4659 }
4660}
4661
4662#[derive(Clone, Copy, PartialEq, Eq)]
4664enum Link {
4665 Parent,
4668 PusherBefore,
4680 Prev,
4682}
4683
4684fn bounded_history(
4717 snapshot: Rc<RuleSnapshot>,
4718 history: Option<usize>,
4719 link: Link,
4720) -> Rc<RuleSnapshot> {
4721 let Some(history) = crate::options::effective_rule_history(history) else {
4722 return snapshot;
4723 };
4724 let mut links: Vec<&Rc<RuleSnapshot>> = Vec::with_capacity(history);
4730 let mut current = Some(&snapshot);
4731 while let Some(snapshot) = current {
4732 if links.len() == history {
4733 break;
4734 }
4735 links.push(snapshot);
4736 current = snapshot.prev_rule.as_ref();
4737 }
4738 let mut prev: Option<Rc<RuleSnapshot>> = None;
4739 for (depth, original) in links.into_iter().enumerate().rev() {
4741 let mut copy = (**original).clone();
4742 if depth != 0 || link != Link::Parent {
4743 copy.child_rule = None;
4744 copy.next_rule = None;
4745 copy.next_rule_name = None;
4746 }
4747 copy.prev_rule = prev.take();
4748 prev = Some(Rc::new(copy));
4749 }
4750 prev.expect("at least the snapshot itself is copied")
4751}
4752
4753fn bound_child_link(rule: &mut Rule, history: Option<usize>) {
4761 if crate::options::effective_rule_history(history).is_none() {
4762 return;
4763 }
4764 if let Some(record) = rule.child_rule.take() {
4765 let bounded = bounded_history(record, history, Link::Prev);
4766 rule.next_rule = Some(Rc::clone(&bounded));
4767 rule.child_rule = Some(bounded);
4768 }
4769}
4770
4771fn snapshot_condition_exists(rule: &RuleSnapshot, path: &[String]) -> bool {
4772 if path.first().map(String::as_str) == Some("n") && path.len() == 2 {
4773 rule.n.contains_key(&path[1])
4774 } else if path.first().map(String::as_str) == Some("parent") {
4775 rule.parent_rule
4776 .as_deref()
4777 .is_some_and(|parent| snapshot_condition_exists(parent, &path[1..]))
4778 } else if path.first().map(String::as_str) == Some("child") {
4779 rule.child_rule
4780 .as_deref()
4781 .is_some_and(|child| snapshot_condition_exists(child, &path[1..]))
4782 } else if path.first().map(String::as_str) == Some("prev") {
4783 rule.prev_rule
4784 .as_deref()
4785 .is_some_and(|prev| snapshot_condition_exists(prev, &path[1..]))
4786 } else if path.first().map(String::as_str) == Some("next") {
4787 if let Some(next) = rule.next_rule.as_deref() {
4788 snapshot_condition_exists(next, &path[1..])
4789 } else if rule.next_rule_name.as_deref() == Some(&*rule.name) {
4790 snapshot_condition_exists(rule, &path[1..])
4791 } else {
4792 false
4793 }
4794 } else {
4795 resolve_snapshot_path(rule, path).is_some()
4796 }
4797}
4798
4799fn resolve_snapshot_path(rule: &RuleSnapshot, path: &[String]) -> Option<Value> {
4800 let root = path.first()?.as_str();
4801 let rest = &path[1..];
4802 match root {
4803 "n" if rest.len() == 1 => Some(Value::Number(*rule.n.get(&rest[0]).unwrap_or(&0) as f64)),
4804 "u" => map_path(&rule.u, rest),
4805 "k" => map_path(&rule.k, rest),
4806 "d" if rest.is_empty() => Some(Value::Number(rule.d as f64)),
4807 "i" if rest.is_empty() => Some(Value::Number(rule.i as f64)),
4808 "name" if rest.is_empty() => Some(Value::String(rule.name.to_string())),
4809 "state" if rest.is_empty() => Some(Value::String(
4810 match rule.state {
4811 RuleState::Open => "o",
4812 RuleState::Close => "c",
4813 }
4814 .into(),
4815 )),
4816 "node" => value_path(rule.node.borrow().clone(), rest),
4817 "need" if rest.is_empty() => Some(Value::Number(rule.need as f64)),
4818 "oN" if rest.is_empty() => Some(Value::Number(rule.o.len() as f64)),
4819 "cN" if rest.is_empty() => Some(Value::Number(rule.c.len() as f64)),
4820 "o" => token_list_path(&rule.o, rest),
4821 "c" => token_list_path(&rule.c, rest),
4822 "o0" => token_path(rule.o.first(), rest),
4823 "o1" => token_path(rule.o.get(1), rest),
4824 "c0" => token_path(rule.c.first(), rest),
4825 "c1" => token_path(rule.c.get(1), rest),
4826 "parent" => resolve_snapshot_path(rule.parent_rule.as_deref()?, rest),
4827 "child" => resolve_snapshot_path(rule.child_rule.as_deref()?, rest),
4828 "prev" => resolve_snapshot_path(rule.prev_rule.as_deref()?, rest),
4829 "next" => {
4830 if let Some(next) = rule.next_rule.as_deref() {
4831 resolve_snapshot_path(next, rest)
4832 } else if rule.next_rule_name.as_deref() == Some(&*rule.name) {
4833 resolve_snapshot_path(rule, rest)
4834 } else {
4835 None
4836 }
4837 }
4838 "spec" if rest == ["name"] => Some(Value::String(rule.name.to_string())),
4839 _ => None,
4840 }
4841}
4842
4843fn map_path(map: &HashMap<String, Value>, path: &[String]) -> Option<Value> {
4844 let (name, rest) = path.split_first()?;
4845 value_path(map.get(name)?.clone(), rest)
4846}
4847
4848fn value_path(mut value: Value, path: &[String]) -> Option<Value> {
4849 for part in path {
4850 value = match value {
4851 Value::Object(map) => map.get(part)?.clone(),
4852 Value::Array(items) => items.get(part.parse::<usize>().ok()?)?.clone(),
4853 _ => return None,
4854 };
4855 }
4856 Some(value)
4857}
4858
4859fn token_list_path(tokens: &[Token], path: &[String]) -> Option<Value> {
4860 let (index, rest) = path.split_first()?;
4861 token_path(tokens.get(index.parse::<usize>().ok()?), rest)
4862}
4863
4864fn token_path(token: Option<&Token>, path: &[String]) -> Option<Value> {
4865 let token = token?;
4866 if path.is_empty() {
4867 let mut value = IndexMap::new();
4868 value.insert("tin".into(), Value::Number(token.tin as f64));
4869 value.insert("name".into(), Value::String(token.name.to_string()));
4870 value.insert("src".into(), Value::String(token.src.to_string()));
4871 value.insert("val".into(), token.val.clone());
4872 value.insert("why".into(), Value::String(token.why.to_string()));
4873 return Some(Value::object(value));
4874 }
4875 let (field, rest) = path.split_first()?;
4876 let value = match field.as_str() {
4877 "tin" => Value::Number(token.tin as f64),
4878 "name" => Value::String(token.name.to_string()),
4879 "src" => Value::String(token.src.to_string()),
4880 "val" => token.val.clone(),
4881 "why" => Value::String(token.why.to_string()),
4882 _ => return None,
4883 };
4884 value_path(value, rest)
4885}
4886
4887#[cfg(test)]
4888mod tests {
4889 use super::*;
4890
4891 #[test]
4901 fn replacing_a_rule_replaces_the_tables_derived_from_it() {
4902 let mut parser = Parser::new(crate::Options::default());
4903
4904 let mut first = RuleSpec::new("val");
4905 first.bo.push("@enter".into());
4906 first.open.push(AltSpec {
4907 s: vec![vec![crate::TIN_NR]],
4908 a: vec!["@act".into()],
4909 ..Default::default()
4910 });
4911 parser.add_rule(first);
4912 let slot = parser
4913 .rules()
4914 .get_index_of("val")
4915 .expect("the rule was just installed");
4916 assert_eq!(parser.expected_tins[slot].at(true, 0), [crate::TIN_NR]);
4917 assert_eq!(&*parser.names[slot], "val");
4918 assert_eq!(parser.prepared[slot].before(true).len(), 1);
4919 assert_eq!(parser.prepared[slot].open[0].actions.len(), 1);
4920
4921 let mut second = RuleSpec::new("val");
4922 second.open.push(AltSpec {
4923 s: vec![vec![crate::TIN_ST]],
4924 ..Default::default()
4925 });
4926 parser.add_rule(second);
4927
4928 assert_eq!(parser.rules().len(), 1, "a replacement, not an addition");
4929 assert_eq!(
4930 parser.expected_tins[slot].at(true, 0),
4931 [crate::TIN_ST],
4932 "lookahead would still expect the replaced rule's tokens"
4933 );
4934 assert_eq!(parser.names.len(), 1, "one rule, one shared name");
4939 assert_eq!(parser.rules().get_index_of("val"), Some(slot));
4940 assert_eq!(&*parser.names[slot], "val");
4941 assert_eq!(parser.prepared.len(), 1);
4947 assert_eq!(&*parser.prepared[slot].name, "val");
4948 assert!(Arc::ptr_eq(
4949 &parser.prepared[slot].spec,
4950 &parser.rules()["val"]
4951 ));
4952 assert!(parser.prepared[slot].before(true).is_empty());
4957 assert!(parser.prepared[slot].open[0].actions.is_empty());
4958 assert!(!parser.prepared[slot].open[0].named);
4959 }
4960
4961 #[test]
4969 fn expected_match_tins_follows_the_rule_name_when_the_slot_goes_stale() {
4970 fn rule_named(name: &str, tin: Tin) -> RuleSpec {
4971 let mut spec = RuleSpec::new(name);
4972 spec.open.push(AltSpec {
4973 s: vec![vec![tin]],
4974 ..Default::default()
4975 });
4976 spec
4977 }
4978
4979 let mut options = crate::Options::default();
4980 let tin = options.register_token("#QQ");
4981 options.match_tokens.insert(
4982 "#QQ".into(),
4983 crate::options::MatchToken {
4984 name: "#QQ".into(),
4985 tin,
4986 matcher: crate::options::MatchTokenMatcher::Regex(regex::Regex::new("^q").unwrap()),
4987 eager: false,
4988 },
4989 );
4990 let mut parser = Parser::new(options);
4991 parser.add_rule(rule_named("val", crate::TIN_NR));
4992 parser.add_rule(rule_named("other", crate::TIN_ST));
4993
4994 let val_slot = parser.rules().get_index_of("val").expect("installed");
4995 let other_slot = parser.rules().get_index_of("other").expect("installed");
4996 assert_ne!(val_slot, other_slot);
4997
4998 let mut rule = Rule::new("val", Value::Undefined);
5001 rule.bind_spec(
5002 &parser.rules()["val"],
5003 parser.names[val_slot].clone(),
5004 val_slot,
5005 );
5006 assert_eq!(&*parser.expected_match_tins(&rule, 0), [crate::TIN_NR]);
5007
5008 rule.name = parser.names[other_slot].clone();
5013 assert_eq!(
5014 &*parser.expected_match_tins(&rule, 0),
5015 [crate::TIN_ST],
5016 "the rule is called `other` now, so `other`'s row answers"
5017 );
5018
5019 rule.name = parser.names[val_slot].clone();
5023 rule.spec = Arc::clone(&parser.rules()["other"]);
5024 assert_eq!(
5025 &*parser.expected_match_tins(&rule, 0),
5026 [crate::TIN_NR],
5027 "still called `val`, so still gated by `val`'s row"
5028 );
5029
5030 let ghost = Rule::new("ghost", Value::Undefined);
5033 assert_eq!(
5034 &*parser.expected_match_tins(&ghost, 0),
5035 &[] as &[Tin],
5036 "an uninstalled name has no row, not another rule's"
5037 );
5038 }
5039
5040 #[test]
5048 fn expected_match_tins_is_empty_until_a_match_token_exists() {
5049 fn val_rule() -> RuleSpec {
5050 let mut spec = RuleSpec::new("val");
5051 spec.open.push(AltSpec {
5052 s: vec![vec![crate::TIN_NR]],
5053 ..Default::default()
5054 });
5055 spec
5056 }
5057 let rule = Rule::new("val", Value::Undefined);
5058
5059 let mut without = Parser::new(crate::Options::default());
5060 without.add_rule(val_rule());
5061 assert!(without.options.match_tokens.is_empty());
5062 assert_eq!(without.expected_tins[0].at(true, 0), [crate::TIN_NR]);
5063 assert_eq!(
5064 &*without.expected_match_tins(&rule, 0),
5065 &[] as &[Tin],
5066 "no custom matcher: nothing to gate, so nothing to look up"
5067 );
5068
5069 let mut options = crate::Options::default();
5070 let tin = options.register_token("#QQ");
5071 options.match_tokens.insert(
5072 "#QQ".into(),
5073 crate::options::MatchToken {
5074 name: "#QQ".into(),
5075 tin,
5076 matcher: crate::options::MatchTokenMatcher::Regex(regex::Regex::new("^q").unwrap()),
5077 eager: false,
5078 },
5079 );
5080 let mut with = Parser::new(options);
5081 with.add_rule(val_rule());
5082 assert_eq!(
5083 &*with.expected_match_tins(&rule, 0),
5084 [crate::TIN_NR],
5085 "a custom matcher is present, so the slot's tins gate it"
5086 );
5087 assert_eq!(
5088 &*with.expected_match_tins(&rule, 1),
5089 &[] as &[Tin],
5090 "a slot the rule never fills expects nothing"
5091 );
5092 }
5093}