1 //! Opaque implementations of [`Parser`]
2
3 use crate::combinator::trace;
4 use crate::combinator::trace_result;
5 use crate::combinator::DisplayDebug;
6 #[cfg(feature = "unstable-recover")]
7 #[cfg(feature = "std")]
8 use crate::error::FromRecoverableError;
9 use crate::error::{AddContext, ErrMode, ErrorKind, FromExternalError, ParserError};
10 use crate::lib::std::borrow::Borrow;
11 use crate::lib::std::ops::Range;
12 #[cfg(feature = "unstable-recover")]
13 #[cfg(feature = "std")]
14 use crate::stream::Recover;
15 use crate::stream::StreamIsPartial;
16 use crate::stream::{Location, Stream};
17 use crate::*;
18
19 /// [`Parser`] implementation for [`Parser::by_ref`]
20 pub struct ByRef<'p, P> {
21 pub(crate) p: &'p mut P,
22 }
23
24 impl<I, O, E, P> Parser<I, O, E> for ByRef<'_, P>
25 where
26 P: Parser<I, O, E>,
27 {
28 #[inline(always)]
parse_next(&mut self, i: &mut I) -> PResult<O, E>29 fn parse_next(&mut self, i: &mut I) -> PResult<O, E> {
30 self.p.parse_next(i)
31 }
32 }
33
34 /// [`Parser`] implementation for [`Parser::map`]
35 pub struct Map<F, G, I, O, O2, E>
36 where
37 F: Parser<I, O, E>,
38 G: FnMut(O) -> O2,
39 {
40 pub(crate) parser: F,
41 pub(crate) map: G,
42 pub(crate) i: core::marker::PhantomData<I>,
43 pub(crate) o: core::marker::PhantomData<O>,
44 pub(crate) o2: core::marker::PhantomData<O2>,
45 pub(crate) e: core::marker::PhantomData<E>,
46 }
47
48 impl<F, G, I, O, O2, E> Parser<I, O2, E> for Map<F, G, I, O, O2, E>
49 where
50 F: Parser<I, O, E>,
51 G: FnMut(O) -> O2,
52 {
53 #[inline]
parse_next(&mut self, i: &mut I) -> PResult<O2, E>54 fn parse_next(&mut self, i: &mut I) -> PResult<O2, E> {
55 match self.parser.parse_next(i) {
56 Err(e) => Err(e),
57 Ok(o) => Ok((self.map)(o)),
58 }
59 }
60 }
61
62 /// [`Parser`] implementation for [`Parser::try_map`]
63 pub struct TryMap<F, G, I, O, O2, E, E2>
64 where
65 F: Parser<I, O, E>,
66 G: FnMut(O) -> Result<O2, E2>,
67 I: Stream,
68 E: FromExternalError<I, E2>,
69 {
70 pub(crate) parser: F,
71 pub(crate) map: G,
72 pub(crate) i: core::marker::PhantomData<I>,
73 pub(crate) o: core::marker::PhantomData<O>,
74 pub(crate) o2: core::marker::PhantomData<O2>,
75 pub(crate) e: core::marker::PhantomData<E>,
76 pub(crate) e2: core::marker::PhantomData<E2>,
77 }
78
79 impl<F, G, I, O, O2, E, E2> Parser<I, O2, E> for TryMap<F, G, I, O, O2, E, E2>
80 where
81 F: Parser<I, O, E>,
82 G: FnMut(O) -> Result<O2, E2>,
83 I: Stream,
84 E: FromExternalError<I, E2>,
85 {
86 #[inline]
parse_next(&mut self, input: &mut I) -> PResult<O2, E>87 fn parse_next(&mut self, input: &mut I) -> PResult<O2, E> {
88 let start = input.checkpoint();
89 let o = self.parser.parse_next(input)?;
90 let res = (self.map)(o).map_err(|err| {
91 input.reset(&start);
92 ErrMode::from_external_error(input, ErrorKind::Verify, err)
93 });
94 trace_result("verify", &res);
95 res
96 }
97 }
98
99 /// [`Parser`] implementation for [`Parser::verify_map`]
100 pub struct VerifyMap<F, G, I, O, O2, E>
101 where
102 F: Parser<I, O, E>,
103 G: FnMut(O) -> Option<O2>,
104 I: Stream,
105 E: ParserError<I>,
106 {
107 pub(crate) parser: F,
108 pub(crate) map: G,
109 pub(crate) i: core::marker::PhantomData<I>,
110 pub(crate) o: core::marker::PhantomData<O>,
111 pub(crate) o2: core::marker::PhantomData<O2>,
112 pub(crate) e: core::marker::PhantomData<E>,
113 }
114
115 impl<F, G, I, O, O2, E> Parser<I, O2, E> for VerifyMap<F, G, I, O, O2, E>
116 where
117 F: Parser<I, O, E>,
118 G: FnMut(O) -> Option<O2>,
119 I: Stream,
120 E: ParserError<I>,
121 {
122 #[inline]
parse_next(&mut self, input: &mut I) -> PResult<O2, E>123 fn parse_next(&mut self, input: &mut I) -> PResult<O2, E> {
124 let start = input.checkpoint();
125 let o = self.parser.parse_next(input)?;
126 let res = (self.map)(o).ok_or_else(|| {
127 input.reset(&start);
128 ErrMode::from_error_kind(input, ErrorKind::Verify)
129 });
130 trace_result("verify", &res);
131 res
132 }
133 }
134
135 /// [`Parser`] implementation for [`Parser::and_then`]
136 pub struct AndThen<F, G, I, O, O2, E>
137 where
138 F: Parser<I, O, E>,
139 G: Parser<O, O2, E>,
140 O: StreamIsPartial,
141 I: Stream,
142 {
143 pub(crate) outer: F,
144 pub(crate) inner: G,
145 pub(crate) i: core::marker::PhantomData<I>,
146 pub(crate) o: core::marker::PhantomData<O>,
147 pub(crate) o2: core::marker::PhantomData<O2>,
148 pub(crate) e: core::marker::PhantomData<E>,
149 }
150
151 impl<F, G, I, O, O2, E> Parser<I, O2, E> for AndThen<F, G, I, O, O2, E>
152 where
153 F: Parser<I, O, E>,
154 G: Parser<O, O2, E>,
155 O: StreamIsPartial,
156 I: Stream,
157 {
158 #[inline(always)]
parse_next(&mut self, i: &mut I) -> PResult<O2, E>159 fn parse_next(&mut self, i: &mut I) -> PResult<O2, E> {
160 let start = i.checkpoint();
161 let mut o = self.outer.parse_next(i)?;
162 let _ = o.complete();
163 let o2 = self.inner.parse_next(&mut o).map_err(|err| {
164 i.reset(&start);
165 err
166 })?;
167 Ok(o2)
168 }
169 }
170
171 /// [`Parser`] implementation for [`Parser::parse_to`]
172 pub struct ParseTo<P, I, O, O2, E>
173 where
174 P: Parser<I, O, E>,
175 I: Stream,
176 O: crate::stream::ParseSlice<O2>,
177 E: ParserError<I>,
178 {
179 pub(crate) p: P,
180 pub(crate) i: core::marker::PhantomData<I>,
181 pub(crate) o: core::marker::PhantomData<O>,
182 pub(crate) o2: core::marker::PhantomData<O2>,
183 pub(crate) e: core::marker::PhantomData<E>,
184 }
185
186 impl<P, I, O, O2, E> Parser<I, O2, E> for ParseTo<P, I, O, O2, E>
187 where
188 P: Parser<I, O, E>,
189 I: Stream,
190 O: crate::stream::ParseSlice<O2>,
191 E: ParserError<I>,
192 {
193 #[inline]
parse_next(&mut self, i: &mut I) -> PResult<O2, E>194 fn parse_next(&mut self, i: &mut I) -> PResult<O2, E> {
195 let start = i.checkpoint();
196 let o = self.p.parse_next(i)?;
197 let res = o.parse_slice().ok_or_else(|| {
198 i.reset(&start);
199 ErrMode::from_error_kind(i, ErrorKind::Verify)
200 });
201 trace_result("verify", &res);
202 res
203 }
204 }
205
206 /// [`Parser`] implementation for [`Parser::flat_map`]
207 pub struct FlatMap<F, G, H, I, O, O2, E>
208 where
209 F: Parser<I, O, E>,
210 G: FnMut(O) -> H,
211 H: Parser<I, O2, E>,
212 {
213 pub(crate) f: F,
214 pub(crate) g: G,
215 pub(crate) h: core::marker::PhantomData<H>,
216 pub(crate) i: core::marker::PhantomData<I>,
217 pub(crate) o: core::marker::PhantomData<O>,
218 pub(crate) o2: core::marker::PhantomData<O2>,
219 pub(crate) e: core::marker::PhantomData<E>,
220 }
221
222 impl<F, G, H, I, O, O2, E> Parser<I, O2, E> for FlatMap<F, G, H, I, O, O2, E>
223 where
224 F: Parser<I, O, E>,
225 G: FnMut(O) -> H,
226 H: Parser<I, O2, E>,
227 {
228 #[inline(always)]
parse_next(&mut self, i: &mut I) -> PResult<O2, E>229 fn parse_next(&mut self, i: &mut I) -> PResult<O2, E> {
230 let o = self.f.parse_next(i)?;
231 (self.g)(o).parse_next(i)
232 }
233 }
234
235 /// [`Parser`] implementation for [`Parser::complete_err`]
236 pub struct CompleteErr<F> {
237 pub(crate) f: F,
238 }
239
240 impl<F, I, O, E> Parser<I, O, E> for CompleteErr<F>
241 where
242 I: Stream,
243 F: Parser<I, O, E>,
244 E: ParserError<I>,
245 {
246 #[inline]
parse_next(&mut self, input: &mut I) -> PResult<O, E>247 fn parse_next(&mut self, input: &mut I) -> PResult<O, E> {
248 trace("complete_err", |input: &mut I| {
249 match (self.f).parse_next(input) {
250 Err(ErrMode::Incomplete(_)) => {
251 Err(ErrMode::from_error_kind(input, ErrorKind::Complete))
252 }
253 rest => rest,
254 }
255 })
256 .parse_next(input)
257 }
258 }
259
260 /// [`Parser`] implementation for [`Parser::verify`]
261 pub struct Verify<F, G, I, O, O2, E>
262 where
263 F: Parser<I, O, E>,
264 G: FnMut(&O2) -> bool,
265 I: Stream,
266 O: Borrow<O2>,
267 O2: ?Sized,
268 E: ParserError<I>,
269 {
270 pub(crate) parser: F,
271 pub(crate) filter: G,
272 pub(crate) i: core::marker::PhantomData<I>,
273 pub(crate) o: core::marker::PhantomData<O>,
274 pub(crate) o2: core::marker::PhantomData<O2>,
275 pub(crate) e: core::marker::PhantomData<E>,
276 }
277
278 impl<F, G, I, O, O2, E> Parser<I, O, E> for Verify<F, G, I, O, O2, E>
279 where
280 F: Parser<I, O, E>,
281 G: FnMut(&O2) -> bool,
282 I: Stream,
283 O: Borrow<O2>,
284 O2: ?Sized,
285 E: ParserError<I>,
286 {
287 #[inline]
parse_next(&mut self, input: &mut I) -> PResult<O, E>288 fn parse_next(&mut self, input: &mut I) -> PResult<O, E> {
289 let start = input.checkpoint();
290 let o = self.parser.parse_next(input)?;
291 let res = (self.filter)(o.borrow()).then_some(o).ok_or_else(|| {
292 input.reset(&start);
293 ErrMode::from_error_kind(input, ErrorKind::Verify)
294 });
295 trace_result("verify", &res);
296 res
297 }
298 }
299
300 /// [`Parser`] implementation for [`Parser::value`]
301 pub struct Value<F, I, O, O2, E>
302 where
303 F: Parser<I, O, E>,
304 O2: Clone,
305 {
306 pub(crate) parser: F,
307 pub(crate) val: O2,
308 pub(crate) i: core::marker::PhantomData<I>,
309 pub(crate) o: core::marker::PhantomData<O>,
310 pub(crate) e: core::marker::PhantomData<E>,
311 }
312
313 impl<F, I, O, O2, E> Parser<I, O2, E> for Value<F, I, O, O2, E>
314 where
315 F: Parser<I, O, E>,
316 O2: Clone,
317 {
318 #[inline]
parse_next(&mut self, input: &mut I) -> PResult<O2, E>319 fn parse_next(&mut self, input: &mut I) -> PResult<O2, E> {
320 (self.parser).parse_next(input).map(|_| self.val.clone())
321 }
322 }
323
324 /// [`Parser`] implementation for [`Parser::default_value`]
325 pub struct DefaultValue<F, I, O, O2, E>
326 where
327 F: Parser<I, O, E>,
328 O2: core::default::Default,
329 {
330 pub(crate) parser: F,
331 pub(crate) o2: core::marker::PhantomData<O2>,
332 pub(crate) i: core::marker::PhantomData<I>,
333 pub(crate) o: core::marker::PhantomData<O>,
334 pub(crate) e: core::marker::PhantomData<E>,
335 }
336
337 impl<F, I, O, O2, E> Parser<I, O2, E> for DefaultValue<F, I, O, O2, E>
338 where
339 F: Parser<I, O, E>,
340 O2: core::default::Default,
341 {
342 #[inline]
parse_next(&mut self, input: &mut I) -> PResult<O2, E>343 fn parse_next(&mut self, input: &mut I) -> PResult<O2, E> {
344 (self.parser).parse_next(input).map(|_| O2::default())
345 }
346 }
347
348 /// [`Parser`] implementation for [`Parser::void`]
349 pub struct Void<F, I, O, E>
350 where
351 F: Parser<I, O, E>,
352 {
353 pub(crate) parser: F,
354 pub(crate) i: core::marker::PhantomData<I>,
355 pub(crate) o: core::marker::PhantomData<O>,
356 pub(crate) e: core::marker::PhantomData<E>,
357 }
358
359 impl<F, I, O, E> Parser<I, (), E> for Void<F, I, O, E>
360 where
361 F: Parser<I, O, E>,
362 {
363 #[inline(always)]
parse_next(&mut self, input: &mut I) -> PResult<(), E>364 fn parse_next(&mut self, input: &mut I) -> PResult<(), E> {
365 (self.parser).parse_next(input).map(|_| ())
366 }
367 }
368
369 /// Replaced with [`Take`]
370 #[deprecated(since = "0.6.14", note = "Replaced with `Take`")]
371 pub type Recognize<F, I, O, E> = Take<F, I, O, E>;
372
373 /// [`Parser`] implementation for [`Parser::take`]
374 pub struct Take<F, I, O, E>
375 where
376 F: Parser<I, O, E>,
377 I: Stream,
378 {
379 pub(crate) parser: F,
380 pub(crate) i: core::marker::PhantomData<I>,
381 pub(crate) o: core::marker::PhantomData<O>,
382 pub(crate) e: core::marker::PhantomData<E>,
383 }
384
385 impl<I, O, E, F> Parser<I, <I as Stream>::Slice, E> for Take<F, I, O, E>
386 where
387 F: Parser<I, O, E>,
388 I: Stream,
389 {
390 #[inline]
parse_next(&mut self, input: &mut I) -> PResult<<I as Stream>::Slice, E>391 fn parse_next(&mut self, input: &mut I) -> PResult<<I as Stream>::Slice, E> {
392 let checkpoint = input.checkpoint();
393 match (self.parser).parse_next(input) {
394 Ok(_) => {
395 let offset = input.offset_from(&checkpoint);
396 input.reset(&checkpoint);
397 let taken = input.next_slice(offset);
398 Ok(taken)
399 }
400 Err(e) => Err(e),
401 }
402 }
403 }
404
405 /// Replaced with [`WithTaken`]
406 #[deprecated(since = "0.6.14", note = "Replaced with `WithTaken`")]
407 pub type WithRecognized<F, I, O, E> = WithTaken<F, I, O, E>;
408
409 /// [`Parser`] implementation for [`Parser::with_taken`]
410 pub struct WithTaken<F, I, O, E>
411 where
412 F: Parser<I, O, E>,
413 I: Stream,
414 {
415 pub(crate) parser: F,
416 pub(crate) i: core::marker::PhantomData<I>,
417 pub(crate) o: core::marker::PhantomData<O>,
418 pub(crate) e: core::marker::PhantomData<E>,
419 }
420
421 impl<F, I, O, E> Parser<I, (O, <I as Stream>::Slice), E> for WithTaken<F, I, O, E>
422 where
423 F: Parser<I, O, E>,
424 I: Stream,
425 {
426 #[inline]
parse_next(&mut self, input: &mut I) -> PResult<(O, <I as Stream>::Slice), E>427 fn parse_next(&mut self, input: &mut I) -> PResult<(O, <I as Stream>::Slice), E> {
428 let checkpoint = input.checkpoint();
429 match (self.parser).parse_next(input) {
430 Ok(result) => {
431 let offset = input.offset_from(&checkpoint);
432 input.reset(&checkpoint);
433 let taken = input.next_slice(offset);
434 Ok((result, taken))
435 }
436 Err(e) => Err(e),
437 }
438 }
439 }
440
441 /// [`Parser`] implementation for [`Parser::span`]
442 pub struct Span<F, I, O, E>
443 where
444 F: Parser<I, O, E>,
445 I: Stream + Location,
446 {
447 pub(crate) parser: F,
448 pub(crate) i: core::marker::PhantomData<I>,
449 pub(crate) o: core::marker::PhantomData<O>,
450 pub(crate) e: core::marker::PhantomData<E>,
451 }
452
453 impl<I, O, E, F> Parser<I, Range<usize>, E> for Span<F, I, O, E>
454 where
455 F: Parser<I, O, E>,
456 I: Stream + Location,
457 {
458 #[inline]
parse_next(&mut self, input: &mut I) -> PResult<Range<usize>, E>459 fn parse_next(&mut self, input: &mut I) -> PResult<Range<usize>, E> {
460 let start = input.location();
461 self.parser.parse_next(input).map(move |_| {
462 let end = input.location();
463 start..end
464 })
465 }
466 }
467
468 /// [`Parser`] implementation for [`Parser::with_span`]
469 pub struct WithSpan<F, I, O, E>
470 where
471 F: Parser<I, O, E>,
472 I: Stream + Location,
473 {
474 pub(crate) parser: F,
475 pub(crate) i: core::marker::PhantomData<I>,
476 pub(crate) o: core::marker::PhantomData<O>,
477 pub(crate) e: core::marker::PhantomData<E>,
478 }
479
480 impl<F, I, O, E> Parser<I, (O, Range<usize>), E> for WithSpan<F, I, O, E>
481 where
482 F: Parser<I, O, E>,
483 I: Stream + Location,
484 {
485 #[inline]
parse_next(&mut self, input: &mut I) -> PResult<(O, Range<usize>), E>486 fn parse_next(&mut self, input: &mut I) -> PResult<(O, Range<usize>), E> {
487 let start = input.location();
488 self.parser.parse_next(input).map(move |output| {
489 let end = input.location();
490 (output, (start..end))
491 })
492 }
493 }
494
495 /// [`Parser`] implementation for [`Parser::output_into`]
496 pub struct OutputInto<F, I, O, O2, E>
497 where
498 F: Parser<I, O, E>,
499 O: Into<O2>,
500 {
501 pub(crate) parser: F,
502 pub(crate) i: core::marker::PhantomData<I>,
503 pub(crate) o: core::marker::PhantomData<O>,
504 pub(crate) o2: core::marker::PhantomData<O2>,
505 pub(crate) e: core::marker::PhantomData<E>,
506 }
507
508 impl<F, I, O, O2, E> Parser<I, O2, E> for OutputInto<F, I, O, O2, E>
509 where
510 F: Parser<I, O, E>,
511 O: Into<O2>,
512 {
513 #[inline]
parse_next(&mut self, i: &mut I) -> PResult<O2, E>514 fn parse_next(&mut self, i: &mut I) -> PResult<O2, E> {
515 self.parser.parse_next(i).map(|o| o.into())
516 }
517 }
518
519 /// [`Parser`] implementation for [`Parser::err_into`]
520 pub struct ErrInto<F, I, O, E, E2>
521 where
522 F: Parser<I, O, E>,
523 E: Into<E2>,
524 {
525 pub(crate) parser: F,
526 pub(crate) i: core::marker::PhantomData<I>,
527 pub(crate) o: core::marker::PhantomData<O>,
528 pub(crate) e: core::marker::PhantomData<E>,
529 pub(crate) e2: core::marker::PhantomData<E2>,
530 }
531
532 impl<F, I, O, E, E2> Parser<I, O, E2> for ErrInto<F, I, O, E, E2>
533 where
534 F: Parser<I, O, E>,
535 E: Into<E2>,
536 {
537 #[inline]
parse_next(&mut self, i: &mut I) -> PResult<O, E2>538 fn parse_next(&mut self, i: &mut I) -> PResult<O, E2> {
539 self.parser
540 .parse_next(i)
541 .map_err(|err| err.map(|e| e.into()))
542 }
543 }
544
545 /// [`Parser`] implementation for [`Parser::context`]
546 pub struct Context<F, I, O, E, C>
547 where
548 F: Parser<I, O, E>,
549 I: Stream,
550 E: AddContext<I, C>,
551 C: Clone + crate::lib::std::fmt::Debug,
552 {
553 pub(crate) parser: F,
554 pub(crate) context: C,
555 pub(crate) i: core::marker::PhantomData<I>,
556 pub(crate) o: core::marker::PhantomData<O>,
557 pub(crate) e: core::marker::PhantomData<E>,
558 }
559
560 impl<F, I, O, E, C> Parser<I, O, E> for Context<F, I, O, E, C>
561 where
562 F: Parser<I, O, E>,
563 I: Stream,
564 E: AddContext<I, C>,
565 C: Clone + crate::lib::std::fmt::Debug,
566 {
567 #[inline]
parse_next(&mut self, i: &mut I) -> PResult<O, E>568 fn parse_next(&mut self, i: &mut I) -> PResult<O, E> {
569 let context = self.context.clone();
570 trace(DisplayDebug(self.context.clone()), move |i: &mut I| {
571 let start = i.checkpoint();
572 (self.parser)
573 .parse_next(i)
574 .map_err(|err| err.add_context(i, &start, context.clone()))
575 })
576 .parse_next(i)
577 }
578 }
579
580 /// [`Parser`] implementation for [`Parser::retry_after`]
581 #[cfg(feature = "unstable-recover")]
582 #[cfg(feature = "std")]
583 pub struct RetryAfter<P, R, I, O, E>
584 where
585 P: Parser<I, O, E>,
586 R: Parser<I, (), E>,
587 I: Stream,
588 I: Recover<E>,
589 E: FromRecoverableError<I, E>,
590 {
591 pub(crate) parser: P,
592 pub(crate) recover: R,
593 pub(crate) i: core::marker::PhantomData<I>,
594 pub(crate) o: core::marker::PhantomData<O>,
595 pub(crate) e: core::marker::PhantomData<E>,
596 }
597
598 #[cfg(feature = "unstable-recover")]
599 #[cfg(feature = "std")]
600 impl<P, R, I, O, E> Parser<I, O, E> for RetryAfter<P, R, I, O, E>
601 where
602 P: Parser<I, O, E>,
603 R: Parser<I, (), E>,
604 I: Stream,
605 I: Recover<E>,
606 E: FromRecoverableError<I, E>,
607 {
608 #[inline(always)]
parse_next(&mut self, i: &mut I) -> PResult<O, E>609 fn parse_next(&mut self, i: &mut I) -> PResult<O, E> {
610 if I::is_recovery_supported() {
611 retry_after_inner(&mut self.parser, &mut self.recover, i)
612 } else {
613 self.parser.parse_next(i)
614 }
615 }
616 }
617
618 #[cfg(feature = "unstable-recover")]
619 #[cfg(feature = "std")]
retry_after_inner<P, R, I, O, E>(parser: &mut P, recover: &mut R, i: &mut I) -> PResult<O, E> where P: Parser<I, O, E>, R: Parser<I, (), E>, I: Stream, I: Recover<E>, E: FromRecoverableError<I, E>,620 fn retry_after_inner<P, R, I, O, E>(parser: &mut P, recover: &mut R, i: &mut I) -> PResult<O, E>
621 where
622 P: Parser<I, O, E>,
623 R: Parser<I, (), E>,
624 I: Stream,
625 I: Recover<E>,
626 E: FromRecoverableError<I, E>,
627 {
628 loop {
629 let token_start = i.checkpoint();
630 let mut err = match parser.parse_next(i) {
631 Ok(o) => {
632 return Ok(o);
633 }
634 Err(ErrMode::Incomplete(e)) => return Err(ErrMode::Incomplete(e)),
635 Err(err) => err,
636 };
637 let err_start = i.checkpoint();
638 let err_start_eof_offset = i.eof_offset();
639 if recover.parse_next(i).is_ok() {
640 let i_eof_offset = i.eof_offset();
641 if err_start_eof_offset == i_eof_offset {
642 // Didn't advance so bubble the error up
643 } else if let Err(err_) = i.record_err(&token_start, &err_start, err) {
644 err = err_;
645 } else {
646 continue;
647 }
648 }
649
650 i.reset(&err_start);
651 err = err.map(|err| E::from_recoverable_error(&token_start, &err_start, i, err));
652 return Err(err);
653 }
654 }
655
656 /// [`Parser`] implementation for [`Parser::resume_after`]
657 #[cfg(feature = "unstable-recover")]
658 #[cfg(feature = "std")]
659 pub struct ResumeAfter<P, R, I, O, E>
660 where
661 P: Parser<I, O, E>,
662 R: Parser<I, (), E>,
663 I: Stream,
664 I: Recover<E>,
665 E: FromRecoverableError<I, E>,
666 {
667 pub(crate) parser: P,
668 pub(crate) recover: R,
669 pub(crate) i: core::marker::PhantomData<I>,
670 pub(crate) o: core::marker::PhantomData<O>,
671 pub(crate) e: core::marker::PhantomData<E>,
672 }
673
674 #[cfg(feature = "unstable-recover")]
675 #[cfg(feature = "std")]
676 impl<P, R, I, O, E> Parser<I, Option<O>, E> for ResumeAfter<P, R, I, O, E>
677 where
678 P: Parser<I, O, E>,
679 R: Parser<I, (), E>,
680 I: Stream,
681 I: Recover<E>,
682 E: FromRecoverableError<I, E>,
683 {
684 #[inline(always)]
parse_next(&mut self, i: &mut I) -> PResult<Option<O>, E>685 fn parse_next(&mut self, i: &mut I) -> PResult<Option<O>, E> {
686 if I::is_recovery_supported() {
687 resume_after_inner(&mut self.parser, &mut self.recover, i)
688 } else {
689 self.parser.parse_next(i).map(Some)
690 }
691 }
692 }
693
694 #[cfg(feature = "unstable-recover")]
695 #[cfg(feature = "std")]
resume_after_inner<P, R, I, O, E>( parser: &mut P, recover: &mut R, i: &mut I, ) -> PResult<Option<O>, E> where P: Parser<I, O, E>, R: Parser<I, (), E>, I: Stream, I: Recover<E>, E: FromRecoverableError<I, E>,696 fn resume_after_inner<P, R, I, O, E>(
697 parser: &mut P,
698 recover: &mut R,
699 i: &mut I,
700 ) -> PResult<Option<O>, E>
701 where
702 P: Parser<I, O, E>,
703 R: Parser<I, (), E>,
704 I: Stream,
705 I: Recover<E>,
706 E: FromRecoverableError<I, E>,
707 {
708 let token_start = i.checkpoint();
709 let mut err = match parser.parse_next(i) {
710 Ok(o) => {
711 return Ok(Some(o));
712 }
713 Err(ErrMode::Incomplete(e)) => return Err(ErrMode::Incomplete(e)),
714 Err(err) => err,
715 };
716 let err_start = i.checkpoint();
717 if recover.parse_next(i).is_ok() {
718 if let Err(err_) = i.record_err(&token_start, &err_start, err) {
719 err = err_;
720 } else {
721 return Ok(None);
722 }
723 }
724
725 i.reset(&err_start);
726 err = err.map(|err| E::from_recoverable_error(&token_start, &err_start, i, err));
727 Err(err)
728 }
729