Debian Codegraph @

.cargo/vendor/nom/src/multi/mod.rs

raw
1 //! Combinators applying their child parser multiple times
2
3 #[cfg(test)]
4 mod tests;
5
6 use core::marker::PhantomData;
7
8 use crate::bytes::take;
9 use crate::error::ErrorKind;
10 use crate::error::ParseError;
11 use crate::internal::{Err, Needed, Parser};
12 use crate::lib::std::num::NonZeroUsize;
13 #[cfg(feature = "alloc")]
14 use crate::lib::std::vec::Vec;
15 use crate::traits::ToUsize;
16 use crate::Check;
17 use crate::Emit;
18 use crate::Input;
19 use crate::Mode;
20 use crate::NomRange;
21 use crate::OutputM;
22 use crate::OutputMode;
23
24 /// Don't pre-allocate more than 64KiB when calling `Vec::with_capacity`.
25 ///
26 /// Pre-allocating memory is a nice optimization but count fields can't
27 /// always be trusted. We should clamp initial capacities to some reasonable
28 /// amount. This reduces the risk of a bogus count value triggering a panic
29 /// due to an OOM error.
30 ///
31 /// This does not affect correctness. Nom will always read the full number
32 /// of elements regardless of the capacity cap.
33 #[cfg(feature = "alloc")]
34 const MAX_INITIAL_CAPACITY_BYTES: usize = 65536;
35
36 /// Repeats the embedded parser, gathering the results in a `Vec`.
37 ///
38 /// This stops on [`Err::Error`] and returns the results that were accumulated. To instead chain an error up, see
39 /// [`cut`][crate::combinator::cut].
40 ///
41 /// # Arguments
42 /// * `f` The parser to apply.
43 ///
44 /// *Note*: if the parser passed in accepts empty inputs (like `alpha0` or `digit0`), `many0` will
45 /// return an error, to prevent going into an infinite loop
46 ///
47 /// ```rust
48 /// # use nom::{Err, error::ErrorKind, Needed, IResult, Parser};
49 /// use nom::multi::many0;
50 /// use nom::bytes::complete::tag;
51 ///
52 /// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
53 /// many0(tag("abc")).parse(s)
54 /// }
55 ///
56 /// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
57 /// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));
58 /// assert_eq!(parser("123123"), Ok(("123123", vec![])));
59 /// assert_eq!(parser(""), Ok(("", vec![])));
60 /// ```
61 #[cfg(feature = "alloc")]
62 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
63 pub fn many0<I, F>(
64 f: F,
65 ) -> impl Parser<I, Output = Vec<<F as Parser<I>>::Output>, Error = <F as Parser<I>>::Error>
66 where
67 I: Clone + Input,
68 F: Parser<I>,
69 {
70 Many0 { parser: f }
71 }
72
73 #[cfg(feature = "alloc")]
74 /// Parser implementation for the [many0] combinator
75 pub struct Many0<F> {
76 parser: F,
77 }
78
79 #[cfg(feature = "alloc")]
80 impl<I, F> Parser<I> for Many0<F>
81 where
82 I: Clone + Input,
83 F: Parser<I>,
84 {
85 type Output = crate::lib::std::vec::Vec<<F as Parser<I>>::Output>;
86 type Error = <F as Parser<I>>::Error;
87
88 fn process<OM: OutputMode>(
89 &mut self,
90 mut i: I,
91 ) -> crate::PResult<OM, I, Self::Output, Self::Error> {
92 let mut acc = OM::Output::bind(|| crate::lib::std::vec::Vec::with_capacity(4));
93 loop {
94 let len = i.input_len();
95 match self
96 .parser
97 .process::<OutputM<OM::Output, Check, OM::Incomplete>>(i.clone())
98 {
99 Err(Err::Error(_)) => return Ok((i, acc)),
100 Err(Err::Failure(e)) => return Err(Err::Failure(e)),
101 Err(Err::Incomplete(e)) => return Err(Err::Incomplete(e)),
102 Ok((i1, o)) => {
103 // infinite loop check: the parser must always consume
104 if i1.input_len() == len {
105 return Err(Err::Error(OM::Error::bind(|| {
106 <F as Parser<I>>::Error::from_error_kind(i, ErrorKind::Many0)
107 })));
108 }
109
110 i = i1;
111
112 acc = OM::Output::combine(acc, o, |mut acc, o| {
113 acc.push(o);
114 acc
115 })
116 }
117 }
118 }
119 }
120 }
121
122 /// Runs the embedded parser, gathering the results in a `Vec`.
123 ///
124 /// This stops on [`Err::Error`] if there is at least one result, and returns the results that were accumulated. To instead chain an error up,
125 /// see [`cut`][crate::combinator::cut].
126 ///
127 /// # Arguments
128 /// * `f` The parser to apply.
129 ///
130 /// *Note*: If the parser passed to `many1` accepts empty inputs
131 /// (like `alpha0` or `digit0`), `many1` will return an error,
132 /// to prevent going into an infinite loop.
133 ///
134 /// ```rust
135 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult, Parser};
136 /// use nom::multi::many1;
137 /// use nom::bytes::complete::tag;
138 ///
139 /// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
140 /// many1(tag("abc")).parse(s)
141 /// }
142 ///
143 /// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
144 /// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));
145 /// assert_eq!(parser("123123"), Err(Err::Error(Error::new("123123", ErrorKind::Tag))));
146 /// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Tag))));
147 /// ```
148 #[cfg(feature = "alloc")]
149 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
150 pub fn many1<I, F>(
151 parser: F,
152 ) -> impl Parser<I, Output = Vec<<F as Parser<I>>::Output>, Error = <F as Parser<I>>::Error>
153 where
154 I: Clone + Input,
155 F: Parser<I>,
156 {
157 Many1 { parser }
158 }
159
160 #[cfg(feature = "alloc")]
161 /// Parser implementation for the [many1] combinator
162 pub struct Many1<F> {
163 parser: F,
164 }
165
166 #[cfg(feature = "alloc")]
167 impl<I, F> Parser<I> for Many1<F>
168 where
169 I: Clone + Input,
170 F: Parser<I>,
171 {
172 type Output = Vec<<F as Parser<I>>::Output>;
173 type Error = <F as Parser<I>>::Error;
174
175 fn process<OM: OutputMode>(
176 &mut self,
177 mut i: I,
178 ) -> crate::PResult<OM, I, Self::Output, Self::Error> {
179 match self
180 .parser
181 .process::<OutputM<OM::Output, Emit, OM::Incomplete>>(i.clone())
182 {
183 Err(Err::Error(err)) => Err(Err::Error(OM::Error::bind(|| {
184 <F as Parser<I>>::Error::append(i, ErrorKind::Many1, err)
185 }))),
186 Err(Err::Failure(e)) => Err(Err::Failure(e)),
187 Err(Err::Incomplete(i)) => Err(Err::Incomplete(i)),
188 Ok((i1, o)) => {
189 let mut acc = OM::Output::map(o, |o| {
190 let mut acc = crate::lib::std::vec::Vec::with_capacity(4);
191 acc.push(o);
192 acc
193 });
194
195 i = i1;
196
197 loop {
198 let len = i.input_len();
199 match self
200 .parser
201 .process::<OutputM<OM::Output, Check, OM::Incomplete>>(i.clone())
202 {
203 Err(Err::Error(_)) => return Ok((i, acc)),
204 Err(Err::Failure(e)) => return Err(Err::Failure(e)),
205 Err(Err::Incomplete(e)) => return Err(Err::Incomplete(e)),
206 Ok((i1, o)) => {
207 // infinite loop check: the parser must always consume
208 if i1.input_len() == len {
209 return Err(Err::Error(OM::Error::bind(|| {
210 <F as Parser<I>>::Error::from_error_kind(i, ErrorKind::Many0)
211 })));
212 }
213
214 i = i1;
215
216 acc = OM::Output::combine(acc, o, |mut acc, o| {
217 acc.push(o);
218 acc
219 })
220 }
221 }
222 }
223 }
224 }
225 }
226 }
227
228 /// Applies the parser `f` until the parser `g` produces a result.
229 ///
230 /// Returns a tuple of the results of `f` in a `Vec` and the result of `g`.
231 ///
232 /// `f` keeps going so long as `g` produces [`Err::Error`]. To instead chain an error up, see [`cut`][crate::combinator::cut].
233 ///
234 /// ```rust
235 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult, Parser};
236 /// use nom::multi::many_till;
237 /// use nom::bytes::complete::tag;
238 ///
239 /// fn parser(s: &str) -> IResult<&str, (Vec<&str>, &str)> {
240 /// many_till(tag("abc"), tag("end")).parse(s)
241 /// };
242 ///
243 /// assert_eq!(parser("abcabcend"), Ok(("", (vec!["abc", "abc"], "end"))));
244 /// assert_eq!(parser("abc123end"), Err(Err::Error(Error::new("123end", ErrorKind::Tag))));
245 /// assert_eq!(parser("123123end"), Err(Err::Error(Error::new("123123end", ErrorKind::Tag))));
246 /// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Tag))));
247 /// assert_eq!(parser("abcendefg"), Ok(("efg", (vec!["abc"], "end"))));
248 /// ```
249 #[cfg(feature = "alloc")]
250 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
251 pub fn many_till<I, E, F, G>(
252 f: F,
253 g: G,
254 ) -> impl Parser<I, Output = (Vec<<F as Parser<I>>::Output>, <G as Parser<I>>::Output), Error = E>
255 where
256 I: Clone + Input,
257 F: Parser<I, Error = E>,
258 G: Parser<I, Error = E>,
259 E: ParseError<I>,
260 {
261 ManyTill {
262 f,
263 g,
264 e: PhantomData,
265 }
266 }
267
268 #[cfg(feature = "alloc")]
269 /// Parser implementation for the [many_till] combinator
270 pub struct ManyTill<F, G, E> {
271 f: F,
272 g: G,
273 e: PhantomData<E>,
274 }
275
276 #[cfg(feature = "alloc")]
277 impl<I, F, G, E> Parser<I> for ManyTill<F, G, E>
278 where
279 I: Clone + Input,
280 F: Parser<I, Error = E>,
281 G: Parser<I, Error = E>,
282 E: ParseError<I>,
283 {
284 type Output = (Vec<<F as Parser<I>>::Output>, <G as Parser<I>>::Output);
285 type Error = E;
286
287 fn process<OM: OutputMode>(
288 &mut self,
289 mut i: I,
290 ) -> crate::PResult<OM, I, Self::Output, Self::Error> {
291 let mut res = OM::Output::bind(crate::lib::std::vec::Vec::new);
292 loop {
293 let len = i.input_len();
294 match self
295 .g
296 .process::<OutputM<OM::Output, Check, OM::Incomplete>>(i.clone())
297 {
298 Ok((i1, o)) => return Ok((i1, OM::Output::combine(res, o, |res, o| (res, o)))),
299 Err(Err::Failure(e)) => return Err(Err::Failure(e)),
300 Err(Err::Incomplete(i)) => return Err(Err::Incomplete(i)),
301 Err(Err::Error(_)) => {
302 match self.f.process::<OM>(i.clone()) {
303 Err(Err::Error(err)) => {
304 return Err(Err::Error(OM::Error::map(err, |err| {
305 E::append(i, ErrorKind::ManyTill, err)
306 })))
307 }
308 Err(Err::Failure(e)) => return Err(Err::Failure(e)),
309 Err(Err::Incomplete(e)) => return Err(Err::Incomplete(e)),
310 Ok((i1, o)) => {
311 // infinite loop check: the parser must always consume
312 if i1.input_len() == len {
313 return Err(Err::Error(OM::Error::bind(|| {
314 E::from_error_kind(i, ErrorKind::Many0)
315 })));
316 }
317
318 i = i1;
319
320 res = OM::Output::combine(res, o, |mut acc, o| {
321 acc.push(o);
322 acc
323 })
324 }
325 }
326 }
327 }
328 }
329 }
330 }
331
332 /// Alternates between two parsers to produce a list of elements.
333 ///
334 /// This stops when either parser returns [`Err::Error`] and returns the results that were accumulated. To instead chain an error up, see
335 /// [`cut`][crate::combinator::cut].
336 ///
337 /// # Arguments
338 /// * `sep` Parses the separator between list elements.
339 /// * `f` Parses the elements of the list.
340 ///
341 /// ```rust
342 /// # use nom::{Err, error::ErrorKind, Needed, IResult, Parser};
343 /// use nom::multi::separated_list0;
344 /// use nom::bytes::complete::tag;
345 ///
346 /// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
347 /// separated_list0(tag("|"), tag("abc")).parse(s)
348 /// }
349 ///
350 /// assert_eq!(parser("abc|abc|abc"), Ok(("", vec!["abc", "abc", "abc"])));
351 /// assert_eq!(parser("abc123abc"), Ok(("123abc", vec!["abc"])));
352 /// assert_eq!(parser("abc|def"), Ok(("|def", vec!["abc"])));
353 /// assert_eq!(parser(""), Ok(("", vec![])));
354 /// assert_eq!(parser("def|abc"), Ok(("def|abc", vec![])));
355 /// ```
356 #[cfg(feature = "alloc")]
357 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
358 pub fn separated_list0<I, E, F, G>(
359 sep: G,
360 f: F,
361 ) -> impl Parser<I, Output = Vec<<F as Parser<I>>::Output>, Error = E>
362 where
363 I: Clone + Input,
364 F: Parser<I, Error = E>,
365 G: Parser<I, Error = E>,
366 E: ParseError<I>,
367 {
368 SeparatedList0 {
369 parser: f,
370 separator: sep,
371 }
372 }
373
374 #[cfg(feature = "alloc")]
375 /// Parser implementation for the [separated_list0] combinator
376 pub struct SeparatedList0<F, G> {
377 parser: F,
378 separator: G,
379 }
380
381 #[cfg(feature = "alloc")]
382 impl<I, E: ParseError<I>, F, G> Parser<I> for SeparatedList0<F, G>
383 where
384 I: Clone + Input,
385 F: Parser<I, Error = E>,
386 G: Parser<I, Error = E>,
387 {
388 type Output = Vec<<F as Parser<I>>::Output>;
389 type Error = <F as Parser<I>>::Error;
390
391 fn process<OM: OutputMode>(
392 &mut self,
393 mut i: I,
394 ) -> crate::PResult<OM, I, Self::Output, Self::Error> {
395 let mut res = OM::Output::bind(crate::lib::std::vec::Vec::new);
396
397 match self
398 .parser
399 .process::<OutputM<OM::Output, Check, OM::Incomplete>>(i.clone())
400 {
401 Err(Err::Error(_)) => return Ok((i, res)),
402 Err(Err::Failure(e)) => return Err(Err::Failure(e)),
403 Err(Err::Incomplete(e)) => return Err(Err::Incomplete(e)),
404 Ok((i1, o)) => {
405 res = OM::Output::combine(res, o, |mut res, o| {
406 res.push(o);
407 res
408 });
409 i = i1;
410 }
411 }
412
413 loop {
414 let len = i.input_len();
415 match self
416 .separator
417 .process::<OutputM<Check, Check, OM::Incomplete>>(i.clone())
418 {
419 Err(Err::Error(_)) => return Ok((i, res)),
420 Err(Err::Failure(e)) => return Err(Err::Failure(e)),
421 Err(Err::Incomplete(e)) => return Err(Err::Incomplete(e)),
422 Ok((i1, _)) => {
423 match self
424 .parser
425 .process::<OutputM<OM::Output, Check, OM::Incomplete>>(i1.clone())
426 {
427 Err(Err::Error(_)) => return Ok((i, res)),
428 Err(Err::Failure(e)) => return Err(Err::Failure(e)),
429 Err(Err::Incomplete(e)) => return Err(Err::Incomplete(e)),
430 Ok((i2, o)) => {
431 // infinite loop check: the parser must always consume
432 if i2.input_len() == len {
433 return Err(Err::Error(OM::Error::bind(|| {
434 <F as Parser<I>>::Error::from_error_kind(i, ErrorKind::SeparatedList)
435 })));
436 }
437
438 res = OM::Output::combine(res, o, |mut res, o| {
439 res.push(o);
440 res
441 });
442
443 i = i2;
444 }
445 }
446 }
447 }
448 }
449 }
450 }
451
452 /// Alternates between two parsers to produce a list of elements until [`Err::Error`].
453 ///
454 /// Fails if the element parser does not produce at least one element.
455 ///
456 /// This stops when either parser returns [`Err::Error`] and returns the results that were accumulated. To instead chain an error up, see
457 /// [`cut`][crate::combinator::cut].
458 ///
459 /// # Arguments
460 /// * `sep` Parses the separator between list elements.
461 /// * `f` Parses the elements of the list.
462 /// ```rust
463 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult, Parser};
464 /// use nom::multi::separated_list1;
465 /// use nom::bytes::complete::tag;
466 ///
467 /// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
468 /// separated_list1(tag("|"), tag("abc")).parse(s)
469 /// }
470 ///
471 /// assert_eq!(parser("abc|abc|abc"), Ok(("", vec!["abc", "abc", "abc"])));
472 /// assert_eq!(parser("abc123abc"), Ok(("123abc", vec!["abc"])));
473 /// assert_eq!(parser("abc|def"), Ok(("|def", vec!["abc"])));
474 /// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Tag))));
475 /// assert_eq!(parser("def|abc"), Err(Err::Error(Error::new("def|abc", ErrorKind::Tag))));
476 /// ```
477 #[cfg(feature = "alloc")]
478 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
479 pub fn separated_list1<I, E, F, G>(
480 separator: G,
481 parser: F,
482 ) -> impl Parser<I, Output = Vec<<F as Parser<I>>::Output>, Error = E>
483 where
484 I: Clone + Input,
485 F: Parser<I, Error = E>,
486 G: Parser<I, Error = E>,
487 E: ParseError<I>,
488 {
489 SeparatedList1 { parser, separator }
490 }
491
492 #[cfg(feature = "alloc")]
493 /// Parser implementation for the [separated_list1] combinator
494 pub struct SeparatedList1<F, G> {
495 parser: F,
496 separator: G,
497 }
498
499 #[cfg(feature = "alloc")]
500 impl<I, E: ParseError<I>, F, G> Parser<I> for SeparatedList1<F, G>
501 where
502 I: Clone + Input,
503 F: Parser<I, Error = E>,
504 G: Parser<I, Error = E>,
505 {
506 type Output = Vec<<F as Parser<I>>::Output>;
507 type Error = <F as Parser<I>>::Error;
508
509 fn process<OM: OutputMode>(
510 &mut self,
511 mut i: I,
512 ) -> crate::PResult<OM, I, Self::Output, Self::Error> {
513 let mut res = OM::Output::bind(crate::lib::std::vec::Vec::new);
514
515 match self.parser.process::<OM>(i.clone()) {
516 Err(e) => return Err(e),
517 Ok((i1, o)) => {
518 res = OM::Output::combine(res, o, |mut res, o| {
519 res.push(o);
520 res
521 });
522 i = i1;
523 }
524 }
525
526 loop {
527 let len = i.input_len();
528 match self
529 .separator
530 .process::<OutputM<Check, Check, OM::Incomplete>>(i.clone())
531 {
532 Err(Err::Error(_)) => return Ok((i, res)),
533 Err(Err::Failure(e)) => return Err(Err::Failure(e)),
534 Err(Err::Incomplete(e)) => return Err(Err::Incomplete(e)),
535 Ok((i1, _)) => {
536 match self
537 .parser
538 .process::<OutputM<OM::Output, Check, OM::Incomplete>>(i1.clone())
539 {
540 Err(Err::Error(_)) => return Ok((i, res)),
541 Err(Err::Failure(e)) => return Err(Err::Failure(e)),
542 Err(Err::Incomplete(e)) => return Err(Err::Incomplete(e)),
543 Ok((i2, o)) => {
544 // infinite loop check: the parser must always consume
545 if i2.input_len() == len {
546 return Err(Err::Error(OM::Error::bind(|| {
547 <F as Parser<I>>::Error::from_error_kind(i, ErrorKind::SeparatedList)
548 })));
549 }
550
551 res = OM::Output::combine(res, o, |mut res, o| {
552 res.push(o);
553 res
554 });
555 i = i2;
556 }
557 }
558 }
559 }
560 }
561 }
562 }
563
564 /// Repeats the embedded parser `m..=n` times
565 ///
566 /// This stops before `n` when the parser returns [`Err::Error`] and returns the results that were accumulated. To instead chain an error up, see
567 /// [`cut`][crate::combinator::cut].
568 ///
569 /// # Arguments
570 /// * `m` The minimum number of iterations.
571 /// * `n` The maximum number of iterations.
572 /// * `f` The parser to apply.
573 ///
574 /// *Note*: If the parser passed to `many1` accepts empty inputs
575 /// (like `alpha0` or `digit0`), `many1` will return an error,
576 /// to prevent going into an infinite loop.
577 ///
578 /// ```rust
579 /// # use nom::{Err, error::ErrorKind, Needed, IResult, Parser};
580 /// use nom::multi::many_m_n;
581 /// use nom::bytes::complete::tag;
582 ///
583 /// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
584 /// many_m_n(0, 2, tag("abc")).parse(s)
585 /// }
586 ///
587 /// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
588 /// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));
589 /// assert_eq!(parser("123123"), Ok(("123123", vec![])));
590 /// assert_eq!(parser(""), Ok(("", vec![])));
591 /// assert_eq!(parser("abcabcabc"), Ok(("abc", vec!["abc", "abc"])));
592 /// ```
593 #[cfg(feature = "alloc")]
594 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
595 pub fn many_m_n<I, E, F>(
596 min: usize,
597 max: usize,
598 parser: F,
599 ) -> impl Parser<I, Output = Vec<<F as Parser<I>>::Output>, Error = E>
600 where
601 I: Clone + Input,
602 F: Parser<I, Error = E>,
603 E: ParseError<I>,
604 {
605 ManyMN { parser, min, max }
606 }
607
608 #[cfg(feature = "alloc")]
609 /// Parser implementation for the [many_m_n] combinator
610 pub struct ManyMN<F> {
611 parser: F,
612 min: usize,
613 max: usize,
614 }
615
616 #[cfg(feature = "alloc")]
617 impl<I, F> Parser<I> for ManyMN<F>
618 where
619 I: Clone + Input,
620 F: Parser<I>,
621 {
622 type Output = Vec<<F as Parser<I>>::Output>;
623 type Error = <F as Parser<I>>::Error;
624
625 fn process<OM: OutputMode>(
626 &mut self,
627 mut input: I,
628 ) -> crate::PResult<OM, I, Self::Output, Self::Error> {
629 if self.min > self.max {
630 return Err(Err::Failure(<F as Parser<I>>::Error::from_error_kind(
631 input,
632 ErrorKind::ManyMN,
633 )));
634 }
635
636 let max_initial_capacity = MAX_INITIAL_CAPACITY_BYTES
637 / crate::lib::std::mem::size_of::<<F as Parser<I>>::Output>().max(1);
638 let mut res = OM::Output::bind(|| {
639 crate::lib::std::vec::Vec::with_capacity(self.min.min(max_initial_capacity))
640 });
641 for count in 0..self.max {
642 let len = input.input_len();
643 match self.parser.process::<OM>(input.clone()) {
644 Ok((tail, value)) => {
645 // infinite loop check: the parser must always consume
646 if tail.input_len() == len {
647 return Err(Err::Error(OM::Error::bind(|| {
648 <F as Parser<I>>::Error::from_error_kind(input, ErrorKind::ManyMN)
649 })));
650 }
651
652 res = OM::Output::combine(res, value, |mut res, value| {
653 res.push(value);
654 res
655 });
656 input = tail;
657 }
658 Err(Err::Error(e)) => {
659 if count < self.min {
660 return Err(Err::Error(OM::Error::map(e, |e| {
661 <F as Parser<I>>::Error::append(input, ErrorKind::ManyMN, e)
662 })));
663 } else {
664 return Ok((input, res));
665 }
666 }
667 Err(e) => {
668 return Err(e);
669 }
670 }
671 }
672
673 Ok((input, res))
674 }
675 }
676
677 /// Repeats the embedded parser, counting the results
678 ///
679 /// This stops on [`Err::Error`]. To instead chain an error up, see
680 /// [`cut`][crate::combinator::cut].
681 ///
682 /// # Arguments
683 /// * `f` The parser to apply.
684 ///
685 /// *Note*: if the parser passed in accepts empty inputs (like `alpha0` or `digit0`), `many0` will
686 /// return an error, to prevent going into an infinite loop
687 ///
688 /// ```rust
689 /// # use nom::{Err, error::ErrorKind, Needed, IResult, Parser};
690 /// use nom::multi::many0_count;
691 /// use nom::bytes::complete::tag;
692 ///
693 /// fn parser(s: &str) -> IResult<&str, usize> {
694 /// many0_count(tag("abc")).parse(s)
695 /// }
696 ///
697 /// assert_eq!(parser("abcabc"), Ok(("", 2)));
698 /// assert_eq!(parser("abc123"), Ok(("123", 1)));
699 /// assert_eq!(parser("123123"), Ok(("123123", 0)));
700 /// assert_eq!(parser(""), Ok(("", 0)));
701 /// ```
702 pub fn many0_count<I, E, F>(parser: F) -> impl Parser<I, Output = usize, Error = E>
703 where
704 I: Clone + Input,
705 F: Parser<I, Error = E>,
706 E: ParseError<I>,
707 {
708 Many0Count { parser }
709 }
710
711 /// Parser implementation for the [many0_count] combinator
712 pub struct Many0Count<F> {
713 parser: F,
714 }
715
716 impl<I, F> Parser<I> for Many0Count<F>
717 where
718 I: Clone + Input,
719 F: Parser<I>,
720 {
721 type Output = usize;
722 type Error = <F as Parser<I>>::Error;
723
724 fn process<OM: OutputMode>(
725 &mut self,
726 mut input: I,
727 ) -> crate::PResult<OM, I, Self::Output, Self::Error> {
728 let mut count = 0;
729
730 loop {
731 let input_ = input.clone();
732 let len = input.input_len();
733 match self
734 .parser
735 .process::<OutputM<Check, Check, OM::Incomplete>>(input_)
736 {
737 Ok((i, _)) => {
738 // infinite loop check: the parser must always consume
739 if i.input_len() == len {
740 return Err(Err::Error(OM::Error::bind(|| {
741 <F as Parser<I>>::Error::from_error_kind(input, ErrorKind::Many0Count)
742 })));
743 }
744
745 input = i;
746 count += 1;
747 }
748
749 Err(Err::Error(_)) => return Ok((input, OM::Output::bind(|| count))),
750 Err(Err::Failure(e)) => return Err(Err::Failure(e)),
751 Err(Err::Incomplete(i)) => return Err(Err::Incomplete(i)),
752 }
753 }
754 }
755 }
756
757 /// Runs the embedded parser, counting the results.
758 ///
759 /// This stops on [`Err::Error`] if there is at least one result. To instead chain an error up,
760 /// see [`cut`][crate::combinator::cut].
761 ///
762 /// # Arguments
763 /// * `f` The parser to apply.
764 ///
765 /// *Note*: If the parser passed to `many1` accepts empty inputs
766 /// (like `alpha0` or `digit0`), `many1` will return an error,
767 /// to prevent going into an infinite loop.
768 ///
769 /// ```rust
770 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult, Parser};
771 /// use nom::multi::many1_count;
772 /// use nom::bytes::complete::tag;
773 ///
774 /// fn parser(s: &str) -> IResult<&str, usize> {
775 /// many1_count(tag("abc")).parse(s)
776 /// }
777 ///
778 /// assert_eq!(parser("abcabc"), Ok(("", 2)));
779 /// assert_eq!(parser("abc123"), Ok(("123", 1)));
780 /// assert_eq!(parser("123123"), Err(Err::Error(Error::new("123123", ErrorKind::Many1Count))));
781 /// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Many1Count))));
782 /// ```
783 pub fn many1_count<I, E, F>(parser: F) -> impl Parser<I, Output = usize, Error = E>
784 where
785 I: Clone + Input,
786 F: Parser<I, Error = E>,
787 E: ParseError<I>,
788 {
789 Many1Count { parser }
790 }
791
792 /// Parser implementation for the [many1_count] combinator
793 pub struct Many1Count<F> {
794 parser: F,
795 }
796
797 impl<I, F> Parser<I> for Many1Count<F>
798 where
799 I: Clone + Input,
800 F: Parser<I>,
801 {
802 type Output = usize;
803 type Error = <F as Parser<I>>::Error;
804
805 fn process<OM: OutputMode>(
806 &mut self,
807 input: I,
808 ) -> crate::PResult<OM, I, Self::Output, Self::Error> {
809 let mut count = 0;
810
811 match self
812 .parser
813 .process::<OutputM<Check, Check, OM::Incomplete>>(input.clone())
814 {
815 Err(Err::Error(_)) => Err(Err::Error(OM::Error::bind(move || {
816 <F as Parser<I>>::Error::from_error_kind(input, ErrorKind::Many1Count)
817 }))),
818 Err(Err::Failure(e)) => Err(Err::Failure(e)),
819 Err(Err::Incomplete(i)) => Err(Err::Incomplete(i)),
820 Ok((mut input, _)) => {
821 count += 1;
822
823 loop {
824 let input_ = input.clone();
825 let len = input.input_len();
826 match self
827 .parser
828 .process::<OutputM<Check, Check, OM::Incomplete>>(input_)
829 {
830 Ok((i, _)) => {
831 // infinite loop check: the parser must always consume
832 if i.input_len() == len {
833 return Err(Err::Error(OM::Error::bind(|| {
834 <F as Parser<I>>::Error::from_error_kind(input, ErrorKind::Many1Count)
835 })));
836 }
837
838 input = i;
839 count += 1;
840 }
841
842 Err(Err::Error(_)) => return Ok((input, OM::Output::bind(|| count))),
843 Err(Err::Failure(e)) => return Err(Err::Failure(e)),
844 Err(Err::Incomplete(i)) => return Err(Err::Incomplete(i)),
845 }
846 }
847 }
848 }
849 }
850 }
851
852 /// Runs the embedded parser `count` times, gathering the results in a `Vec`
853 ///
854 /// # Arguments
855 /// * `f` The parser to apply.
856 /// * `count` How often to apply the parser.
857 /// ```rust
858 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult, Parser};
859 /// use nom::multi::count;
860 /// use nom::bytes::complete::tag;
861 ///
862 /// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
863 /// count(tag("abc"), 2).parse(s)
864 /// }
865 ///
866 /// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
867 /// assert_eq!(parser("abc123"), Err(Err::Error(Error::new("123", ErrorKind::Tag))));
868 /// assert_eq!(parser("123123"), Err(Err::Error(Error::new("123123", ErrorKind::Tag))));
869 /// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Tag))));
870 /// assert_eq!(parser("abcabcabc"), Ok(("abc", vec!["abc", "abc"])));
871 /// ```
872 #[cfg(feature = "alloc")]
873 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
874 pub fn count<I, F>(
875 parser: F,
876 count: usize,
877 ) -> impl Parser<I, Output = Vec<<F as Parser<I>>::Output>, Error = <F as Parser<I>>::Error>
878 where
879 I: Clone,
880 F: Parser<I>,
881 {
882 Count { parser, count }
883 }
884
885 #[cfg(feature = "alloc")]
886 /// Parser implementation for the [count] combinator
887 pub struct Count<F> {
888 parser: F,
889 count: usize,
890 }
891
892 #[cfg(feature = "alloc")]
893 impl<I, F> Parser<I> for Count<F>
894 where
895 I: Clone,
896 F: Parser<I>,
897 {
898 type Output = Vec<<F as Parser<I>>::Output>;
899 type Error = <F as Parser<I>>::Error;
900
901 fn process<OM: OutputMode>(&mut self, i: I) -> crate::PResult<OM, I, Self::Output, Self::Error> {
902 let mut input = i.clone();
903 let max_initial_capacity = MAX_INITIAL_CAPACITY_BYTES
904 / crate::lib::std::mem::size_of::<<F as Parser<I>>::Output>().max(1);
905 let mut res = OM::Output::bind(|| {
906 crate::lib::std::vec::Vec::with_capacity(self.count.min(max_initial_capacity))
907 });
908
909 for _ in 0..self.count {
910 let input_ = input.clone();
911 match self.parser.process::<OM>(input_) {
912 Ok((i, o)) => {
913 res = OM::Output::combine(res, o, |mut res, o| {
914 res.push(o);
915 res
916 });
917 input = i;
918 }
919 Err(Err::Error(e)) => {
920 return Err(Err::Error(OM::Error::map(e, |e| {
921 <F as Parser<I>>::Error::append(i, ErrorKind::Count, e)
922 })));
923 }
924 Err(e) => {
925 return Err(e);
926 }
927 }
928 }
929
930 Ok((input, res))
931 }
932 }
933
934 /// Runs the embedded parser repeatedly, filling the given slice with results.
935 ///
936 /// This parser fails if the input runs out before the given slice is full.
937 ///
938 /// # Arguments
939 /// * `f` The parser to apply.
940 /// * `buf` The slice to fill
941 /// ```rust
942 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult, Parser};
943 /// use nom::multi::fill;
944 /// use nom::bytes::complete::tag;
945 ///
946 /// fn parser(s: &str) -> IResult<&str, [&str; 2]> {
947 /// let mut buf = ["", ""];
948 /// let (rest, ()) = fill(tag("abc"), &mut buf).parse(s)?;
949 /// Ok((rest, buf))
950 /// }
951 ///
952 /// assert_eq!(parser("abcabc"), Ok(("", ["abc", "abc"])));
953 /// assert_eq!(parser("abc123"), Err(Err::Error(Error::new("123", ErrorKind::Tag))));
954 /// assert_eq!(parser("123123"), Err(Err::Error(Error::new("123123", ErrorKind::Tag))));
955 /// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Tag))));
956 /// assert_eq!(parser("abcabcabc"), Ok(("abc", ["abc", "abc"])));
957 /// ```
958 pub fn fill<'a, I, E, F>(
959 parser: F,
960 buf: &'a mut [<F as Parser<I>>::Output],
961 ) -> impl Parser<I, Output = (), Error = E> + 'a
962 where
963 I: Clone,
964 F: Parser<I, Error = E> + 'a,
965 E: ParseError<I>,
966 {
967 Fill { parser, buf }
968 }
969
970 /// Parser implementation for the [fill] combinator
971 pub struct Fill<'a, F, O> {
972 parser: F,
973 buf: &'a mut [O],
974 }
975
976 impl<'a, I, F, O> Parser<I> for Fill<'a, F, O>
977 where
978 I: Clone,
979 F: Parser<I, Output = O>,
980 {
981 type Output = ();
982 type Error = <F as Parser<I>>::Error;
983
984 fn process<OM: OutputMode>(&mut self, i: I) -> crate::PResult<OM, I, Self::Output, Self::Error> {
985 let mut input = i.clone();
986
987 for elem in self.buf.iter_mut() {
988 let input_ = input.clone();
989 match self.parser.process::<OM>(input_) {
990 Ok((i, o)) => {
991 OM::Output::map(o, |o| *elem = o);
992 input = i;
993 }
994 Err(Err::Error(e)) => {
995 return Err(Err::Error(OM::Error::map(e, |e| {
996 <F as Parser<I>>::Error::append(i, ErrorKind::Count, e)
997 })));
998 }
999 Err(e) => {
1000 return Err(e);
1001 }
1002 }
1003 }
1004
1005 Ok((input, OM::Output::bind(|| ())))
1006 }
1007 }
1008
1009 /// Repeats the embedded parser, calling `g` to gather the results.
1010 ///
1011 /// This stops on [`Err::Error`]. To instead chain an error up, see
1012 /// [`cut`][crate::combinator::cut].
1013 ///
1014 /// # Arguments
1015 /// * `f` The parser to apply.
1016 /// * `init` A function returning the initial value.
1017 /// * `g` The function that combines a result of `f` with
1018 /// the current accumulator.
1019 ///
1020 /// *Note*: if the parser passed in accepts empty inputs (like `alpha0` or `digit0`), `many0` will
1021 /// return an error, to prevent going into an infinite loop
1022 ///
1023 /// ```rust
1024 /// # use nom::{Err, error::ErrorKind, Needed, IResult, Parser};
1025 /// use nom::multi::fold_many0;
1026 /// use nom::bytes::complete::tag;
1027 ///
1028 /// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
1029 /// fold_many0(
1030 /// tag("abc"),
1031 /// Vec::new,
1032 /// |mut acc: Vec<_>, item| {
1033 /// acc.push(item);
1034 /// acc
1035 /// }
1036 /// ).parse(s)
1037 /// }
1038 ///
1039 /// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
1040 /// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));
1041 /// assert_eq!(parser("123123"), Ok(("123123", vec![])));
1042 /// assert_eq!(parser(""), Ok(("", vec![])));
1043 /// ```
1044 pub fn fold_many0<I, E, F, G, H, R>(
1045 parser: F,
1046 init: H,
1047 g: G,
1048 ) -> impl Parser<I, Output = R, Error = E>
1049 where
1050 I: Clone + Input,
1051 F: Parser<I, Error = E>,
1052 G: FnMut(R, <F as Parser<I>>::Output) -> R,
1053 H: FnMut() -> R,
1054 E: ParseError<I>,
1055 {
1056 FoldMany0 {
1057 parser,
1058 g,
1059 init,
1060 r: PhantomData,
1061 }
1062 }
1063
1064 /// Parser implementation for the [fold_many0] combinator
1065 pub struct FoldMany0<F, G, Init, R> {
1066 parser: F,
1067 g: G,
1068 init: Init,
1069 r: PhantomData<R>,
1070 }
1071
1072 impl<I, F, G, Init, R> Parser<I> for FoldMany0<F, G, Init, R>
1073 where
1074 I: Clone + Input,
1075 F: Parser<I>,
1076 G: FnMut(R, <F as Parser<I>>::Output) -> R,
1077 Init: FnMut() -> R,
1078 {
1079 type Output = R;
1080 type Error = <F as Parser<I>>::Error;
1081
1082 fn process<OM: OutputMode>(&mut self, i: I) -> crate::PResult<OM, I, Self::Output, Self::Error> {
1083 let mut res = OM::Output::bind(|| (self.init)());
1084 let mut input = i;
1085
1086 loop {
1087 let i_ = input.clone();
1088 let len = input.input_len();
1089 match self.parser.process::<OM>(i_) {
1090 Ok((i, o)) => {
1091 // infinite loop check: the parser must always consume
1092 if i.input_len() == len {
1093 return Err(Err::Error(OM::Error::bind(|| {
1094 <F as Parser<I>>::Error::from_error_kind(input, ErrorKind::Many0)
1095 })));
1096 }
1097
1098 res = OM::Output::combine(res, o, |res, o| (self.g)(res, o));
1099 input = i;
1100 }
1101 Err(Err::Error(_)) => {
1102 return Ok((input, res));
1103 }
1104 Err(e) => {
1105 return Err(e);
1106 }
1107 }
1108 }
1109 }
1110 }
1111
1112 /// Repeats the embedded parser, calling `g` to gather the results.
1113 ///
1114 /// This stops on [`Err::Error`] if there is at least one result. To instead chain an error up,
1115 /// see [`cut`][crate::combinator::cut].
1116 ///
1117 /// # Arguments
1118 /// * `f` The parser to apply.
1119 /// * `init` A function returning the initial value.
1120 /// * `g` The function that combines a result of `f` with
1121 /// the current accumulator.
1122 ///
1123 /// *Note*: If the parser passed to `many1` accepts empty inputs
1124 /// (like `alpha0` or `digit0`), `many1` will return an error,
1125 /// to prevent going into an infinite loop.
1126 ///
1127 /// ```rust
1128 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult, Parser};
1129 /// use nom::multi::fold_many1;
1130 /// use nom::bytes::complete::tag;
1131 ///
1132 /// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
1133 /// fold_many1(
1134 /// tag("abc"),
1135 /// Vec::new,
1136 /// |mut acc: Vec<_>, item| {
1137 /// acc.push(item);
1138 /// acc
1139 /// }
1140 /// ).parse(s)
1141 /// }
1142 ///
1143 /// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
1144 /// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));
1145 /// assert_eq!(parser("123123"), Err(Err::Error(Error::new("123123", ErrorKind::Many1))));
1146 /// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Many1))));
1147 /// ```
1148 pub fn fold_many1<I, E, F, G, H, R>(
1149 parser: F,
1150 init: H,
1151 g: G,
1152 ) -> impl Parser<I, Output = R, Error = E>
1153 where
1154 I: Clone + Input,
1155 F: Parser<I, Error = E>,
1156 G: FnMut(R, <F as Parser<I>>::Output) -> R,
1157 H: FnMut() -> R,
1158 E: ParseError<I>,
1159 {
1160 FoldMany1 {
1161 parser,
1162 g,
1163 init,
1164 r: PhantomData,
1165 }
1166 }
1167
1168 /// Parser implementation for the [fold_many1] combinator
1169 pub struct FoldMany1<F, G, Init, R> {
1170 parser: F,
1171 g: G,
1172 init: Init,
1173 r: PhantomData<R>,
1174 }
1175
1176 impl<I, F, G, Init, R> Parser<I> for FoldMany1<F, G, Init, R>
1177 where
1178 I: Clone + Input,
1179 F: Parser<I>,
1180 G: FnMut(R, <F as Parser<I>>::Output) -> R,
1181 Init: FnMut() -> R,
1182 {
1183 type Output = R;
1184 type Error = <F as Parser<I>>::Error;
1185
1186 fn process<OM: OutputMode>(&mut self, i: I) -> crate::PResult<OM, I, Self::Output, Self::Error> {
1187 let mut res = OM::Output::bind(|| (self.init)());
1188 let input = i.clone();
1189
1190 match self.parser.process::<OM>(input) {
1191 Err(Err::Error(_)) => Err(Err::Error(OM::Error::bind(|| {
1192 <F as Parser<I>>::Error::from_error_kind(i, ErrorKind::Many1)
1193 }))),
1194 Err(e) => Err(e),
1195 Ok((i1, o1)) => {
1196 res = OM::Output::combine(res, o1, |res, o| (self.g)(res, o));
1197
1198 let mut input = i1;
1199 loop {
1200 let i_ = input.clone();
1201 let len = input.input_len();
1202 match self.parser.process::<OM>(i_) {
1203 Ok((i, o)) => {
1204 // infinite loop check: the parser must always consume
1205 if i.input_len() == len {
1206 return Err(Err::Error(OM::Error::bind(|| {
1207 <F as Parser<I>>::Error::from_error_kind(input, ErrorKind::Many1)
1208 })));
1209 }
1210
1211 res = OM::Output::combine(res, o, |res, o| (self.g)(res, o));
1212 input = i;
1213 }
1214 Err(Err::Error(_)) => {
1215 return Ok((input, res));
1216 }
1217 Err(e) => {
1218 return Err(e);
1219 }
1220 }
1221 }
1222 }
1223 }
1224 }
1225 }
1226
1227 /// Repeats the embedded parser `m..=n` times, calling `g` to gather the results
1228 ///
1229 /// This stops before `n` when the parser returns [`Err::Error`]. To instead chain an error up, see
1230 /// [`cut`][crate::combinator::cut].
1231 ///
1232 /// # Arguments
1233 /// * `m` The minimum number of iterations.
1234 /// * `n` The maximum number of iterations.
1235 /// * `f` The parser to apply.
1236 /// * `init` A function returning the initial value.
1237 /// * `g` The function that combines a result of `f` with
1238 /// the current accumulator.
1239 ///
1240 /// *Note*: If the parser passed to `many1` accepts empty inputs
1241 /// (like `alpha0` or `digit0`), `many1` will return an error,
1242 /// to prevent going into an infinite loop.
1243 ///
1244 /// ```rust
1245 /// # use nom::{Err, error::ErrorKind, Needed, IResult, Parser};
1246 /// use nom::multi::fold_many_m_n;
1247 /// use nom::bytes::complete::tag;
1248 ///
1249 /// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
1250 /// fold_many_m_n(
1251 /// 0,
1252 /// 2,
1253 /// tag("abc"),
1254 /// Vec::new,
1255 /// |mut acc: Vec<_>, item| {
1256 /// acc.push(item);
1257 /// acc
1258 /// }
1259 /// ).parse(s)
1260 /// }
1261 ///
1262 /// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
1263 /// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));
1264 /// assert_eq!(parser("123123"), Ok(("123123", vec![])));
1265 /// assert_eq!(parser(""), Ok(("", vec![])));
1266 /// assert_eq!(parser("abcabcabc"), Ok(("abc", vec!["abc", "abc"])));
1267 /// ```
1268 pub fn fold_many_m_n<I, E, F, G, H, R>(
1269 min: usize,
1270 max: usize,
1271 parser: F,
1272 init: H,
1273 g: G,
1274 ) -> impl Parser<I, Output = R, Error = E>
1275 where
1276 I: Clone + Input,
1277 F: Parser<I, Error = E>,
1278 G: FnMut(R, <F as Parser<I>>::Output) -> R,
1279 H: FnMut() -> R,
1280 E: ParseError<I>,
1281 {
1282 FoldManyMN {
1283 parser,
1284 g,
1285 init,
1286 min,
1287 max,
1288 r: PhantomData,
1289 }
1290 }
1291
1292 /// Parser implementation for the [fold_many_m_n] combinator
1293 pub struct FoldManyMN<F, G, Init, R> {
1294 parser: F,
1295 g: G,
1296 init: Init,
1297 r: PhantomData<R>,
1298 min: usize,
1299 max: usize,
1300 }
1301
1302 impl<I, F, G, Init, R> Parser<I> for FoldManyMN<F, G, Init, R>
1303 where
1304 I: Clone + Input,
1305 F: Parser<I>,
1306 G: FnMut(R, <F as Parser<I>>::Output) -> R,
1307 Init: FnMut() -> R,
1308 {
1309 type Output = R;
1310 type Error = <F as Parser<I>>::Error;
1311
1312 fn process<OM: OutputMode>(
1313 &mut self,
1314 mut input: I,
1315 ) -> crate::PResult<OM, I, Self::Output, Self::Error> {
1316 if self.min > self.max {
1317 return Err(Err::Error(OM::Error::bind(|| {
1318 <F as Parser<I>>::Error::from_error_kind(input, ErrorKind::ManyMN)
1319 })));
1320 }
1321
1322 let mut res = OM::Output::bind(|| (self.init)());
1323 for count in 0..self.max {
1324 let len = input.input_len();
1325 match self.parser.process::<OM>(input.clone()) {
1326 Ok((tail, value)) => {
1327 // infinite loop check: the parser must always consume
1328 if tail.input_len() == len {
1329 return Err(Err::Error(OM::Error::bind(|| {
1330 <F as Parser<I>>::Error::from_error_kind(tail, ErrorKind::ManyMN)
1331 })));
1332 }
1333
1334 res = OM::Output::combine(res, value, |res, o| (self.g)(res, o));
1335 input = tail;
1336 }
1337 Err(Err::Error(err)) => {
1338 if count < self.min {
1339 return Err(Err::Error(OM::Error::map(err, |err| {
1340 <F as Parser<I>>::Error::append(input, ErrorKind::ManyMN, err)
1341 })));
1342 } else {
1343 break;
1344 }
1345 }
1346 Err(e) => return Err(e),
1347 }
1348 }
1349
1350 Ok((input, res))
1351 }
1352 }
1353
1354 /// Gets a number from the parser and returns a
1355 /// subslice of the input of that size.
1356 /// If the parser returns `Incomplete`,
1357 /// `length_data` will return an error.
1358 /// # Arguments
1359 /// * `f` The parser to apply.
1360 /// ```rust
1361 /// # use nom::{Err, error::ErrorKind, Needed, IResult, Parser};
1362 /// use nom::number::complete::be_u16;
1363 /// use nom::multi::length_data;
1364 /// use nom::bytes::complete::tag;
1365 ///
1366 /// fn parser(s: &[u8]) -> IResult<&[u8], &[u8]> {
1367 /// length_data(be_u16).parse(s)
1368 /// }
1369 ///
1370 /// assert_eq!(parser(b"\x00\x03abcefg"), Ok((&b"efg"[..], &b"abc"[..])));
1371 /// assert_eq!(parser(b"\x00\x03a"), Err(Err::Incomplete(Needed::new(2))));
1372 /// ```
1373 pub fn length_data<I, E, F>(f: F) -> impl Parser<I, Output = I, Error = E>
1374 where
1375 I: Input,
1376 <F as Parser<I>>::Output: ToUsize,
1377 F: Parser<I, Error = E>,
1378 E: ParseError<I>,
1379 {
1380 f.flat_map(|size| take(size))
1381 }
1382
1383 /// Gets a number from the first parser,
1384 /// takes a subslice of the input of that size,
1385 /// then applies the second parser on that subslice.
1386 /// If the second parser returns `Incomplete`,
1387 /// `length_value` will return an error.
1388 /// # Arguments
1389 /// * `f` The parser to apply.
1390 /// * `g` The parser to apply on the subslice.
1391 /// ```rust
1392 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult, Parser};
1393 /// use nom::number::complete::be_u16;
1394 /// use nom::multi::length_value;
1395 /// use nom::bytes::complete::tag;
1396 ///
1397 /// fn parser(s: &[u8]) -> IResult<&[u8], &[u8]> {
1398 /// length_value(be_u16, tag("abc")).parse(s)
1399 /// }
1400 ///
1401 /// assert_eq!(parser(b"\x00\x03abcefg"), Ok((&b"efg"[..], &b"abc"[..])));
1402 /// assert_eq!(parser(b"\x00\x03123123"), Err(Err::Error(Error::new(&b"123"[..], ErrorKind::Tag))));
1403 /// assert_eq!(parser(b"\x00\x03a"), Err(Err::Incomplete(Needed::new(2))));
1404 /// ```
1405 pub fn length_value<I, E, F, G>(
1406 f: F,
1407 g: G,
1408 ) -> impl Parser<I, Output = <G as Parser<I>>::Output, Error = E>
1409 where
1410 I: Clone + Input,
1411 <F as Parser<I>>::Output: ToUsize,
1412 F: Parser<I, Error = E>,
1413 G: Parser<I, Error = E>,
1414 E: ParseError<I>,
1415 {
1416 /*f.flat_map(|size| {
1417 println!("got size: {size}");
1418 take(size)
1419 })
1420 .and_then(g)*/
1421 LengthValue {
1422 length: f,
1423 parser: g,
1424 e: PhantomData,
1425 }
1426 }
1427
1428 /// Parser implementation for the [length_value] combinator
1429 pub struct LengthValue<F, G, E> {
1430 length: F,
1431 parser: G,
1432 e: PhantomData<E>,
1433 }
1434
1435 impl<I, F, G, E> Parser<I> for LengthValue<F, G, E>
1436 where
1437 I: Clone + Input,
1438 F: Parser<I, Error = E>,
1439 G: Parser<I, Error = E>,
1440 <F as Parser<I>>::Output: ToUsize,
1441 E: ParseError<I>,
1442 {
1443 type Output = <G as Parser<I>>::Output;
1444 type Error = E;
1445
1446 fn process<OM: OutputMode>(
1447 &mut self,
1448 input: I,
1449 ) -> crate::PResult<OM, I, Self::Output, Self::Error> {
1450 let (i, length) = self
1451 .length
1452 .process::<OutputM<Emit, OM::Error, OM::Incomplete>>(input)?;
1453
1454 let length: usize = length.to_usize();
1455
1456 if let Some(needed) = length
1457 .checked_sub(i.input_len())
1458 .and_then(NonZeroUsize::new)
1459 {
1460 Err(Err::Incomplete(Needed::Size(needed)))
1461 } else {
1462 let (rest, i) = i.take_split(length);
1463 match self.parser.process::<OM>(i.clone()) {
1464 Err(Err::Incomplete(_)) => Err(Err::Error(OM::Error::bind(|| {
1465 E::from_error_kind(i, ErrorKind::Complete)
1466 }))),
1467 Err(e) => Err(e),
1468 Ok((_, o)) => Ok((rest, o)),
1469 }
1470 }
1471 }
1472 }
1473
1474 /// Gets a number from the first parser,
1475 /// then applies the second parser that many times.
1476 /// # Arguments
1477 /// * `f` The parser to apply to obtain the count.
1478 /// * `g` The parser to apply repeatedly.
1479 /// ```rust
1480 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult, Parser};
1481 /// use nom::number::complete::u8;
1482 /// use nom::multi::length_count;
1483 /// use nom::bytes::complete::tag;
1484 /// use nom::combinator::map;
1485 ///
1486 /// fn parser(s: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
1487 /// length_count(map(u8, |i| {
1488 /// println!("got number: {}", i);
1489 /// i
1490 /// }), tag("abc")).parse(s)
1491 /// }
1492 ///
1493 /// assert_eq!(parser(&b"\x02abcabcabc"[..]), Ok(((&b"abc"[..], vec![&b"abc"[..], &b"abc"[..]]))));
1494 /// assert_eq!(parser(b"\x03123123123"), Err(Err::Error(Error::new(&b"123123123"[..], ErrorKind::Tag))));
1495 /// ```
1496 #[cfg(feature = "alloc")]
1497 pub fn length_count<I, E, F, G>(
1498 f: F,
1499 g: G,
1500 ) -> impl Parser<I, Output = Vec<<G as Parser<I>>::Output>, Error = E>
1501 where
1502 I: Clone,
1503 <F as Parser<I>>::Output: ToUsize,
1504 F: Parser<I, Error = E>,
1505 G: Parser<I, Error = E>,
1506 E: ParseError<I>,
1507 {
1508 LengthCount {
1509 length: f,
1510 parser: g,
1511 e: PhantomData,
1512 }
1513 }
1514
1515 #[cfg(feature = "alloc")]
1516 /// Parser implementation for the [length_count] combinator
1517 pub struct LengthCount<F, G, E> {
1518 length: F,
1519 parser: G,
1520 e: PhantomData<E>,
1521 }
1522
1523 #[cfg(feature = "alloc")]
1524 impl<I, F, G, E> Parser<I> for LengthCount<F, G, E>
1525 where
1526 I: Clone,
1527 F: Parser<I, Error = E>,
1528 G: Parser<I, Error = E>,
1529 <F as Parser<I>>::Output: ToUsize,
1530 E: ParseError<I>,
1531 {
1532 type Output = Vec<<G as Parser<I>>::Output>;
1533 type Error = E;
1534
1535 fn process<OM: OutputMode>(
1536 &mut self,
1537 input: I,
1538 ) -> crate::PResult<OM, I, Self::Output, Self::Error> {
1539 match self
1540 .length
1541 .process::<OutputM<Emit, OM::Error, OM::Incomplete>>(input)
1542 {
1543 Err(e) => Err(e),
1544 Ok((i, count)) => {
1545 let count = count.to_usize();
1546 let mut input = i.clone();
1547 let max_initial_capacity = MAX_INITIAL_CAPACITY_BYTES
1548 / crate::lib::std::mem::size_of::<<F as Parser<I>>::Output>().max(1);
1549 let mut res = OM::Output::bind(|| {
1550 crate::lib::std::vec::Vec::with_capacity(count.min(max_initial_capacity))
1551 });
1552
1553 for _ in 0..count {
1554 let input_ = input.clone();
1555 match self.parser.process::<OM>(input_) {
1556 Ok((i, o)) => {
1557 res = OM::Output::combine(res, o, |mut res, o| {
1558 res.push(o);
1559 res
1560 });
1561 input = i;
1562 }
1563 Err(Err::Error(e)) => {
1564 return Err(Err::Error(OM::Error::map(e, |e| {
1565 <F as Parser<I>>::Error::append(i, ErrorKind::Count, e)
1566 })));
1567 }
1568 Err(e) => {
1569 return Err(e);
1570 }
1571 }
1572 }
1573
1574 Ok((input, res))
1575 }
1576 }
1577 }
1578 }
1579
1580 /// Repeats the embedded parser and collects the results in a type implementing `Extend + Default`.
1581 /// Fails if the amount of time the embedded parser is run is not
1582 /// within the specified range.
1583 /// # Arguments
1584 /// * `range` Constrains the number of iterations.
1585 /// * A range without an upper bound `a..` is equivalent to a range of `a..=usize::MAX`.
1586 /// * A single `usize` value is equivalent to `value..=value`.
1587 /// * An empty range is invalid.
1588 /// * `parse` The parser to apply.
1589 ///
1590 /// ```rust
1591 /// # #[macro_use] extern crate nom;
1592 /// # use nom::{Err, error::ErrorKind, Needed, IResult, Parser};
1593 /// use nom::multi::many;
1594 /// use nom::bytes::complete::tag;
1595 ///
1596 /// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
1597 /// many(0..=2, tag("abc")).parse(s)
1598 /// }
1599 ///
1600 /// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
1601 /// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));
1602 /// assert_eq!(parser("123123"), Ok(("123123", vec![])));
1603 /// assert_eq!(parser(""), Ok(("", vec![])));
1604 /// assert_eq!(parser("abcabcabc"), Ok(("abc", vec!["abc", "abc"])));
1605 /// ```
1606 ///
1607 /// This is not limited to `Vec`, other collections like `HashMap`
1608 /// can be used:
1609 ///
1610 /// ```rust
1611 /// # #[macro_use] extern crate nom;
1612 /// # use nom::{Err, error::ErrorKind, Needed, IResult, Parser};
1613 /// use nom::multi::many;
1614 /// use nom::bytes::complete::{tag, take_while};
1615 /// use nom::sequence::{separated_pair, terminated};
1616 /// use nom::AsChar;
1617 ///
1618 /// use std::collections::HashMap;
1619 ///
1620 /// fn key_value(s: &str) -> IResult<&str, HashMap<&str, &str>> {
1621 /// many(0.., terminated(
1622 /// separated_pair(
1623 /// take_while(AsChar::is_alpha),
1624 /// tag("="),
1625 /// take_while(AsChar::is_alpha)
1626 /// ),
1627 /// tag(";")
1628 /// )).parse(s)
1629 /// }
1630 ///
1631 /// assert_eq!(
1632 /// key_value("a=b;c=d;"),
1633 /// Ok(("", HashMap::from([("a", "b"), ("c", "d")])))
1634 /// );
1635 /// ```
1636 ///
1637 /// If more control is needed on the default value, [fold] can
1638 /// be used instead:
1639 ///
1640 /// ```rust
1641 /// # #[macro_use] extern crate nom;
1642 /// # use nom::{Err, error::ErrorKind, Needed, IResult, Parser};
1643 /// use nom::multi::fold;
1644 /// use nom::bytes::complete::tag;
1645 ///
1646 ///
1647 /// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
1648 /// fold(
1649 /// 0..=4,
1650 /// tag("abc"),
1651 /// // preallocates a vector of the max size
1652 /// || Vec::with_capacity(4),
1653 /// |mut acc: Vec<_>, item| {
1654 /// acc.push(item);
1655 /// acc
1656 /// }
1657 /// ).parse(s)
1658 /// }
1659 ///
1660 ///
1661 /// assert_eq!(parser("abcabcabcabc"), Ok(("", vec!["abc", "abc", "abc", "abc"])));
1662 /// ```
1663 #[cfg(feature = "alloc")]
1664 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
1665 pub fn many<I, E, Collection, F, G>(
1666 range: G,
1667 parser: F,
1668 ) -> impl Parser<I, Output = Collection, Error = E>
1669 where
1670 I: Clone + Input,
1671 F: Parser<I, Error = E>,
1672 Collection: Extend<<F as Parser<I>>::Output> + Default,
1673 E: ParseError<I>,
1674 G: NomRange<usize>,
1675 {
1676 Many {
1677 parser,
1678 range,
1679 c: PhantomData,
1680 }
1681 }
1682
1683 /// Parser implementation for the [many] combinator
1684 pub struct Many<F, R, Collection> {
1685 parser: F,
1686 range: R,
1687 c: PhantomData<Collection>,
1688 }
1689
1690 impl<I, F, R, Collection> Parser<I> for Many<F, R, Collection>
1691 where
1692 I: Clone + Input,
1693 F: Parser<I>,
1694 Collection: Extend<<F as Parser<I>>::Output> + Default,
1695 R: NomRange<usize>,
1696 {
1697 type Output = Collection;
1698 type Error = <F as Parser<I>>::Error;
1699
1700 fn process<OM: OutputMode>(
1701 &mut self,
1702 mut input: I,
1703 ) -> crate::PResult<OM, I, Self::Output, Self::Error> {
1704 if self.range.is_inverted() {
1705 return Err(Err::Failure(<F as Parser<I>>::Error::from_error_kind(
1706 input,
1707 ErrorKind::Many,
1708 )));
1709 }
1710
1711 let mut res = OM::Output::bind(Collection::default);
1712
1713 for count in self.range.bounded_iter() {
1714 let len = input.input_len();
1715 match self.parser.process::<OM>(input.clone()) {
1716 Ok((tail, value)) => {
1717 // infinite loop check: the parser must always consume
1718 if tail.input_len() == len {
1719 return Err(Err::Error(OM::Error::bind(|| {
1720 <F as Parser<I>>::Error::from_error_kind(input, ErrorKind::Many)
1721 })));
1722 }
1723
1724 res = OM::Output::combine(res, value, |mut res, value| {
1725 res.extend(Some(value));
1726 res
1727 });
1728 input = tail;
1729 }
1730 Err(Err::Error(e)) => {
1731 if !self.range.contains(&count) {
1732 return Err(Err::Error(OM::Error::map(e, |e| {
1733 <F as Parser<I>>::Error::append(input, ErrorKind::Many, e)
1734 })));
1735 } else {
1736 return Ok((input, res));
1737 }
1738 }
1739 Err(e) => {
1740 return Err(e);
1741 }
1742 }
1743 }
1744
1745 Ok((input, res))
1746 }
1747 }
1748
1749 /// Applies a parser and accumulates the results using a given
1750 /// function and initial value.
1751 /// Fails if the amount of time the embedded parser is run is not
1752 /// within the specified range.
1753 ///
1754 /// # Arguments
1755 /// * `range` Constrains the number of iterations.
1756 /// * A range without an upper bound `a..` allows the parser to run until it fails.
1757 /// * A single `usize` value is equivalent to `value..=value`.
1758 /// * An empty range is invalid.
1759 /// * `parse` The parser to apply.
1760 /// * `init` A function returning the initial value.
1761 /// * `fold` The function that combines a result of `f` with
1762 /// the current accumulator.
1763 /// ```rust
1764 /// # #[macro_use] extern crate nom;
1765 /// # use nom::{Err, error::ErrorKind, Needed, IResult, Parser};
1766 /// use nom::multi::fold;
1767 /// use nom::bytes::complete::tag;
1768 ///
1769 /// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
1770 /// fold(
1771 /// 0..=2,
1772 /// tag("abc"),
1773 /// Vec::new,
1774 /// |mut acc: Vec<_>, item| {
1775 /// acc.push(item);
1776 /// acc
1777 /// }
1778 /// ).parse(s)
1779 /// }
1780 ///
1781 /// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
1782 /// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));
1783 /// assert_eq!(parser("123123"), Ok(("123123", vec![])));
1784 /// assert_eq!(parser(""), Ok(("", vec![])));
1785 /// assert_eq!(parser("abcabcabc"), Ok(("abc", vec!["abc", "abc"])));
1786 /// ```
1787 pub fn fold<I, E, F, G, H, J, R>(
1788 range: J,
1789 parser: F,
1790 init: H,
1791 fold: G,
1792 ) -> impl Parser<I, Output = R, Error = E>
1793 where
1794 I: Clone + Input,
1795 F: Parser<I, Error = E>,
1796 G: FnMut(R, <F as Parser<I>>::Output) -> R,
1797 H: FnMut() -> R,
1798 E: ParseError<I>,
1799 J: NomRange<usize>,
1800 {
1801 Fold {
1802 parser,
1803 init,
1804 fold,
1805 range,
1806 }
1807 }
1808
1809 /// Parser implementation for the [fold] combinator
1810 pub struct Fold<F, G, H, Range> {
1811 parser: F,
1812 init: H,
1813 fold: G,
1814 range: Range,
1815 }
1816
1817 impl<I, F, G, H, Range, Res> Parser<I> for Fold<F, G, H, Range>
1818 where
1819 I: Clone + Input,
1820 F: Parser<I>,
1821 G: FnMut(Res, <F as Parser<I>>::Output) -> Res,
1822 H: FnMut() -> Res,
1823 Range: NomRange<usize>,
1824 {
1825 type Output = Res;
1826 type Error = <F as Parser<I>>::Error;
1827
1828 fn process<OM: OutputMode>(
1829 &mut self,
1830 mut input: I,
1831 ) -> crate::PResult<OM, I, Self::Output, Self::Error> {
1832 if self.range.is_inverted() {
1833 return Err(Err::Failure(<F as Parser<I>>::Error::from_error_kind(
1834 input,
1835 ErrorKind::Fold,
1836 )));
1837 }
1838
1839 let mut acc = OM::Output::bind(|| (self.init)());
1840
1841 for count in self.range.saturating_iter() {
1842 let len = input.input_len();
1843 match self.parser.process::<OM>(input.clone()) {
1844 Ok((tail, value)) => {
1845 // infinite loop check: the parser must always consume
1846 if tail.input_len() == len {
1847 return Err(Err::Error(OM::Error::bind(|| {
1848 <F as Parser<I>>::Error::from_error_kind(tail, ErrorKind::Fold)
1849 })));
1850 }
1851
1852 acc = OM::Output::combine(acc, value, |acc, value| (self.fold)(acc, value));
1853 input = tail;
1854 }
1855 Err(Err::Error(err)) => {
1856 if !self.range.contains(&count) {
1857 return Err(Err::Error(OM::Error::map(err, |err| {
1858 <F as Parser<I>>::Error::append(input, ErrorKind::Fold, err)
1859 })));
1860 } else {
1861 break;
1862 }
1863 }
1864 Err(e) => return Err(e),
1865 }
1866 }
1867
1868 Ok((input, acc))
1869 }
1870 }