winnow/combinator/
parser.rs

1use crate::combinator::trace;
2use crate::combinator::trace_result;
3use crate::combinator::DisplayDebug;
4#[cfg(feature = "unstable-recover")]
5#[cfg(feature = "std")]
6use crate::error::FromRecoverableError;
7use crate::error::{AddContext, ErrMode, ErrorKind, FromExternalError, ParserError};
8use crate::lib::std::borrow::Borrow;
9use crate::lib::std::ops::Range;
10#[cfg(feature = "unstable-recover")]
11#[cfg(feature = "std")]
12use crate::stream::Recover;
13use crate::stream::StreamIsPartial;
14use crate::stream::{Location, Stream};
15use crate::*;
16
17/// Implementation of [`Parser::by_ref`]
18pub struct ByRef<'p, P> {
19    p: &'p mut P,
20}
21
22impl<'p, P> ByRef<'p, P> {
23    #[inline(always)]
24    pub(crate) fn new(p: &'p mut P) -> Self {
25        Self { p }
26    }
27}
28
29impl<'p, I, O, E, P> Parser<I, O, E> for ByRef<'p, P>
30where
31    P: Parser<I, O, E>,
32{
33    #[inline(always)]
34    fn parse_next(&mut self, i: &mut I) -> PResult<O, E> {
35        self.p.parse_next(i)
36    }
37}
38
39/// Implementation of [`Parser::map`]
40pub struct Map<F, G, I, O, O2, E>
41where
42    F: Parser<I, O, E>,
43    G: FnMut(O) -> O2,
44{
45    parser: F,
46    map: G,
47    i: core::marker::PhantomData<I>,
48    o: core::marker::PhantomData<O>,
49    o2: core::marker::PhantomData<O2>,
50    e: core::marker::PhantomData<E>,
51}
52
53impl<F, G, I, O, O2, E> Map<F, G, I, O, O2, E>
54where
55    F: Parser<I, O, E>,
56    G: FnMut(O) -> O2,
57{
58    #[inline(always)]
59    pub(crate) fn new(parser: F, map: G) -> Self {
60        Self {
61            parser,
62            map,
63            i: Default::default(),
64            o: Default::default(),
65            o2: Default::default(),
66            e: Default::default(),
67        }
68    }
69}
70
71impl<F, G, I, O, O2, E> Parser<I, O2, E> for Map<F, G, I, O, O2, E>
72where
73    F: Parser<I, O, E>,
74    G: FnMut(O) -> O2,
75{
76    #[inline]
77    fn parse_next(&mut self, i: &mut I) -> PResult<O2, E> {
78        match self.parser.parse_next(i) {
79            Err(e) => Err(e),
80            Ok(o) => Ok((self.map)(o)),
81        }
82    }
83}
84
85/// Implementation of [`Parser::try_map`]
86pub struct TryMap<F, G, I, O, O2, E, E2>
87where
88    F: Parser<I, O, E>,
89    G: FnMut(O) -> Result<O2, E2>,
90    I: Stream,
91    E: FromExternalError<I, E2>,
92{
93    parser: F,
94    map: G,
95    i: core::marker::PhantomData<I>,
96    o: core::marker::PhantomData<O>,
97    o2: core::marker::PhantomData<O2>,
98    e: core::marker::PhantomData<E>,
99    e2: core::marker::PhantomData<E2>,
100}
101
102impl<F, G, I, O, O2, E, E2> TryMap<F, G, I, O, O2, E, E2>
103where
104    F: Parser<I, O, E>,
105    G: FnMut(O) -> Result<O2, E2>,
106    I: Stream,
107    E: FromExternalError<I, E2>,
108{
109    #[inline(always)]
110    pub(crate) fn new(parser: F, map: G) -> Self {
111        Self {
112            parser,
113            map,
114            i: Default::default(),
115            o: Default::default(),
116            o2: Default::default(),
117            e: Default::default(),
118            e2: Default::default(),
119        }
120    }
121}
122
123impl<F, G, I, O, O2, E, E2> Parser<I, O2, E> for TryMap<F, G, I, O, O2, E, E2>
124where
125    F: Parser<I, O, E>,
126    G: FnMut(O) -> Result<O2, E2>,
127    I: Stream,
128    E: FromExternalError<I, E2>,
129{
130    #[inline]
131    fn parse_next(&mut self, input: &mut I) -> PResult<O2, E> {
132        let start = input.checkpoint();
133        let o = self.parser.parse_next(input)?;
134        let res = (self.map)(o).map_err(|err| {
135            input.reset(&start);
136            ErrMode::from_external_error(input, ErrorKind::Verify, err)
137        });
138        trace_result("verify", &res);
139        res
140    }
141}
142
143/// Implementation of [`Parser::verify_map`]
144pub struct VerifyMap<F, G, I, O, O2, E>
145where
146    F: Parser<I, O, E>,
147    G: FnMut(O) -> Option<O2>,
148    I: Stream,
149    E: ParserError<I>,
150{
151    parser: F,
152    map: G,
153    i: core::marker::PhantomData<I>,
154    o: core::marker::PhantomData<O>,
155    o2: core::marker::PhantomData<O2>,
156    e: core::marker::PhantomData<E>,
157}
158
159impl<F, G, I, O, O2, E> VerifyMap<F, G, I, O, O2, E>
160where
161    F: Parser<I, O, E>,
162    G: FnMut(O) -> Option<O2>,
163    I: Stream,
164    E: ParserError<I>,
165{
166    #[inline(always)]
167    pub(crate) fn new(parser: F, map: G) -> Self {
168        Self {
169            parser,
170            map,
171            i: Default::default(),
172            o: Default::default(),
173            o2: Default::default(),
174            e: Default::default(),
175        }
176    }
177}
178
179impl<F, G, I, O, O2, E> Parser<I, O2, E> for VerifyMap<F, G, I, O, O2, E>
180where
181    F: Parser<I, O, E>,
182    G: FnMut(O) -> Option<O2>,
183    I: Stream,
184    E: ParserError<I>,
185{
186    #[inline]
187    fn parse_next(&mut self, input: &mut I) -> PResult<O2, E> {
188        let start = input.checkpoint();
189        let o = self.parser.parse_next(input)?;
190        let res = (self.map)(o).ok_or_else(|| {
191            input.reset(&start);
192            ErrMode::from_error_kind(input, ErrorKind::Verify)
193        });
194        trace_result("verify", &res);
195        res
196    }
197}
198
199/// Implementation of [`Parser::and_then`]
200pub struct AndThen<F, G, I, O, O2, E>
201where
202    F: Parser<I, O, E>,
203    G: Parser<O, O2, E>,
204    O: StreamIsPartial,
205    I: Stream,
206{
207    outer: F,
208    inner: G,
209    i: core::marker::PhantomData<I>,
210    o: core::marker::PhantomData<O>,
211    o2: core::marker::PhantomData<O2>,
212    e: core::marker::PhantomData<E>,
213}
214
215impl<F, G, I, O, O2, E> AndThen<F, G, I, O, O2, E>
216where
217    F: Parser<I, O, E>,
218    G: Parser<O, O2, E>,
219    O: StreamIsPartial,
220    I: Stream,
221{
222    #[inline(always)]
223    pub(crate) fn new(outer: F, inner: G) -> Self {
224        Self {
225            outer,
226            inner,
227            i: Default::default(),
228            o: Default::default(),
229            o2: Default::default(),
230            e: Default::default(),
231        }
232    }
233}
234
235impl<F, G, I, O, O2, E> Parser<I, O2, E> for AndThen<F, G, I, O, O2, E>
236where
237    F: Parser<I, O, E>,
238    G: Parser<O, O2, E>,
239    O: StreamIsPartial,
240    I: Stream,
241{
242    #[inline(always)]
243    fn parse_next(&mut self, i: &mut I) -> PResult<O2, E> {
244        let start = i.checkpoint();
245        let mut o = self.outer.parse_next(i)?;
246        let _ = o.complete();
247        let o2 = self.inner.parse_next(&mut o).map_err(|err| {
248            i.reset(&start);
249            err
250        })?;
251        Ok(o2)
252    }
253}
254
255/// Implementation of [`Parser::parse_to`]
256pub struct ParseTo<P, I, O, O2, E>
257where
258    P: Parser<I, O, E>,
259    I: Stream,
260    O: crate::stream::ParseSlice<O2>,
261    E: ParserError<I>,
262{
263    p: P,
264    i: core::marker::PhantomData<I>,
265    o: core::marker::PhantomData<O>,
266    o2: core::marker::PhantomData<O2>,
267    e: core::marker::PhantomData<E>,
268}
269
270impl<P, I, O, O2, E> ParseTo<P, I, O, O2, E>
271where
272    P: Parser<I, O, E>,
273    I: Stream,
274    O: crate::stream::ParseSlice<O2>,
275    E: ParserError<I>,
276{
277    #[inline(always)]
278    pub(crate) fn new(p: P) -> Self {
279        Self {
280            p,
281            i: Default::default(),
282            o: Default::default(),
283            o2: Default::default(),
284            e: Default::default(),
285        }
286    }
287}
288
289impl<P, I, O, O2, E> Parser<I, O2, E> for ParseTo<P, I, O, O2, E>
290where
291    P: Parser<I, O, E>,
292    I: Stream,
293    O: crate::stream::ParseSlice<O2>,
294    E: ParserError<I>,
295{
296    #[inline]
297    fn parse_next(&mut self, i: &mut I) -> PResult<O2, E> {
298        let start = i.checkpoint();
299        let o = self.p.parse_next(i)?;
300        let res = o.parse_slice().ok_or_else(|| {
301            i.reset(&start);
302            ErrMode::from_error_kind(i, ErrorKind::Verify)
303        });
304        trace_result("verify", &res);
305        res
306    }
307}
308
309/// Implementation of [`Parser::flat_map`]
310pub struct FlatMap<F, G, H, I, O, O2, E>
311where
312    F: Parser<I, O, E>,
313    G: FnMut(O) -> H,
314    H: Parser<I, O2, E>,
315{
316    f: F,
317    g: G,
318    h: core::marker::PhantomData<H>,
319    i: core::marker::PhantomData<I>,
320    o: core::marker::PhantomData<O>,
321    o2: core::marker::PhantomData<O2>,
322    e: core::marker::PhantomData<E>,
323}
324
325impl<F, G, H, I, O, O2, E> FlatMap<F, G, H, I, O, O2, E>
326where
327    F: Parser<I, O, E>,
328    G: FnMut(O) -> H,
329    H: Parser<I, O2, E>,
330{
331    #[inline(always)]
332    pub(crate) fn new(f: F, g: G) -> Self {
333        Self {
334            f,
335            g,
336            h: Default::default(),
337            i: Default::default(),
338            o: Default::default(),
339            o2: Default::default(),
340            e: Default::default(),
341        }
342    }
343}
344
345impl<F, G, H, I, O, O2, E> Parser<I, O2, E> for FlatMap<F, G, H, I, O, O2, E>
346where
347    F: Parser<I, O, E>,
348    G: FnMut(O) -> H,
349    H: Parser<I, O2, E>,
350{
351    #[inline(always)]
352    fn parse_next(&mut self, i: &mut I) -> PResult<O2, E> {
353        let o = self.f.parse_next(i)?;
354        (self.g)(o).parse_next(i)
355    }
356}
357
358/// Implementation of [`Parser::complete_err`]
359pub struct CompleteErr<F> {
360    f: F,
361}
362
363impl<F> CompleteErr<F> {
364    #[inline(always)]
365    pub(crate) fn new(f: F) -> Self {
366        Self { f }
367    }
368}
369
370impl<F, I, O, E> Parser<I, O, E> for CompleteErr<F>
371where
372    I: Stream,
373    F: Parser<I, O, E>,
374    E: ParserError<I>,
375{
376    #[inline]
377    fn parse_next(&mut self, input: &mut I) -> PResult<O, E> {
378        trace("complete_err", |input: &mut I| {
379            match (self.f).parse_next(input) {
380                Err(ErrMode::Incomplete(_)) => {
381                    Err(ErrMode::from_error_kind(input, ErrorKind::Complete))
382                }
383                rest => rest,
384            }
385        })
386        .parse_next(input)
387    }
388}
389
390/// Implementation of [`Parser::verify`]
391pub struct Verify<F, G, I, O, O2, E>
392where
393    F: Parser<I, O, E>,
394    G: FnMut(&O2) -> bool,
395    I: Stream,
396    O: Borrow<O2>,
397    O2: ?Sized,
398    E: ParserError<I>,
399{
400    parser: F,
401    filter: G,
402    i: core::marker::PhantomData<I>,
403    o: core::marker::PhantomData<O>,
404    o2: core::marker::PhantomData<O2>,
405    e: core::marker::PhantomData<E>,
406}
407
408impl<F, G, I, O, O2, E> Verify<F, G, I, O, O2, E>
409where
410    F: Parser<I, O, E>,
411    G: FnMut(&O2) -> bool,
412    I: Stream,
413    O: Borrow<O2>,
414    O2: ?Sized,
415    E: ParserError<I>,
416{
417    #[inline(always)]
418    pub(crate) fn new(parser: F, filter: G) -> Self {
419        Self {
420            parser,
421            filter,
422            i: Default::default(),
423            o: Default::default(),
424            o2: Default::default(),
425            e: Default::default(),
426        }
427    }
428}
429
430impl<F, G, I, O, O2, E> Parser<I, O, E> for Verify<F, G, I, O, O2, E>
431where
432    F: Parser<I, O, E>,
433    G: FnMut(&O2) -> bool,
434    I: Stream,
435    O: Borrow<O2>,
436    O2: ?Sized,
437    E: ParserError<I>,
438{
439    #[inline]
440    fn parse_next(&mut self, input: &mut I) -> PResult<O, E> {
441        let start = input.checkpoint();
442        let o = self.parser.parse_next(input)?;
443        let res = (self.filter)(o.borrow()).then_some(o).ok_or_else(|| {
444            input.reset(&start);
445            ErrMode::from_error_kind(input, ErrorKind::Verify)
446        });
447        trace_result("verify", &res);
448        res
449    }
450}
451
452/// Implementation of [`Parser::value`]
453pub struct Value<F, I, O, O2, E>
454where
455    F: Parser<I, O, E>,
456    O2: Clone,
457{
458    parser: F,
459    val: O2,
460    i: core::marker::PhantomData<I>,
461    o: core::marker::PhantomData<O>,
462    e: core::marker::PhantomData<E>,
463}
464
465impl<F, I, O, O2, E> Value<F, I, O, O2, E>
466where
467    F: Parser<I, O, E>,
468    O2: Clone,
469{
470    #[inline(always)]
471    pub(crate) fn new(parser: F, val: O2) -> Self {
472        Self {
473            parser,
474            val,
475            i: Default::default(),
476            o: Default::default(),
477            e: Default::default(),
478        }
479    }
480}
481
482impl<F, I, O, O2, E> Parser<I, O2, E> for Value<F, I, O, O2, E>
483where
484    F: Parser<I, O, E>,
485    O2: Clone,
486{
487    #[inline]
488    fn parse_next(&mut self, input: &mut I) -> PResult<O2, E> {
489        (self.parser).parse_next(input).map(|_| self.val.clone())
490    }
491}
492
493/// Implementation of [`Parser::default_value`]
494pub struct DefaultValue<F, I, O, O2, E>
495where
496    F: Parser<I, O, E>,
497    O2: core::default::Default,
498{
499    parser: F,
500    o2: core::marker::PhantomData<O2>,
501    i: core::marker::PhantomData<I>,
502    o: core::marker::PhantomData<O>,
503    e: core::marker::PhantomData<E>,
504}
505
506impl<F, I, O, O2, E> DefaultValue<F, I, O, O2, E>
507where
508    F: Parser<I, O, E>,
509    O2: core::default::Default,
510{
511    #[inline(always)]
512    pub(crate) fn new(parser: F) -> Self {
513        Self {
514            parser,
515            o2: Default::default(),
516            i: Default::default(),
517            o: Default::default(),
518            e: Default::default(),
519        }
520    }
521}
522
523impl<F, I, O, O2, E> Parser<I, O2, E> for DefaultValue<F, I, O, O2, E>
524where
525    F: Parser<I, O, E>,
526    O2: core::default::Default,
527{
528    #[inline]
529    fn parse_next(&mut self, input: &mut I) -> PResult<O2, E> {
530        (self.parser).parse_next(input).map(|_| O2::default())
531    }
532}
533
534/// Implementation of [`Parser::void`]
535pub struct Void<F, I, O, E>
536where
537    F: Parser<I, O, E>,
538{
539    parser: F,
540    i: core::marker::PhantomData<I>,
541    o: core::marker::PhantomData<O>,
542    e: core::marker::PhantomData<E>,
543}
544
545impl<F, I, O, E> Void<F, I, O, E>
546where
547    F: Parser<I, O, E>,
548{
549    #[inline(always)]
550    pub(crate) fn new(parser: F) -> Self {
551        Self {
552            parser,
553            i: Default::default(),
554            o: Default::default(),
555            e: Default::default(),
556        }
557    }
558}
559
560impl<F, I, O, E> Parser<I, (), E> for Void<F, I, O, E>
561where
562    F: Parser<I, O, E>,
563{
564    #[inline(always)]
565    fn parse_next(&mut self, input: &mut I) -> PResult<(), E> {
566        (self.parser).parse_next(input).map(|_| ())
567    }
568}
569
570/// Replaced with [`Take`]
571#[deprecated(since = "0.6.14", note = "Replaced with `Take`")]
572pub type Recognize<F, I, O, E> = Take<F, I, O, E>;
573
574/// Implementation of [`Parser::take`]
575pub struct Take<F, I, O, E>
576where
577    F: Parser<I, O, E>,
578    I: Stream,
579{
580    parser: F,
581    i: core::marker::PhantomData<I>,
582    o: core::marker::PhantomData<O>,
583    e: core::marker::PhantomData<E>,
584}
585
586impl<F, I, O, E> Take<F, I, O, E>
587where
588    F: Parser<I, O, E>,
589    I: Stream,
590{
591    #[inline(always)]
592    pub(crate) fn new(parser: F) -> Self {
593        Self {
594            parser,
595            i: Default::default(),
596            o: Default::default(),
597            e: Default::default(),
598        }
599    }
600}
601
602impl<I, O, E, F> Parser<I, <I as Stream>::Slice, E> for Take<F, I, O, E>
603where
604    F: Parser<I, O, E>,
605    I: Stream,
606{
607    #[inline]
608    fn parse_next(&mut self, input: &mut I) -> PResult<<I as Stream>::Slice, E> {
609        let checkpoint = input.checkpoint();
610        match (self.parser).parse_next(input) {
611            Ok(_) => {
612                let offset = input.offset_from(&checkpoint);
613                input.reset(&checkpoint);
614                let taken = input.next_slice(offset);
615                Ok(taken)
616            }
617            Err(e) => Err(e),
618        }
619    }
620}
621
622/// Replaced with [`WithTaken`]
623#[deprecated(since = "0.6.14", note = "Replaced with `WithTaken`")]
624pub type WithRecognized<F, I, O, E> = WithTaken<F, I, O, E>;
625
626/// Implementation of [`Parser::with_taken`]
627pub struct WithTaken<F, I, O, E>
628where
629    F: Parser<I, O, E>,
630    I: Stream,
631{
632    parser: F,
633    i: core::marker::PhantomData<I>,
634    o: core::marker::PhantomData<O>,
635    e: core::marker::PhantomData<E>,
636}
637
638impl<F, I, O, E> WithTaken<F, I, O, E>
639where
640    F: Parser<I, O, E>,
641    I: Stream,
642{
643    #[inline(always)]
644    pub(crate) fn new(parser: F) -> Self {
645        Self {
646            parser,
647            i: Default::default(),
648            o: Default::default(),
649            e: Default::default(),
650        }
651    }
652}
653
654impl<F, I, O, E> Parser<I, (O, <I as Stream>::Slice), E> for WithTaken<F, I, O, E>
655where
656    F: Parser<I, O, E>,
657    I: Stream,
658{
659    #[inline]
660    fn parse_next(&mut self, input: &mut I) -> PResult<(O, <I as Stream>::Slice), E> {
661        let checkpoint = input.checkpoint();
662        match (self.parser).parse_next(input) {
663            Ok(result) => {
664                let offset = input.offset_from(&checkpoint);
665                input.reset(&checkpoint);
666                let taken = input.next_slice(offset);
667                Ok((result, taken))
668            }
669            Err(e) => Err(e),
670        }
671    }
672}
673
674/// Implementation of [`Parser::span`]
675pub struct Span<F, I, O, E>
676where
677    F: Parser<I, O, E>,
678    I: Stream + Location,
679{
680    parser: F,
681    i: core::marker::PhantomData<I>,
682    o: core::marker::PhantomData<O>,
683    e: core::marker::PhantomData<E>,
684}
685
686impl<F, I, O, E> Span<F, I, O, E>
687where
688    F: Parser<I, O, E>,
689    I: Stream + Location,
690{
691    #[inline(always)]
692    pub(crate) fn new(parser: F) -> Self {
693        Self {
694            parser,
695            i: Default::default(),
696            o: Default::default(),
697            e: Default::default(),
698        }
699    }
700}
701
702impl<I, O, E, F> Parser<I, Range<usize>, E> for Span<F, I, O, E>
703where
704    F: Parser<I, O, E>,
705    I: Stream + Location,
706{
707    #[inline]
708    fn parse_next(&mut self, input: &mut I) -> PResult<Range<usize>, E> {
709        let start = input.location();
710        self.parser.parse_next(input).map(move |_| {
711            let end = input.location();
712            start..end
713        })
714    }
715}
716
717/// Implementation of [`Parser::with_span`]
718pub struct WithSpan<F, I, O, E>
719where
720    F: Parser<I, O, E>,
721    I: Stream + Location,
722{
723    parser: F,
724    i: core::marker::PhantomData<I>,
725    o: core::marker::PhantomData<O>,
726    e: core::marker::PhantomData<E>,
727}
728
729impl<F, I, O, E> WithSpan<F, I, O, E>
730where
731    F: Parser<I, O, E>,
732    I: Stream + Location,
733{
734    #[inline(always)]
735    pub(crate) fn new(parser: F) -> Self {
736        Self {
737            parser,
738            i: Default::default(),
739            o: Default::default(),
740            e: Default::default(),
741        }
742    }
743}
744
745impl<F, I, O, E> Parser<I, (O, Range<usize>), E> for WithSpan<F, I, O, E>
746where
747    F: Parser<I, O, E>,
748    I: Stream + Location,
749{
750    #[inline]
751    fn parse_next(&mut self, input: &mut I) -> PResult<(O, Range<usize>), E> {
752        let start = input.location();
753        self.parser.parse_next(input).map(move |output| {
754            let end = input.location();
755            (output, (start..end))
756        })
757    }
758}
759
760/// Implementation of [`Parser::output_into`]
761pub struct OutputInto<F, I, O, O2, E>
762where
763    F: Parser<I, O, E>,
764    O: Into<O2>,
765{
766    parser: F,
767    i: core::marker::PhantomData<I>,
768    o: core::marker::PhantomData<O>,
769    o2: core::marker::PhantomData<O2>,
770    e: core::marker::PhantomData<E>,
771}
772
773impl<F, I, O, O2, E> OutputInto<F, I, O, O2, E>
774where
775    F: Parser<I, O, E>,
776    O: Into<O2>,
777{
778    #[inline(always)]
779    pub(crate) fn new(parser: F) -> Self {
780        Self {
781            parser,
782            i: Default::default(),
783            o: Default::default(),
784            o2: Default::default(),
785            e: Default::default(),
786        }
787    }
788}
789
790impl<F, I, O, O2, E> Parser<I, O2, E> for OutputInto<F, I, O, O2, E>
791where
792    F: Parser<I, O, E>,
793    O: Into<O2>,
794{
795    #[inline]
796    fn parse_next(&mut self, i: &mut I) -> PResult<O2, E> {
797        self.parser.parse_next(i).map(|o| o.into())
798    }
799}
800
801/// Implementation of [`Parser::err_into`]
802pub struct ErrInto<F, I, O, E, E2>
803where
804    F: Parser<I, O, E>,
805    E: Into<E2>,
806{
807    parser: F,
808    i: core::marker::PhantomData<I>,
809    o: core::marker::PhantomData<O>,
810    e: core::marker::PhantomData<E>,
811    e2: core::marker::PhantomData<E2>,
812}
813
814impl<F, I, O, E, E2> ErrInto<F, I, O, E, E2>
815where
816    F: Parser<I, O, E>,
817    E: Into<E2>,
818{
819    #[inline(always)]
820    pub(crate) fn new(parser: F) -> Self {
821        Self {
822            parser,
823            i: Default::default(),
824            o: Default::default(),
825            e: Default::default(),
826            e2: Default::default(),
827        }
828    }
829}
830
831impl<F, I, O, E, E2> Parser<I, O, E2> for ErrInto<F, I, O, E, E2>
832where
833    F: Parser<I, O, E>,
834    E: Into<E2>,
835{
836    #[inline]
837    fn parse_next(&mut self, i: &mut I) -> PResult<O, E2> {
838        match self.parser.parse_next(i) {
839            Ok(ok) => Ok(ok),
840            Err(ErrMode::Backtrack(e)) => Err(ErrMode::Backtrack(e.into())),
841            Err(ErrMode::Cut(e)) => Err(ErrMode::Cut(e.into())),
842            Err(ErrMode::Incomplete(e)) => Err(ErrMode::Incomplete(e)),
843        }
844    }
845}
846
847/// Implementation of [`Parser::context`]
848pub struct Context<F, I, O, E, C>
849where
850    F: Parser<I, O, E>,
851    I: Stream,
852    E: AddContext<I, C>,
853    C: Clone + crate::lib::std::fmt::Debug,
854{
855    parser: F,
856    context: C,
857    i: core::marker::PhantomData<I>,
858    o: core::marker::PhantomData<O>,
859    e: core::marker::PhantomData<E>,
860}
861
862impl<F, I, O, E, C> Context<F, I, O, E, C>
863where
864    F: Parser<I, O, E>,
865    I: Stream,
866    E: AddContext<I, C>,
867    C: Clone + crate::lib::std::fmt::Debug,
868{
869    #[inline(always)]
870    pub(crate) fn new(parser: F, context: C) -> Self {
871        Self {
872            parser,
873            context,
874            i: Default::default(),
875            o: Default::default(),
876            e: Default::default(),
877        }
878    }
879}
880
881impl<F, I, O, E, C> Parser<I, O, E> for Context<F, I, O, E, C>
882where
883    F: Parser<I, O, E>,
884    I: Stream,
885    E: AddContext<I, C>,
886    C: Clone + crate::lib::std::fmt::Debug,
887{
888    #[inline]
889    fn parse_next(&mut self, i: &mut I) -> PResult<O, E> {
890        let context = self.context.clone();
891        trace(DisplayDebug(self.context.clone()), move |i: &mut I| {
892            let start = i.checkpoint();
893            (self.parser)
894                .parse_next(i)
895                .map_err(|err| err.add_context(i, &start, context.clone()))
896        })
897        .parse_next(i)
898    }
899}
900
901/// Implementation of [`Parser::retry_after`]
902#[cfg(feature = "unstable-recover")]
903#[cfg(feature = "std")]
904pub struct RetryAfter<P, R, I, O, E>
905where
906    P: Parser<I, O, E>,
907    R: Parser<I, (), E>,
908    I: Stream,
909    I: Recover<E>,
910    E: FromRecoverableError<I, E>,
911{
912    parser: P,
913    recover: R,
914    i: core::marker::PhantomData<I>,
915    o: core::marker::PhantomData<O>,
916    e: core::marker::PhantomData<E>,
917}
918
919#[cfg(feature = "unstable-recover")]
920#[cfg(feature = "std")]
921impl<P, R, I, O, E> RetryAfter<P, R, I, O, E>
922where
923    P: Parser<I, O, E>,
924    R: Parser<I, (), E>,
925    I: Stream,
926    I: Recover<E>,
927    E: FromRecoverableError<I, E>,
928{
929    #[inline(always)]
930    pub(crate) fn new(parser: P, recover: R) -> Self {
931        Self {
932            parser,
933            recover,
934            i: Default::default(),
935            o: Default::default(),
936            e: Default::default(),
937        }
938    }
939}
940
941#[cfg(feature = "unstable-recover")]
942#[cfg(feature = "std")]
943impl<P, R, I, O, E> Parser<I, O, E> for RetryAfter<P, R, I, O, E>
944where
945    P: Parser<I, O, E>,
946    R: Parser<I, (), E>,
947    I: Stream,
948    I: Recover<E>,
949    E: FromRecoverableError<I, E>,
950{
951    #[inline(always)]
952    fn parse_next(&mut self, i: &mut I) -> PResult<O, E> {
953        if I::is_recovery_supported() {
954            retry_after_inner(&mut self.parser, &mut self.recover, i)
955        } else {
956            self.parser.parse_next(i)
957        }
958    }
959}
960
961#[cfg(feature = "unstable-recover")]
962#[cfg(feature = "std")]
963fn retry_after_inner<P, R, I, O, E>(parser: &mut P, recover: &mut R, i: &mut I) -> PResult<O, E>
964where
965    P: Parser<I, O, E>,
966    R: Parser<I, (), E>,
967    I: Stream,
968    I: Recover<E>,
969    E: FromRecoverableError<I, E>,
970{
971    loop {
972        let token_start = i.checkpoint();
973        let mut err = match parser.parse_next(i) {
974            Ok(o) => {
975                return Ok(o);
976            }
977            Err(ErrMode::Incomplete(e)) => return Err(ErrMode::Incomplete(e)),
978            Err(err) => err,
979        };
980        let err_start = i.checkpoint();
981        let err_start_eof_offset = i.eof_offset();
982        if recover.parse_next(i).is_ok() {
983            let i_eof_offset = i.eof_offset();
984            if err_start_eof_offset == i_eof_offset {
985                // Didn't advance so bubble the error up
986            } else if let Err(err_) = i.record_err(&token_start, &err_start, err) {
987                err = err_;
988            } else {
989                continue;
990            }
991        }
992
993        i.reset(&err_start);
994        err = err.map(|err| E::from_recoverable_error(&token_start, &err_start, i, err));
995        return Err(err);
996    }
997}
998
999/// Implementation of [`Parser::resume_after`]
1000#[cfg(feature = "unstable-recover")]
1001#[cfg(feature = "std")]
1002pub struct ResumeAfter<P, R, I, O, E>
1003where
1004    P: Parser<I, O, E>,
1005    R: Parser<I, (), E>,
1006    I: Stream,
1007    I: Recover<E>,
1008    E: FromRecoverableError<I, E>,
1009{
1010    parser: P,
1011    recover: R,
1012    i: core::marker::PhantomData<I>,
1013    o: core::marker::PhantomData<O>,
1014    e: core::marker::PhantomData<E>,
1015}
1016
1017#[cfg(feature = "unstable-recover")]
1018#[cfg(feature = "std")]
1019impl<P, R, I, O, E> ResumeAfter<P, R, I, O, E>
1020where
1021    P: Parser<I, O, E>,
1022    R: Parser<I, (), E>,
1023    I: Stream,
1024    I: Recover<E>,
1025    E: FromRecoverableError<I, E>,
1026{
1027    #[inline(always)]
1028    pub(crate) fn new(parser: P, recover: R) -> Self {
1029        Self {
1030            parser,
1031            recover,
1032            i: Default::default(),
1033            o: Default::default(),
1034            e: Default::default(),
1035        }
1036    }
1037}
1038
1039#[cfg(feature = "unstable-recover")]
1040#[cfg(feature = "std")]
1041impl<P, R, I, O, E> Parser<I, Option<O>, E> for ResumeAfter<P, R, I, O, E>
1042where
1043    P: Parser<I, O, E>,
1044    R: Parser<I, (), E>,
1045    I: Stream,
1046    I: Recover<E>,
1047    E: FromRecoverableError<I, E>,
1048{
1049    #[inline(always)]
1050    fn parse_next(&mut self, i: &mut I) -> PResult<Option<O>, E> {
1051        if I::is_recovery_supported() {
1052            resume_after_inner(&mut self.parser, &mut self.recover, i)
1053        } else {
1054            self.parser.parse_next(i).map(Some)
1055        }
1056    }
1057}
1058
1059#[cfg(feature = "unstable-recover")]
1060#[cfg(feature = "std")]
1061fn resume_after_inner<P, R, I, O, E>(
1062    parser: &mut P,
1063    recover: &mut R,
1064    i: &mut I,
1065) -> PResult<Option<O>, E>
1066where
1067    P: Parser<I, O, E>,
1068    R: Parser<I, (), E>,
1069    I: Stream,
1070    I: Recover<E>,
1071    E: FromRecoverableError<I, E>,
1072{
1073    let token_start = i.checkpoint();
1074    let mut err = match parser.parse_next(i) {
1075        Ok(o) => {
1076            return Ok(Some(o));
1077        }
1078        Err(ErrMode::Incomplete(e)) => return Err(ErrMode::Incomplete(e)),
1079        Err(err) => err,
1080    };
1081    let err_start = i.checkpoint();
1082    if recover.parse_next(i).is_ok() {
1083        if let Err(err_) = i.record_err(&token_start, &err_start, err) {
1084            err = err_;
1085        } else {
1086            return Ok(None);
1087        }
1088    }
1089
1090    i.reset(&err_start);
1091    err = err.map(|err| E::from_recoverable_error(&token_start, &err_start, i, err));
1092    Err(err)
1093}
winnow/combinator/parser.rs

winnow/combinator/
parser.rs
