summaryrefslogtreecommitdiffstats
path: root/vendor/winnow/src/combinator/multi.rs
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/winnow/src/combinator/multi.rs')
-rw-r--r--vendor/winnow/src/combinator/multi.rs454
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)
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-10-24 22:02:22 +0000