toml_parser/parser/
event.rs

1use crate::ErrorSink;
2use crate::ParseError;
3use crate::Source;
4use crate::Span;
5use crate::decoder::Encoding;
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        // `decode_whitespace` is a no-op, so don't bother
344        self.receiver.whitespace(span, error);
345    }
346    fn comment(&mut self, span: Span, error: &mut dyn ErrorSink) {
347        let raw = self.source.get(span).expect("token spans are valid");
348        raw.decode_comment(error);
349
350        self.receiver.comment(span, error);
351    }
352    fn newline(&mut self, span: Span, error: &mut dyn ErrorSink) {
353        let raw = self.source.get(span).expect("token spans are valid");
354        raw.decode_newline(error);
355
356        self.receiver.newline(span, error);
357    }
358    fn error(&mut self, span: Span, error: &mut dyn ErrorSink) {
359        self.receiver.error(span, error);
360    }
361}
362
363pub struct RecursionGuard<'r> {
364    receiver: &'r mut dyn EventReceiver,
365    max_depth: u32,
366    depth: i64,
367}
368
369impl<'r> RecursionGuard<'r> {
370    pub fn new(receiver: &'r mut dyn EventReceiver, max_depth: u32) -> Self {
371        Self {
372            receiver,
373            max_depth,
374            depth: 0,
375        }
376    }
377
378    fn within_depth(&self) -> bool {
379        self.depth <= self.max_depth as i64
380    }
381}
382
383impl EventReceiver for RecursionGuard<'_> {
384    fn std_table_open(&mut self, span: Span, error: &mut dyn ErrorSink) {
385        self.receiver.std_table_open(span, error);
386    }
387    fn std_table_close(&mut self, span: Span, error: &mut dyn ErrorSink) {
388        self.receiver.std_table_close(span, error);
389    }
390    fn array_table_open(&mut self, span: Span, error: &mut dyn ErrorSink) {
391        self.receiver.array_table_open(span, error);
392    }
393    fn array_table_close(&mut self, span: Span, error: &mut dyn ErrorSink) {
394        self.receiver.array_table_close(span, error);
395    }
396    fn inline_table_open(&mut self, span: Span, error: &mut dyn ErrorSink) -> bool {
397        let allowed = self.receiver.inline_table_open(span, error);
398        self.depth += 1;
399        let within_depth = self.within_depth();
400        if allowed && !within_depth {
401            error.report_error(
402                ParseError::new("cannot recurse further; max recursion depth met")
403                    .with_unexpected(span),
404            );
405        }
406        allowed && within_depth
407    }
408    fn inline_table_close(&mut self, span: Span, error: &mut dyn ErrorSink) {
409        self.depth -= 1;
410        self.receiver.inline_table_close(span, error);
411    }
412    fn array_open(&mut self, span: Span, error: &mut dyn ErrorSink) -> bool {
413        let allowed = self.receiver.array_open(span, error);
414        self.depth += 1;
415        let within_depth = self.within_depth();
416        if allowed && !within_depth {
417            error.report_error(
418                ParseError::new("cannot recurse further; max recursion depth met")
419                    .with_unexpected(span),
420            );
421        }
422        allowed && within_depth
423    }
424    fn array_close(&mut self, span: Span, error: &mut dyn ErrorSink) {
425        self.depth -= 1;
426        self.receiver.array_close(span, error);
427    }
428    fn simple_key(&mut self, span: Span, encoding: Option<Encoding>, error: &mut dyn ErrorSink) {
429        self.receiver.simple_key(span, encoding, error);
430    }
431    fn key_sep(&mut self, span: Span, error: &mut dyn ErrorSink) {
432        self.receiver.key_sep(span, error);
433    }
434    fn key_val_sep(&mut self, span: Span, error: &mut dyn ErrorSink) {
435        self.receiver.key_val_sep(span, error);
436    }
437    fn scalar(&mut self, span: Span, encoding: Option<Encoding>, error: &mut dyn ErrorSink) {
438        self.receiver.scalar(span, encoding, error);
439    }
440    fn value_sep(&mut self, span: Span, error: &mut dyn ErrorSink) {
441        self.receiver.value_sep(span, error);
442    }
443    fn whitespace(&mut self, span: Span, error: &mut dyn ErrorSink) {
444        self.receiver.whitespace(span, error);
445    }
446    fn comment(&mut self, span: Span, error: &mut dyn ErrorSink) {
447        self.receiver.comment(span, error);
448    }
449    fn newline(&mut self, span: Span, error: &mut dyn ErrorSink) {
450        self.receiver.newline(span, error);
451    }
452    fn error(&mut self, span: Span, error: &mut dyn ErrorSink) {
453        self.receiver.error(span, error);
454    }
455}
456
457#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
458pub struct Event {
459    kind: EventKind,
460    encoding: Option<Encoding>,
461    span: Span,
462}
463
464impl Event {
465    pub fn new_unchecked(kind: EventKind, encoding: Option<Encoding>, span: Span) -> Self {
466        Self {
467            kind,
468            encoding,
469            span,
470        }
471    }
472
473    #[inline(always)]
474    pub fn kind(&self) -> EventKind {
475        self.kind
476    }
477
478    #[inline(always)]
479    pub fn encoding(&self) -> Option<Encoding> {
480        self.encoding
481    }
482
483    #[inline(always)]
484    pub fn span(&self) -> Span {
485        self.span
486    }
487}
488
489#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
490pub enum EventKind {
491    StdTableOpen,
492    StdTableClose,
493    ArrayTableOpen,
494    ArrayTableClose,
495    InlineTableOpen,
496    InlineTableClose,
497    ArrayOpen,
498    ArrayClose,
499    SimpleKey,
500    KeySep,
501    KeyValSep,
502    Scalar,
503    ValueSep,
504    Whitespace,
505    Comment,
506    Newline,
507    Error,
508}
509
510impl EventKind {
511    pub const fn description(&self) -> &'static str {
512        match self {
513            Self::StdTableOpen => "std-table open",
514            Self::StdTableClose => "std-table close",
515            Self::ArrayTableOpen => "array-table open",
516            Self::ArrayTableClose => "array-table close",
517            Self::InlineTableOpen => "inline-table open",
518            Self::InlineTableClose => "inline-table close",
519            Self::ArrayOpen => "array open",
520            Self::ArrayClose => "array close",
521            Self::SimpleKey => "key",
522            Self::KeySep => "key separator",
523            Self::KeyValSep => "key-value separator",
524            Self::Scalar => "value",
525            Self::ValueSep => "value separator",
526            Self::Whitespace => "whitespace",
527            Self::Comment => "comment",
528            Self::Newline => "newline",
529            Self::Error => "error",
530        }
531    }
532}
toml_parser/parser/event.rs

toml_parser/parser/
event.rs
