toml_parser/parser/
event.rs

1use crate::decoder::Encoding;
2use crate::ErrorSink;
3use crate::ParseError;
4use crate::Source;
5use crate::Span;
6
7pub trait EventReceiver {
8    fn std_table_open(&mut self, _span: Span, _error: &mut dyn ErrorSink) {}
9    fn std_table_close(&mut self, _span: Span, _error: &mut dyn ErrorSink) {}
10    fn array_table_open(&mut self, _span: Span, _error: &mut dyn ErrorSink) {}
11    fn array_table_close(&mut self, _span: Span, _error: &mut dyn ErrorSink) {}
12    /// Returns if entering the inline table is allowed
13    #[must_use]
14    fn inline_table_open(&mut self, _span: Span, _error: &mut dyn ErrorSink) -> bool {
15        true
16    }
17    fn inline_table_close(&mut self, _span: Span, _error: &mut dyn ErrorSink) {}
18    /// Returns if entering the array is allowed
19    #[must_use]
20    fn array_open(&mut self, _span: Span, _error: &mut dyn ErrorSink) -> bool {
21        true
22    }
23    fn array_close(&mut self, _span: Span, _error: &mut dyn ErrorSink) {}
24    fn simple_key(&mut self, _span: Span, _kind: Option<Encoding>, _error: &mut dyn ErrorSink) {}
25    fn key_sep(&mut self, _span: Span, _error: &mut dyn ErrorSink) {}
26    fn key_val_sep(&mut self, _span: Span, _error: &mut dyn ErrorSink) {}
27    fn scalar(&mut self, _span: Span, _kind: Option<Encoding>, _error: &mut dyn ErrorSink) {}
28    fn value_sep(&mut self, _span: Span, _error: &mut dyn ErrorSink) {}
29    fn whitespace(&mut self, _span: Span, _error: &mut dyn ErrorSink) {}
30    fn comment(&mut self, _span: Span, _error: &mut dyn ErrorSink) {}
31    fn newline(&mut self, _span: Span, _error: &mut dyn ErrorSink) {}
32    fn error(&mut self, _span: Span, _error: &mut dyn ErrorSink) {}
33}
34
35impl<F> EventReceiver for F
36where
37    F: FnMut(Event),
38{
39    fn std_table_open(&mut self, span: Span, _error: &mut dyn ErrorSink) {
40        (self)(Event {
41            kind: EventKind::StdTableOpen,
42            encoding: None,
43            span,
44        });
45    }
46    fn std_table_close(&mut self, span: Span, _error: &mut dyn ErrorSink) {
47        (self)(Event {
48            kind: EventKind::StdTableClose,
49            encoding: None,
50            span,
51        });
52    }
53    fn array_table_open(&mut self, span: Span, _error: &mut dyn ErrorSink) {
54        (self)(Event {
55            kind: EventKind::ArrayTableOpen,
56            encoding: None,
57            span,
58        });
59    }
60    fn array_table_close(&mut self, span: Span, _error: &mut dyn ErrorSink) {
61        (self)(Event {
62            kind: EventKind::ArrayTableClose,
63            encoding: None,
64            span,
65        });
66    }
67    fn inline_table_open(&mut self, span: Span, _error: &mut dyn ErrorSink) -> bool {
68        (self)(Event {
69            kind: EventKind::InlineTableOpen,
70            encoding: None,
71            span,
72        });
73        true
74    }
75    fn inline_table_close(&mut self, span: Span, _error: &mut dyn ErrorSink) {
76        (self)(Event {
77            kind: EventKind::InlineTableClose,
78            encoding: None,
79            span,
80        });
81    }
82    fn array_open(&mut self, span: Span, _error: &mut dyn ErrorSink) -> bool {
83        (self)(Event {
84            kind: EventKind::ArrayOpen,
85            encoding: None,
86            span,
87        });
88        true
89    }
90    fn array_close(&mut self, span: Span, _error: &mut dyn ErrorSink) {
91        (self)(Event {
92            kind: EventKind::ArrayClose,
93            encoding: None,
94            span,
95        });
96    }
97    fn simple_key(&mut self, span: Span, encoding: Option<Encoding>, _error: &mut dyn ErrorSink) {
98        (self)(Event {
99            kind: EventKind::SimpleKey,
100            encoding,
101            span,
102        });
103    }
104    fn key_sep(&mut self, span: Span, _error: &mut dyn ErrorSink) {
105        (self)(Event {
106            kind: EventKind::KeySep,
107            encoding: None,
108            span,
109        });
110    }
111    fn key_val_sep(&mut self, span: Span, _error: &mut dyn ErrorSink) {
112        (self)(Event {
113            kind: EventKind::KeyValSep,
114            encoding: None,
115            span,
116        });
117    }
118    fn scalar(&mut self, span: Span, encoding: Option<Encoding>, _error: &mut dyn ErrorSink) {
119        (self)(Event {
120            kind: EventKind::Scalar,
121            encoding,
122            span,
123        });
124    }
125    fn value_sep(&mut self, span: Span, _error: &mut dyn ErrorSink) {
126        (self)(Event {
127            kind: EventKind::ValueSep,
128            encoding: None,
129            span,
130        });
131    }
132    fn whitespace(&mut self, span: Span, _error: &mut dyn ErrorSink) {
133        (self)(Event {
134            kind: EventKind::Whitespace,
135            encoding: None,
136            span,
137        });
138    }
139    fn comment(&mut self, span: Span, _error: &mut dyn ErrorSink) {
140        (self)(Event {
141            kind: EventKind::Comment,
142            encoding: None,
143            span,
144        });
145    }
146    fn newline(&mut self, span: Span, _error: &mut dyn ErrorSink) {
147        (self)(Event {
148            kind: EventKind::Newline,
149            encoding: None,
150            span,
151        });
152    }
153    fn error(&mut self, span: Span, _error: &mut dyn ErrorSink) {
154        (self)(Event {
155            kind: EventKind::Error,
156            encoding: None,
157            span,
158        });
159    }
160}
161
162#[cfg(feature = "alloc")]
163#[allow(unused_qualifications)]
164impl EventReceiver for alloc::vec::Vec<Event> {
165    fn std_table_open(&mut self, span: Span, _error: &mut dyn ErrorSink) {
166        self.push(Event {
167            kind: EventKind::StdTableOpen,
168            encoding: None,
169            span,
170        });
171    }
172    fn std_table_close(&mut self, span: Span, _error: &mut dyn ErrorSink) {
173        self.push(Event {
174            kind: EventKind::StdTableClose,
175            encoding: None,
176            span,
177        });
178    }
179    fn array_table_open(&mut self, span: Span, _error: &mut dyn ErrorSink) {
180        self.push(Event {
181            kind: EventKind::ArrayTableOpen,
182            encoding: None,
183            span,
184        });
185    }
186    fn array_table_close(&mut self, span: Span, _error: &mut dyn ErrorSink) {
187        self.push(Event {
188            kind: EventKind::ArrayTableClose,
189            encoding: None,
190            span,
191        });
192    }
193    fn inline_table_open(&mut self, span: Span, _error: &mut dyn ErrorSink) -> bool {
194        self.push(Event {
195            kind: EventKind::InlineTableOpen,
196            encoding: None,
197            span,
198        });
199        true
200    }
201    fn inline_table_close(&mut self, span: Span, _error: &mut dyn ErrorSink) {
202        self.push(Event {
203            kind: EventKind::InlineTableClose,
204            encoding: None,
205            span,
206        });
207    }
208    fn array_open(&mut self, span: Span, _error: &mut dyn ErrorSink) -> bool {
209        self.push(Event {
210            kind: EventKind::ArrayOpen,
211            encoding: None,
212            span,
213        });
214        true
215    }
216    fn array_close(&mut self, span: Span, _error: &mut dyn ErrorSink) {
217        self.push(Event {
218            kind: EventKind::ArrayClose,
219            encoding: None,
220            span,
221        });
222    }
223    fn simple_key(&mut self, span: Span, encoding: Option<Encoding>, _error: &mut dyn ErrorSink) {
224        self.push(Event {
225            kind: EventKind::SimpleKey,
226            encoding,
227            span,
228        });
229    }
230    fn key_sep(&mut self, span: Span, _error: &mut dyn ErrorSink) {
231        self.push(Event {
232            kind: EventKind::KeySep,
233            encoding: None,
234            span,
235        });
236    }
237    fn key_val_sep(&mut self, span: Span, _error: &mut dyn ErrorSink) {
238        self.push(Event {
239            kind: EventKind::KeyValSep,
240            encoding: None,
241            span,
242        });
243    }
244    fn scalar(&mut self, span: Span, encoding: Option<Encoding>, _error: &mut dyn ErrorSink) {
245        self.push(Event {
246            kind: EventKind::Scalar,
247            encoding,
248            span,
249        });
250    }
251    fn value_sep(&mut self, span: Span, _error: &mut dyn ErrorSink) {
252        self.push(Event {
253            kind: EventKind::ValueSep,
254            encoding: None,
255            span,
256        });
257    }
258    fn whitespace(&mut self, span: Span, _error: &mut dyn ErrorSink) {
259        self.push(Event {
260            kind: EventKind::Whitespace,
261            encoding: None,
262            span,
263        });
264    }
265    fn comment(&mut self, span: Span, _error: &mut dyn ErrorSink) {
266        self.push(Event {
267            kind: EventKind::Comment,
268            encoding: None,
269            span,
270        });
271    }
272    fn newline(&mut self, span: Span, _error: &mut dyn ErrorSink) {
273        self.push(Event {
274            kind: EventKind::Newline,
275            encoding: None,
276            span,
277        });
278    }
279    fn error(&mut self, span: Span, _error: &mut dyn ErrorSink) {
280        self.push(Event {
281            kind: EventKind::Error,
282            encoding: None,
283            span,
284        });
285    }
286}
287
288impl EventReceiver for () {}
289
290/// Centralize validation for all whitespace-like content
291pub struct ValidateWhitespace<'r, 's> {
292    receiver: &'r mut dyn EventReceiver,
293    source: Source<'s>,
294}
295
296impl<'r, 's> ValidateWhitespace<'r, 's> {
297    pub fn new(receiver: &'r mut dyn EventReceiver, source: Source<'s>) -> Self {
298        Self { receiver, source }
299    }
300}
301
302impl EventReceiver for ValidateWhitespace<'_, '_> {
303    fn std_table_open(&mut self, span: Span, error: &mut dyn ErrorSink) {
304        self.receiver.std_table_open(span, error);
305    }
306    fn std_table_close(&mut self, span: Span, error: &mut dyn ErrorSink) {
307        self.receiver.std_table_close(span, error);
308    }
309    fn array_table_open(&mut self, span: Span, error: &mut dyn ErrorSink) {
310        self.receiver.array_table_open(span, error);
311    }
312    fn array_table_close(&mut self, span: Span, error: &mut dyn ErrorSink) {
313        self.receiver.array_table_close(span, error);
314    }
315    fn inline_table_open(&mut self, span: Span, error: &mut dyn ErrorSink) -> bool {
316        self.receiver.inline_table_open(span, error)
317    }
318    fn inline_table_close(&mut self, span: Span, error: &mut dyn ErrorSink) {
319        self.receiver.inline_table_close(span, error);
320    }
321    fn array_open(&mut self, span: Span, error: &mut dyn ErrorSink) -> bool {
322        self.receiver.array_open(span, error)
323    }
324    fn array_close(&mut self, span: Span, error: &mut dyn ErrorSink) {
325        self.receiver.array_close(span, error);
326    }
327    fn simple_key(&mut self, span: Span, encoding: Option<Encoding>, error: &mut dyn ErrorSink) {
328        self.receiver.simple_key(span, encoding, error);
329    }
330    fn key_sep(&mut self, span: Span, error: &mut dyn ErrorSink) {
331        self.receiver.key_sep(span, error);
332    }
333    fn key_val_sep(&mut self, span: Span, error: &mut dyn ErrorSink) {
334        self.receiver.key_val_sep(span, error);
335    }
336    fn scalar(&mut self, span: Span, encoding: Option<Encoding>, error: &mut dyn ErrorSink) {
337        self.receiver.scalar(span, encoding, error);
338    }
339    fn value_sep(&mut self, span: Span, error: &mut dyn ErrorSink) {
340        self.receiver.value_sep(span, error);
341    }
342    fn whitespace(&mut self, span: Span, error: &mut dyn ErrorSink) {
343        #[cfg(feature = "unsafe")] // SAFETY: callers must use valid span
344        let raw = unsafe { self.source.get_unchecked(span) };
345        #[cfg(not(feature = "unsafe"))]
346        let raw = self.source.get(span).expect("token spans are valid");
347        raw.decode_whitespace(error);
348
349        self.receiver.whitespace(span, error);
350    }
351    fn comment(&mut self, span: Span, error: &mut dyn ErrorSink) {
352        #[cfg(feature = "unsafe")] // SAFETY: callers must use valid span
353        let raw = unsafe { self.source.get_unchecked(span) };
354        #[cfg(not(feature = "unsafe"))]
355        let raw = self.source.get(span).expect("token spans are valid");
356        raw.decode_comment(error);
357
358        self.receiver.comment(span, error);
359    }
360    fn newline(&mut self, span: Span, error: &mut dyn ErrorSink) {
361        #[cfg(feature = "unsafe")] // SAFETY: callers must use valid span
362        let raw = unsafe { self.source.get_unchecked(span) };
363        #[cfg(not(feature = "unsafe"))]
364        let raw = self.source.get(span).expect("token spans are valid");
365        raw.decode_newline(error);
366
367        self.receiver.newline(span, error);
368    }
369    fn error(&mut self, span: Span, error: &mut dyn ErrorSink) {
370        self.receiver.error(span, error);
371    }
372}
373
374pub struct RecursionGuard<'r> {
375    receiver: &'r mut dyn EventReceiver,
376    max_depth: u32,
377    depth: i64,
378}
379
380impl<'r> RecursionGuard<'r> {
381    pub fn new(receiver: &'r mut dyn EventReceiver, max_depth: u32) -> Self {
382        Self {
383            receiver,
384            max_depth,
385            depth: 0,
386        }
387    }
388
389    fn within_depth(&self) -> bool {
390        self.depth <= self.max_depth as i64
391    }
392}
393
394impl EventReceiver for RecursionGuard<'_> {
395    fn std_table_open(&mut self, span: Span, error: &mut dyn ErrorSink) {
396        self.receiver.std_table_open(span, error);
397    }
398    fn std_table_close(&mut self, span: Span, error: &mut dyn ErrorSink) {
399        self.receiver.std_table_close(span, error);
400    }
401    fn array_table_open(&mut self, span: Span, error: &mut dyn ErrorSink) {
402        self.receiver.array_table_open(span, error);
403    }
404    fn array_table_close(&mut self, span: Span, error: &mut dyn ErrorSink) {
405        self.receiver.array_table_close(span, error);
406    }
407    fn inline_table_open(&mut self, span: Span, error: &mut dyn ErrorSink) -> bool {
408        let allowed = self.receiver.inline_table_open(span, error);
409        self.depth += 1;
410        let within_depth = self.within_depth();
411        if allowed && !within_depth {
412            error.report_error(
413                ParseError::new("cannot recurse further; max recursion depth met")
414                    .with_unexpected(span),
415            );
416        }
417        allowed && within_depth
418    }
419    fn inline_table_close(&mut self, span: Span, error: &mut dyn ErrorSink) {
420        self.depth -= 1;
421        self.receiver.inline_table_close(span, error);
422    }
423    fn array_open(&mut self, span: Span, error: &mut dyn ErrorSink) -> bool {
424        let allowed = self.receiver.array_open(span, error);
425        self.depth += 1;
426        let within_depth = self.within_depth();
427        if allowed && !within_depth {
428            error.report_error(
429                ParseError::new("cannot recurse further; max recursion depth met")
430                    .with_unexpected(span),
431            );
432        }
433        allowed && within_depth
434    }
435    fn array_close(&mut self, span: Span, error: &mut dyn ErrorSink) {
436        self.depth -= 1;
437        self.receiver.array_close(span, error);
438    }
439    fn simple_key(&mut self, span: Span, encoding: Option<Encoding>, error: &mut dyn ErrorSink) {
440        self.receiver.simple_key(span, encoding, error);
441    }
442    fn key_sep(&mut self, span: Span, error: &mut dyn ErrorSink) {
443        self.receiver.key_sep(span, error);
444    }
445    fn key_val_sep(&mut self, span: Span, error: &mut dyn ErrorSink) {
446        self.receiver.key_val_sep(span, error);
447    }
448    fn scalar(&mut self, span: Span, encoding: Option<Encoding>, error: &mut dyn ErrorSink) {
449        self.receiver.scalar(span, encoding, error);
450    }
451    fn value_sep(&mut self, span: Span, error: &mut dyn ErrorSink) {
452        self.receiver.value_sep(span, error);
453    }
454    fn whitespace(&mut self, span: Span, error: &mut dyn ErrorSink) {
455        self.receiver.whitespace(span, error);
456    }
457    fn comment(&mut self, span: Span, error: &mut dyn ErrorSink) {
458        self.receiver.comment(span, error);
459    }
460    fn newline(&mut self, span: Span, error: &mut dyn ErrorSink) {
461        self.receiver.newline(span, error);
462    }
463    fn error(&mut self, span: Span, error: &mut dyn ErrorSink) {
464        self.receiver.error(span, error);
465    }
466}
467
468#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
469pub struct Event {
470    kind: EventKind,
471    encoding: Option<Encoding>,
472    span: Span,
473}
474
475impl Event {
476    pub fn new_unchecked(kind: EventKind, encoding: Option<Encoding>, span: Span) -> Self {
477        Self {
478            kind,
479            encoding,
480            span,
481        }
482    }
483
484    #[inline(always)]
485    pub fn kind(&self) -> EventKind {
486        self.kind
487    }
488
489    #[inline(always)]
490    pub fn encoding(&self) -> Option<Encoding> {
491        self.encoding
492    }
493
494    #[inline(always)]
495    pub fn span(&self) -> Span {
496        self.span
497    }
498}
499
500#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
501pub enum EventKind {
502    StdTableOpen,
503    StdTableClose,
504    ArrayTableOpen,
505    ArrayTableClose,
506    InlineTableOpen,
507    InlineTableClose,
508    ArrayOpen,
509    ArrayClose,
510    SimpleKey,
511    KeySep,
512    KeyValSep,
513    Scalar,
514    ValueSep,
515    Whitespace,
516    Comment,
517    Newline,
518    Error,
519}
520
521impl EventKind {
522    pub const fn description(&self) -> &'static str {
523        match self {
524            Self::StdTableOpen => "std-table open",
525            Self::StdTableClose => "std-table close",
526            Self::ArrayTableOpen => "array-table open",
527            Self::ArrayTableClose => "array-table close",
528            Self::InlineTableOpen => "inline-table open",
529            Self::InlineTableClose => "inline-table close",
530            Self::ArrayOpen => "array open",
531            Self::ArrayClose => "array close",
532            Self::SimpleKey => "key",
533            Self::KeySep => "key separator",
534            Self::KeyValSep => "key-value separator",
535            Self::Scalar => "value",
536            Self::ValueSep => "value separator",
537            Self::Whitespace => "whitespace",
538            Self::Comment => "comment",
539            Self::Newline => "newline",
540            Self::Error => "error",
541        }
542    }
543}
toml_parser/parser/event.rs

toml_parser/parser/
event.rs
