diff options
Diffstat (limited to 'vendor/winnow/src/combinator/multi.rs')
-rw-r--r-- | vendor/winnow/src/combinator/multi.rs | 454 |
1 files changed, 206 insertions, 248 deletions
diff --git a/vendor/winnow/src/combinator/multi.rs b/vendor/winnow/src/combinator/multi.rs index 950432601..1fdb7535b 100644 --- a/vendor/winnow/src/combinator/multi.rs +++ b/vendor/winnow/src/combinator/multi.rs @@ -2,12 +2,12 @@ use crate::error::ErrMode; use crate::error::ErrorKind; -use crate::error::ParseError; +use crate::error::ParserError; use crate::stream::Accumulate; use crate::stream::Range; use crate::stream::Stream; use crate::trace::trace; -use crate::IResult; +use crate::PResult; use crate::Parser; /// [`Accumulate`] the output of a parser into a container, like `Vec` @@ -37,7 +37,7 @@ use crate::Parser; /// use winnow::token::tag; /// /// fn parser(s: &str) -> IResult<&str, Vec<&str>> { -/// repeat(0.., "abc").parse_next(s) +/// repeat(0.., "abc").parse_peek(s) /// } /// /// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"]))); @@ -50,38 +50,38 @@ use crate::Parser; /// One or more reptitions: /// ```rust /// # #[cfg(feature = "std")] { -/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed}; +/// # use winnow::{error::ErrMode, error::{InputError, ErrorKind}, error::Needed}; /// # use winnow::prelude::*; /// use winnow::combinator::repeat; /// use winnow::token::tag; /// /// fn parser(s: &str) -> IResult<&str, Vec<&str>> { -/// repeat(1.., "abc").parse_next(s) +/// repeat(1.., "abc").parse_peek(s) /// } /// /// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"]))); /// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"]))); -/// assert_eq!(parser("123123"), Err(ErrMode::Backtrack(Error::new("123123", ErrorKind::Tag)))); -/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Tag)))); +/// assert_eq!(parser("123123"), Err(ErrMode::Backtrack(InputError::new("123123", ErrorKind::Tag)))); +/// assert_eq!(parser(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Tag)))); /// # } /// ``` /// /// Fixed number of repeitions: /// ```rust /// # #[cfg(feature = "std")] { -/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed}; +/// # use winnow::{error::ErrMode, error::{InputError, ErrorKind}, error::Needed}; /// # use winnow::prelude::*; /// use winnow::combinator::repeat; /// use winnow::token::tag; /// /// fn parser(s: &str) -> IResult<&str, Vec<&str>> { -/// repeat(2, "abc").parse_next(s) +/// repeat(2, "abc").parse_peek(s) /// } /// /// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"]))); -/// assert_eq!(parser("abc123"), Err(ErrMode::Backtrack(Error::new("123", ErrorKind::Tag)))); -/// assert_eq!(parser("123123"), Err(ErrMode::Backtrack(Error::new("123123", ErrorKind::Tag)))); -/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Tag)))); +/// assert_eq!(parser("abc123"), Err(ErrMode::Backtrack(InputError::new("123", ErrorKind::Tag)))); +/// assert_eq!(parser("123123"), Err(ErrMode::Backtrack(InputError::new("123123", ErrorKind::Tag)))); +/// assert_eq!(parser(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Tag)))); /// assert_eq!(parser("abcabcabc"), Ok(("abc", vec!["abc", "abc"]))); /// # } /// ``` @@ -95,7 +95,7 @@ use crate::Parser; /// use winnow::token::tag; /// /// fn parser(s: &str) -> IResult<&str, Vec<&str>> { -/// repeat(0..=2, "abc").parse_next(s) +/// repeat(0..=2, "abc").parse_peek(s) /// } /// /// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"]))); @@ -120,13 +120,13 @@ where I: Stream, C: Accumulate<O>, F: Parser<I, O, E>, - E: ParseError<I>, + E: ParserError<I>, { let Range { start_inclusive, end_inclusive, } = range.into(); - trace("repeat", move |i: I| { + trace("repeat", move |i: &mut I| { match (start_inclusive, end_inclusive) { (0, None) => repeat0_(&mut f, i), (1, None) => repeat1_(&mut f, i), @@ -136,84 +136,63 @@ where }) } -/// Deprecated, replaced by [`repeat`] -#[deprecated(since = "0.4.6", note = "Replaced with `repeat`")] -#[inline(always)] -pub fn repeat0<I, O, C, E, F>(f: F) -> impl Parser<I, C, E> -where - I: Stream, - C: Accumulate<O>, - F: Parser<I, O, E>, - E: ParseError<I>, -{ - repeat(0.., f) -} - -fn repeat0_<I, O, C, E, F>(f: &mut F, mut i: I) -> IResult<I, C, E> +fn repeat0_<I, O, C, E, F>(f: &mut F, i: &mut I) -> PResult<C, E> where I: Stream, C: Accumulate<O>, F: Parser<I, O, E>, - E: ParseError<I>, + E: ParserError<I>, { let mut acc = C::initial(None); loop { + let start = i.checkpoint(); let len = i.eof_offset(); - match f.parse_next(i.clone()) { - Err(ErrMode::Backtrack(_)) => return Ok((i, acc)), + match f.parse_next(i) { + Err(ErrMode::Backtrack(_)) => { + i.reset(start); + return Ok(acc); + } Err(e) => return Err(e), - Ok((i1, o)) => { + Ok(o) => { // infinite loop check: the parser must always consume - if i1.eof_offset() == len { + if i.eof_offset() == len { return Err(ErrMode::assert(i, "`repeat` parsers must always consume")); } - i = i1; acc.accumulate(o); } } } } -/// Deprecated, replaced by [`repeat`] -#[deprecated(since = "0.4.6", note = "Replaced with `repeat`")] -#[inline(always)] -pub fn repeat1<I, O, C, E, F>(f: F) -> impl Parser<I, C, E> -where - I: Stream, - C: Accumulate<O>, - F: Parser<I, O, E>, - E: ParseError<I>, -{ - repeat(1.., f) -} - -fn repeat1_<I, O, C, E, F>(f: &mut F, mut i: I) -> IResult<I, C, E> +fn repeat1_<I, O, C, E, F>(f: &mut F, i: &mut I) -> PResult<C, E> where I: Stream, C: Accumulate<O>, F: Parser<I, O, E>, - E: ParseError<I>, + E: ParserError<I>, { - match f.parse_next(i.clone()) { + match f.parse_next(i) { Err(e) => Err(e.append(i, ErrorKind::Many)), - Ok((i1, o)) => { + Ok(o) => { let mut acc = C::initial(None); acc.accumulate(o); - i = i1; loop { + let start = i.checkpoint(); let len = i.eof_offset(); - match f.parse_next(i.clone()) { - Err(ErrMode::Backtrack(_)) => return Ok((i, acc)), + match f.parse_next(i) { + Err(ErrMode::Backtrack(_)) => { + i.reset(start); + return Ok(acc); + } Err(e) => return Err(e), - Ok((i1, o)) => { + Ok(o) => { // infinite loop check: the parser must always consume - if i1.eof_offset() == len { + if i.eof_offset() == len { return Err(ErrMode::assert(i, "`repeat` parsers must always consume")); } - i = i1; acc.accumulate(o); } } @@ -235,19 +214,19 @@ where /// /// ```rust /// # #[cfg(feature = "std")] { -/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed}; +/// # use winnow::{error::ErrMode, error::{InputError, ErrorKind}, error::Needed}; /// # use winnow::prelude::*; /// use winnow::combinator::repeat_till0; /// use winnow::token::tag; /// /// fn parser(s: &str) -> IResult<&str, (Vec<&str>, &str)> { -/// repeat_till0("abc", "end").parse_next(s) +/// repeat_till0("abc", "end").parse_peek(s) /// }; /// /// assert_eq!(parser("abcabcend"), Ok(("", (vec!["abc", "abc"], "end")))); -/// assert_eq!(parser("abc123end"), Err(ErrMode::Backtrack(Error::new("123end", ErrorKind::Tag)))); -/// assert_eq!(parser("123123end"), Err(ErrMode::Backtrack(Error::new("123123end", ErrorKind::Tag)))); -/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Tag)))); +/// assert_eq!(parser("abc123end"), Err(ErrMode::Backtrack(InputError::new("123end", ErrorKind::Tag)))); +/// assert_eq!(parser("123123end"), Err(ErrMode::Backtrack(InputError::new("123123end", ErrorKind::Tag)))); +/// assert_eq!(parser(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Tag)))); /// assert_eq!(parser("abcendefg"), Ok(("efg", (vec!["abc"], "end")))); /// # } /// ``` @@ -258,20 +237,22 @@ where C: Accumulate<O>, F: Parser<I, O, E>, G: Parser<I, P, E>, - E: ParseError<I>, + E: ParserError<I>, { - trace("repeat_till0", move |mut i: I| { + trace("repeat_till0", move |i: &mut I| { let mut res = C::initial(None); loop { + let start = i.checkpoint(); let len = i.eof_offset(); - match g.parse_next(i.clone()) { - Ok((i1, o)) => return Ok((i1, (res, o))), + match g.parse_next(i) { + Ok(o) => return Ok((res, o)), Err(ErrMode::Backtrack(_)) => { - match f.parse_next(i.clone()) { + i.reset(start); + match f.parse_next(i) { Err(e) => return Err(e.append(i, ErrorKind::Many)), - Ok((i1, o)) => { + Ok(o) => { // infinite loop check: the parser must always consume - if i1.eof_offset() == len { + if i.eof_offset() == len { return Err(ErrMode::assert( i, "`repeat` parsers must always consume", @@ -279,7 +260,6 @@ where } res.accumulate(o); - i = i1; } } } @@ -308,7 +288,7 @@ where /// use winnow::token::tag; /// /// fn parser(s: &str) -> IResult<&str, Vec<&str>> { -/// separated0("abc", "|").parse_next(s) +/// separated0("abc", "|").parse_peek(s) /// } /// /// assert_eq!(parser("abc|abc|abc"), Ok(("", vec!["abc", "abc", "abc"]))); @@ -326,37 +306,46 @@ where C: Accumulate<O>, P: Parser<I, O, E>, S: Parser<I, O2, E>, - E: ParseError<I>, + E: ParserError<I>, { - trace("separated0", move |mut i: I| { + trace("separated0", move |i: &mut I| { let mut res = C::initial(None); - match parser.parse_next(i.clone()) { - Err(ErrMode::Backtrack(_)) => return Ok((i, res)), + let start = i.checkpoint(); + match parser.parse_next(i) { + Err(ErrMode::Backtrack(_)) => { + i.reset(start); + return Ok(res); + } Err(e) => return Err(e), - Ok((i1, o)) => { + Ok(o) => { res.accumulate(o); - i = i1; } } loop { + let start = i.checkpoint(); let len = i.eof_offset(); - match sep.parse_next(i.clone()) { - Err(ErrMode::Backtrack(_)) => return Ok((i, res)), + match sep.parse_next(i) { + Err(ErrMode::Backtrack(_)) => { + i.reset(start); + return Ok(res); + } Err(e) => return Err(e), - Ok((i1, _)) => { + Ok(_) => { // infinite loop check: the parser must always consume - if i1.eof_offset() == len { + if i.eof_offset() == len { return Err(ErrMode::assert(i, "sep parsers must always consume")); } - match parser.parse_next(i1.clone()) { - Err(ErrMode::Backtrack(_)) => return Ok((i, res)), + match parser.parse_next(i) { + Err(ErrMode::Backtrack(_)) => { + i.reset(start); + return Ok(res); + } Err(e) => return Err(e), - Ok((i2, o)) => { + Ok(o) => { res.accumulate(o); - i = i2; } } } @@ -380,20 +369,20 @@ where /// /// ```rust /// # #[cfg(feature = "std")] { -/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed}; +/// # use winnow::{error::ErrMode, error::{InputError, ErrorKind}, error::Needed}; /// # use winnow::prelude::*; /// use winnow::combinator::separated1; /// use winnow::token::tag; /// /// fn parser(s: &str) -> IResult<&str, Vec<&str>> { -/// separated1("abc", "|").parse_next(s) +/// separated1("abc", "|").parse_peek(s) /// } /// /// assert_eq!(parser("abc|abc|abc"), Ok(("", vec!["abc", "abc", "abc"]))); /// assert_eq!(parser("abc123abc"), Ok(("123abc", vec!["abc"]))); /// assert_eq!(parser("abc|def"), Ok(("|def", vec!["abc"]))); -/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Tag)))); -/// assert_eq!(parser("def|abc"), Err(ErrMode::Backtrack(Error::new("def|abc", ErrorKind::Tag)))); +/// assert_eq!(parser(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Tag)))); +/// assert_eq!(parser("def|abc"), Err(ErrMode::Backtrack(InputError::new("def|abc", ErrorKind::Tag)))); /// # } /// ``` #[doc(alias = "sep_by1")] @@ -404,37 +393,42 @@ where C: Accumulate<O>, P: Parser<I, O, E>, S: Parser<I, O2, E>, - E: ParseError<I>, + E: ParserError<I>, { - trace("separated1", move |mut i: I| { + trace("separated1", move |i: &mut I| { let mut res = C::initial(None); // Parse the first element - match parser.parse_next(i.clone()) { + match parser.parse_next(i) { Err(e) => return Err(e), - Ok((i1, o)) => { + Ok(o) => { res.accumulate(o); - i = i1; } } loop { + let start = i.checkpoint(); let len = i.eof_offset(); - match sep.parse_next(i.clone()) { - Err(ErrMode::Backtrack(_)) => return Ok((i, res)), + match sep.parse_next(i) { + Err(ErrMode::Backtrack(_)) => { + i.reset(start); + return Ok(res); + } Err(e) => return Err(e), - Ok((i1, _)) => { + Ok(_) => { // infinite loop check: the parser must always consume - if i1.eof_offset() == len { + if i.eof_offset() == len { return Err(ErrMode::assert(i, "sep parsers must always consume")); } - match parser.parse_next(i1.clone()) { - Err(ErrMode::Backtrack(_)) => return Ok((i, res)), + match parser.parse_next(i) { + Err(ErrMode::Backtrack(_)) => { + i.reset(start); + return Ok(res); + } Err(e) => return Err(e), - Ok((i2, o)) => { + Ok(o) => { res.accumulate(o); - i = i2; } } } @@ -451,18 +445,18 @@ where /// # Example /// /// ```rust -/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed}; +/// # use winnow::{error::ErrMode, error::{InputError, ErrorKind}, error::Needed}; /// # use winnow::prelude::*; /// use winnow::combinator::separated_foldl1; /// use winnow::ascii::dec_int; /// /// fn parser(s: &str) -> IResult<&str, i32> { -/// separated_foldl1(dec_int, "-", |l, _, r| l - r).parse_next(s) +/// separated_foldl1(dec_int, "-", |l, _, r| l - r).parse_peek(s) /// } /// /// assert_eq!(parser("9-3-5"), Ok(("", 1))); -/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Slice)))); -/// assert_eq!(parser("def|abc"), Err(ErrMode::Backtrack(Error::new("def|abc", ErrorKind::Slice)))); +/// assert_eq!(parser(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Slice)))); +/// assert_eq!(parser("def|abc"), Err(ErrMode::Backtrack(InputError::new("def|abc", ErrorKind::Slice)))); /// ``` pub fn separated_foldl1<I, O, O2, E, P, S, Op>( mut parser: P, @@ -473,29 +467,35 @@ where I: Stream, P: Parser<I, O, E>, S: Parser<I, O2, E>, - E: ParseError<I>, + E: ParserError<I>, Op: Fn(O, O2, O) -> O, { - trace("separated_foldl1", move |i: I| { - let (mut i, mut ol) = parser.parse_next(i)?; + trace("separated_foldl1", move |i: &mut I| { + let mut ol = parser.parse_next(i)?; loop { + let start = i.checkpoint(); let len = i.eof_offset(); - match sep.parse_next(i.clone()) { - Err(ErrMode::Backtrack(_)) => return Ok((i, ol)), + match sep.parse_next(i) { + Err(ErrMode::Backtrack(_)) => { + i.reset(start); + return Ok(ol); + } Err(e) => return Err(e), - Ok((i1, s)) => { + Ok(s) => { // infinite loop check: the parser must always consume - if i1.eof_offset() == len { + if i.eof_offset() == len { return Err(ErrMode::assert(i, "`repeat` parsers must always consume")); } - match parser.parse_next(i1.clone()) { - Err(ErrMode::Backtrack(_)) => return Ok((i, ol)), + match parser.parse_next(i) { + Err(ErrMode::Backtrack(_)) => { + i.reset(start); + return Ok(ol); + } Err(e) => return Err(e), - Ok((i2, or)) => { + Ok(or) => { ol = op(ol, s, or); - i = i2; } } } @@ -512,19 +512,19 @@ where /// # Example /// /// ``` -/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed}; +/// # use winnow::{error::ErrMode, error::{InputError, ErrorKind}, error::Needed}; /// # use winnow::prelude::*; /// use winnow::combinator::separated_foldr1; /// use winnow::ascii::dec_uint; /// /// fn parser(s: &str) -> IResult<&str, u32> { -/// separated_foldr1(dec_uint, "^", |l: u32, _, r: u32| l.pow(r)).parse_next(s) +/// separated_foldr1(dec_uint, "^", |l: u32, _, r: u32| l.pow(r)).parse_peek(s) /// } /// /// assert_eq!(parser("2^3^2"), Ok(("", 512))); /// assert_eq!(parser("2"), Ok(("", 2))); -/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Slice)))); -/// assert_eq!(parser("def|abc"), Err(ErrMode::Backtrack(Error::new("def|abc", ErrorKind::Slice)))); +/// assert_eq!(parser(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Slice)))); +/// assert_eq!(parser("def|abc"), Err(ErrMode::Backtrack(InputError::new("def|abc", ErrorKind::Slice)))); /// ``` #[cfg(feature = "alloc")] pub fn separated_foldr1<I, O, O2, E, P, S, Op>( @@ -536,12 +536,12 @@ where I: Stream, P: Parser<I, O, E>, S: Parser<I, O2, E>, - E: ParseError<I>, + E: ParserError<I>, Op: Fn(O, O2, O) -> O, { - trace("separated_foldr1", move |i: I| { - let (i, ol) = parser.parse_next(i)?; - let (i, all): (_, crate::lib::std::vec::Vec<(O2, O)>) = + trace("separated_foldr1", move |i: &mut I| { + let ol = parser.parse_next(i)?; + let all: crate::lib::std::vec::Vec<(O2, O)> = repeat(0.., (sep.by_ref(), parser.by_ref())).parse_next(i)?; if let Some((s, or)) = all .into_iter() @@ -549,24 +549,19 @@ where .reduce(|(sr, or), (sl, ol)| (sl, op(ol, sr, or))) { let merged = op(ol, s, or); - Ok((i, merged)) + Ok(merged) } else { - Ok((i, ol)) + Ok(ol) } }) } -fn repeat_m_n_<I, O, C, E, F>( - min: usize, - max: usize, - parse: &mut F, - mut input: I, -) -> IResult<I, C, E> +fn repeat_m_n_<I, O, C, E, F>(min: usize, max: usize, parse: &mut F, input: &mut I) -> PResult<C, E> where I: Stream, C: Accumulate<O>, F: Parser<I, O, E>, - E: ParseError<I>, + E: ParserError<I>, { if min > max { return Err(ErrMode::Cut(E::from_error_kind(input, ErrorKind::Many))); @@ -574,11 +569,12 @@ where let mut res = C::initial(Some(min)); for count in 0..max { + let start = input.checkpoint(); let len = input.eof_offset(); - match parse.parse_next(input.clone()) { - Ok((tail, value)) => { + match parse.parse_next(input) { + Ok(value) => { // infinite loop check: the parser must always consume - if tail.eof_offset() == len { + if input.eof_offset() == len { return Err(ErrMode::assert( input, "`repeat` parsers must always consume", @@ -586,13 +582,13 @@ where } res.accumulate(value); - input = tail; } Err(ErrMode::Backtrack(e)) => { if count < min { return Err(ErrMode::Backtrack(e.append(input, ErrorKind::Many))); } else { - return Ok((input, res)); + input.reset(start); + return Ok(res); } } Err(e) => { @@ -601,38 +597,22 @@ where } } - Ok((input, res)) + Ok(res) } -/// Deprecated, replaced by [`repeat`] -#[deprecated(since = "0.4.6", note = "Replaced with `repeat`")] -#[inline(always)] -pub fn count<I, O, C, E, F>(f: F, count: usize) -> impl Parser<I, C, E> +fn repeat_n_<I, O, C, E, F>(count: usize, f: &mut F, i: &mut I) -> PResult<C, E> where I: Stream, C: Accumulate<O>, F: Parser<I, O, E>, - E: ParseError<I>, + E: ParserError<I>, { - repeat(count, f) -} - -fn repeat_n_<I, O, C, E, F>(count: usize, f: &mut F, i: I) -> IResult<I, C, E> -where - I: Stream, - C: Accumulate<O>, - F: Parser<I, O, E>, - E: ParseError<I>, -{ - let mut input = i.clone(); let mut res = C::initial(Some(count)); for _ in 0..count { - let input_ = input.clone(); - match f.parse_next(input_) { - Ok((i, o)) => { + match f.parse_next(i) { + Ok(o) => { res.accumulate(o); - input = i; } Err(e) => { return Err(e.append(i, ErrorKind::Many)); @@ -640,7 +620,7 @@ where } } - Ok((input, res)) + Ok(res) } /// Repeats the embedded parser, filling the given slice with results. @@ -654,38 +634,34 @@ where /// # Example /// /// ```rust -/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed}; +/// # use winnow::{error::ErrMode, error::{InputError, ErrorKind}, error::Needed}; /// # use winnow::prelude::*; /// use winnow::combinator::fill; /// use winnow::token::tag; /// /// fn parser(s: &str) -> IResult<&str, [&str; 2]> { /// let mut buf = ["", ""]; -/// let (rest, ()) = fill("abc", &mut buf).parse_next(s)?; +/// let (rest, ()) = fill("abc", &mut buf).parse_peek(s)?; /// Ok((rest, buf)) /// } /// /// assert_eq!(parser("abcabc"), Ok(("", ["abc", "abc"]))); -/// assert_eq!(parser("abc123"), Err(ErrMode::Backtrack(Error::new("123", ErrorKind::Tag)))); -/// assert_eq!(parser("123123"), Err(ErrMode::Backtrack(Error::new("123123", ErrorKind::Tag)))); -/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Tag)))); +/// assert_eq!(parser("abc123"), Err(ErrMode::Backtrack(InputError::new("123", ErrorKind::Tag)))); +/// assert_eq!(parser("123123"), Err(ErrMode::Backtrack(InputError::new("123123", ErrorKind::Tag)))); +/// assert_eq!(parser(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Tag)))); /// assert_eq!(parser("abcabcabc"), Ok(("abc", ["abc", "abc"]))); /// ``` pub fn fill<'a, I, O, E, F>(mut f: F, buf: &'a mut [O]) -> impl Parser<I, (), E> + 'a where I: Stream + 'a, F: Parser<I, O, E> + 'a, - E: ParseError<I> + 'a, + E: ParserError<I> + 'a, { - trace("fill", move |i: I| { - let mut input = i.clone(); - + trace("fill", move |i: &mut I| { for elem in buf.iter_mut() { - let input_ = input.clone(); - match f.parse_next(input_) { - Ok((i, o)) => { + match f.parse_next(i) { + Ok(o) => { *elem = o; - input = i; } Err(e) => { return Err(e.append(i, ErrorKind::Many)); @@ -693,7 +669,7 @@ where } } - Ok((input, ())) + Ok(()) }) } @@ -732,7 +708,7 @@ where /// acc.push(item); /// acc /// } -/// ).parse_next(s) +/// ).parse_peek(s) /// } /// /// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"]))); @@ -743,7 +719,7 @@ where /// /// One or more repetitions: /// ```rust -/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed}; +/// # use winnow::{error::ErrMode, error::{InputError, ErrorKind}, error::Needed}; /// # use winnow::prelude::*; /// use winnow::combinator::fold_repeat; /// use winnow::token::tag; @@ -757,13 +733,13 @@ where /// acc.push(item); /// acc /// } -/// ).parse_next(s) +/// ).parse_peek(s) /// } /// /// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"]))); /// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"]))); -/// assert_eq!(parser("123123"), Err(ErrMode::Backtrack(Error::new("123123", ErrorKind::Many)))); -/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Many)))); +/// assert_eq!(parser("123123"), Err(ErrMode::Backtrack(InputError::new("123123", ErrorKind::Many)))); +/// assert_eq!(parser(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Many)))); /// ``` /// /// Arbitrary number of repetitions: @@ -782,7 +758,7 @@ where /// acc.push(item); /// acc /// } -/// ).parse_next(s) +/// ).parse_peek(s) /// } /// /// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"]))); @@ -806,13 +782,13 @@ where F: Parser<I, O, E>, G: FnMut(R, O) -> R, H: FnMut() -> R, - E: ParseError<I>, + E: ParserError<I>, { let Range { start_inclusive, end_inclusive, } = range.into(); - trace("fold_repeat", move |i: I| { + trace("fold_repeat", move |i: &mut I| { match (start_inclusive, end_inclusive) { (0, None) => fold_repeat0_(&mut f, &mut init, &mut g, i), (1, None) => fold_repeat1_(&mut f, &mut init, &mut g, i), @@ -828,48 +804,39 @@ where }) } -/// Deprecated, replaced by [`fold_repeat`] -#[deprecated(since = "0.4.6", note = "Replaced with `fold_repeat`")] -#[inline(always)] -pub fn fold_repeat0<I, O, E, F, G, H, R>(mut f: F, mut init: H, mut g: G) -> impl Parser<I, R, E> -where - I: Stream, - F: Parser<I, O, E>, - G: FnMut(R, O) -> R, - H: FnMut() -> R, - E: ParseError<I>, -{ - trace("fold_repeat0", move |i: I| { - fold_repeat0_(&mut f, &mut init, &mut g, i) - }) -} - -fn fold_repeat0_<I, O, E, F, G, H, R>(f: &mut F, init: &mut H, g: &mut G, i: I) -> IResult<I, R, E> +fn fold_repeat0_<I, O, E, F, G, H, R>( + f: &mut F, + init: &mut H, + g: &mut G, + input: &mut I, +) -> PResult<R, E> where I: Stream, F: Parser<I, O, E>, G: FnMut(R, O) -> R, H: FnMut() -> R, - E: ParseError<I>, + E: ParserError<I>, { let mut res = init(); - let mut input = i; loop { - let i_ = input.clone(); + let start = input.checkpoint(); let len = input.eof_offset(); - match f.parse_next(i_) { - Ok((i, o)) => { + match f.parse_next(input) { + Ok(o) => { // infinite loop check: the parser must always consume - if i.eof_offset() == len { - return Err(ErrMode::assert(i, "`repeat` parsers must always consume")); + if input.eof_offset() == len { + return Err(ErrMode::assert( + input, + "`repeat` parsers must always consume", + )); } res = g(res, o); - input = i; } Err(ErrMode::Backtrack(_)) => { - return Ok((input, res)); + input.reset(start); + return Ok(res); } Err(e) => { return Err(e); @@ -878,60 +845,50 @@ where } } -/// Deprecated, replaced by [`fold_repeat`] -#[deprecated(since = "0.4.6", note = "Replaced with `fold_repeat`")] -#[inline(always)] -pub fn fold_repeat1<I, O, E, F, G, H, R>(mut f: F, mut init: H, mut g: G) -> impl Parser<I, R, E> -where - I: Stream, - F: Parser<I, O, E>, - G: FnMut(R, O) -> R, - H: FnMut() -> R, - E: ParseError<I>, -{ - trace("fold_repeat1", move |i: I| { - fold_repeat1_(&mut f, &mut init, &mut g, i) - }) -} - -fn fold_repeat1_<I, O, E, F, G, H, R>(f: &mut F, init: &mut H, g: &mut G, i: I) -> IResult<I, R, E> +fn fold_repeat1_<I, O, E, F, G, H, R>( + f: &mut F, + init: &mut H, + g: &mut G, + input: &mut I, +) -> PResult<R, E> where I: Stream, F: Parser<I, O, E>, G: FnMut(R, O) -> R, H: FnMut() -> R, - E: ParseError<I>, + E: ParserError<I>, { - let _i = i.clone(); let init = init(); - match f.parse_next(_i) { - Err(ErrMode::Backtrack(_)) => Err(ErrMode::from_error_kind(i, ErrorKind::Many)), + match f.parse_next(input) { + Err(ErrMode::Backtrack(_)) => Err(ErrMode::from_error_kind(input, ErrorKind::Many)), Err(e) => Err(e), - Ok((i1, o1)) => { + Ok(o1) => { let mut acc = g(init, o1); - let mut input = i1; loop { - let _input = input.clone(); + let start = input.checkpoint(); let len = input.eof_offset(); - match f.parse_next(_input) { + match f.parse_next(input) { Err(ErrMode::Backtrack(_)) => { + input.reset(start); break; } Err(e) => return Err(e), - Ok((i, o)) => { + Ok(o) => { // infinite loop check: the parser must always consume - if i.eof_offset() == len { - return Err(ErrMode::assert(i, "`repeat` parsers must always consume")); + if input.eof_offset() == len { + return Err(ErrMode::assert( + input, + "`repeat` parsers must always consume", + )); } acc = g(acc, o); - input = i; } } } - Ok((input, acc)) + Ok(acc) } } } @@ -942,14 +899,14 @@ fn fold_repeat_m_n_<I, O, E, F, G, H, R>( parse: &mut F, init: &mut H, fold: &mut G, - mut input: I, -) -> IResult<I, R, E> + input: &mut I, +) -> PResult<R, E> where I: Stream, F: Parser<I, O, E>, G: FnMut(R, O) -> R, H: FnMut() -> R, - E: ParseError<I>, + E: ParserError<I>, { if min > max { return Err(ErrMode::Cut(E::from_error_kind(input, ErrorKind::Many))); @@ -957,11 +914,12 @@ where let mut acc = init(); for count in 0..max { + let start = input.checkpoint(); let len = input.eof_offset(); - match parse.parse_next(input.clone()) { - Ok((tail, value)) => { + match parse.parse_next(input) { + Ok(value) => { // infinite loop check: the parser must always consume - if tail.eof_offset() == len { + if input.eof_offset() == len { return Err(ErrMode::assert( input, "`repeat` parsers must always consume", @@ -969,13 +927,13 @@ where } acc = fold(acc, value); - input = tail; } //FInputXMError: handle failure properly Err(ErrMode::Backtrack(err)) => { if count < min { return Err(ErrMode::Backtrack(err.append(input, ErrorKind::Many))); } else { + input.reset(start); break; } } @@ -983,5 +941,5 @@ where } } - Ok((input, acc)) + Ok(acc) } |