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