From 3ab6ce3d82838705d5803ca5a9c301faa97370e3 Mon Sep 17 00:00:00 2001 From: Ed Page Date: Mon, 26 Jun 2023 15:51:44 -0500 Subject: [PATCH] feat(stream)!: Allow mutable iteration --- proptest-regressions/stream/tests.txt | 7 ++ src/ascii/mod.rs | 48 +++---- src/binary/bits/mod.rs | 8 +- src/binary/mod.rs | 2 +- src/combinator/core.rs | 4 +- src/combinator/parser.rs | 4 +- src/combinator/tests.rs | 2 +- src/parser.rs | 4 +- src/stream/mod.rs | 172 +++++++++++++------------- src/stream/tests.rs | 10 +- src/token/mod.rs | 28 ++--- src/trace/internals.rs | 2 +- 12 files changed, 146 insertions(+), 145 deletions(-) create mode 100644 proptest-regressions/stream/tests.txt diff --git a/proptest-regressions/stream/tests.txt b/proptest-regressions/stream/tests.txt new file mode 100644 index 00000000..ba3ce3cd --- /dev/null +++ b/proptest-regressions/stream/tests.txt @@ -0,0 +1,7 @@ +# Seeds for failure cases proptest has generated in the past. It is +# automatically read and these particular cases re-run before any +# novel cases are generated. +# +# It is recommended to check this file in to source control so that +# everyone who runs the test benefits from these saved cases. +cc dd80dcf3d84999d176d263e5de7ab8bd3c9b7d0b24fa74cb6004556677665b72 # shrinks to byte_len = 11, start = 0 diff --git a/src/ascii/mod.rs b/src/ascii/mod.rs index 94699e3f..512ff677 100644 --- a/src/ascii/mod.rs +++ b/src/ascii/mod.rs @@ -124,9 +124,9 @@ where c == '\r' || c == '\n' }) { None if PARTIAL && input.is_partial() => Err(ErrMode::Incomplete(Needed::Unknown)), - None => Ok(input.finish()), + None => Ok(input.peek_finish()), Some(offset) => { - let (new_input, res) = input.next_slice(offset); + let (new_input, res) = input.peek_slice(offset); let bytes = new_input.as_bstr(); let nth = bytes[0]; if nth == b'\r' { @@ -935,7 +935,7 @@ where if offset == 0 { return Err(ErrMode::from_error_kind(input, ErrorKind::Slice)); } else { - return Ok((input.next_slice(offset).0, value)); + return Ok((input.peek_slice(offset).0, value)); } } } @@ -944,7 +944,7 @@ where if ::is_partial_supported() && input.is_partial() { Err(ErrMode::Incomplete(Needed::new(1))) } else { - Ok((input.finish().0, value)) + Ok((input.peek_finish().0, value)) } }) .parse_next(input) @@ -1100,7 +1100,7 @@ where if offset == 0 { return Err(ErrMode::from_error_kind(input, ErrorKind::Slice)); } else { - return Ok((input.next_slice(offset).0, value)); + return Ok((input.peek_slice(offset).0, value)); } } } @@ -1109,7 +1109,7 @@ where if ::is_partial_supported() && input.is_partial() { Err(ErrMode::Incomplete(Needed::new(1))) } else { - Ok((input.finish().0, value)) + Ok((input.peek_finish().0, value)) } }) .parse_next(input) @@ -1232,7 +1232,7 @@ where // Must be at least one digit return Err(ErrMode::from_error_kind(input, ErrorKind::Slice)); } - let (remaining, parsed) = input.next_slice(offset); + let (remaining, parsed) = input.peek_slice(offset); let mut res = O::default(); for c in parsed.as_bstr() { @@ -1482,15 +1482,15 @@ where } else if i2.eof_offset() == current_len { let offset = i2.offset_from(&start); input.reset(start); - return Ok(input.next_slice(offset)); + return Ok(input.peek_slice(offset)); } else { input = i2; } } Err(ErrMode::Backtrack(_)) => { - if input.next_token().expect("eof_offset > 0").1.as_char() == control_char { + if input.peek_token().expect("eof_offset > 0").1.as_char() == control_char { let next = control_char.len_utf8(); - let (i2, _) = escapable.parse_next(input.next_slice(next).0)?; + let (i2, _) = escapable.parse_next(input.peek_slice(next).0)?; if i2.eof_offset() == 0 { return Err(ErrMode::Incomplete(Needed::Unknown)); } else { @@ -1499,7 +1499,7 @@ where } else { let offset = input.offset_from(&start); input.reset(start); - return Ok(input.next_slice(offset)); + return Ok(input.peek_slice(offset)); } } Err(e) => { @@ -1536,29 +1536,29 @@ where // does not consume anything if i2.eof_offset() == 0 { input.reset(start); - return Ok(input.finish()); + return Ok(input.peek_finish()); } else if i2.eof_offset() == current_len { let offset = i2.offset_from(&start); input.reset(start); - return Ok(input.next_slice(offset)); + return Ok(input.peek_slice(offset)); } else { input = i2; } } Err(ErrMode::Backtrack(_)) => { - if input.next_token().expect("eof_offset > 0").1.as_char() == control_char { + if input.peek_token().expect("eof_offset > 0").1.as_char() == control_char { let next = control_char.len_utf8(); - let (i2, _) = escapable.parse_next(input.next_slice(next).0)?; + let (i2, _) = escapable.parse_next(input.peek_slice(next).0)?; if i2.eof_offset() == 0 { input.reset(start); - return Ok(input.finish()); + return Ok(input.peek_finish()); } else { input = i2; } } else { let offset = input.offset_from(&start); input.reset(start); - return Ok(input.next_slice(offset)); + return Ok(input.peek_slice(offset)); } } Err(e) => { @@ -1567,7 +1567,7 @@ where } } - Ok(input.finish()) + Ok(input.peek_finish()) } /// Matches a byte string with escaped characters. @@ -1684,9 +1684,9 @@ where } } Err(ErrMode::Backtrack(_)) => { - if input.next_token().expect("eof_offset > 0").1.as_char() == control_char { + if input.peek_token().expect("eof_offset > 0").1.as_char() == control_char { let next = control_char.len_utf8(); - let (i2, o) = transform.parse_next(input.next_slice(next).0)?; + let (i2, o) = transform.parse_next(input.peek_slice(next).0)?; res.accumulate(o); if i2.eof_offset() == 0 { return Err(ErrMode::Incomplete(Needed::Unknown)); @@ -1727,7 +1727,7 @@ where Ok((i2, o)) => { res.accumulate(o); if i2.eof_offset() == 0 { - return Ok((input.finish().0, res)); + return Ok((input.peek_finish().0, res)); } else if i2.eof_offset() == current_len { return Ok((input, res)); } else { @@ -1735,12 +1735,12 @@ where } } Err(ErrMode::Backtrack(_)) => { - if input.next_token().expect("eof_offset > 0").1.as_char() == control_char { + if input.peek_token().expect("eof_offset > 0").1.as_char() == control_char { let next = control_char.len_utf8(); - let (i2, o) = transform.parse_next(input.next_slice(next).0)?; + let (i2, o) = transform.parse_next(input.peek_slice(next).0)?; res.accumulate(o); if i2.eof_offset() == 0 { - return Ok((input.finish().0, res)); + return Ok((input.peek_finish().0, res)); } else { input = i2; } diff --git a/src/binary/bits/mod.rs b/src/binary/bits/mod.rs index 5400e330..ac59cd6d 100644 --- a/src/binary/bits/mod.rs +++ b/src/binary/bits/mod.rs @@ -57,7 +57,7 @@ where // The parser functions might already slice away all fully read bytes. // That's why `offset / 8` isn't necessarily needed at all times. let remaining_bytes_index = offset / 8 + if offset % 8 == 0 { 0 } else { 1 }; - let (input, _) = rest.next_slice(remaining_bytes_index); + let (input, _) = rest.peek_slice(remaining_bytes_index); Ok((input, result)) } Err(ErrMode::Incomplete(n)) => Err(ErrMode::Incomplete(n.map(|u| u.get() / 8 + 1))), @@ -105,9 +105,9 @@ where { trace("bytes", move |(input, offset): (I, usize)| { let (inner, _) = if offset % 8 != 0 { - input.next_slice(1 + offset / 8) + input.peek_slice(1 + offset / 8) } else { - input.next_slice(offset / 8) + input.peek_slice(offset / 8) }; let i = (input, offset); match parser.parse_next(inner) { @@ -221,7 +221,7 @@ where offset = 0; } } - let (input, _) = input.next_slice(cnt); + let (input, _) = input.peek_slice(cnt); Ok(((input, end_offset), acc)) } } diff --git a/src/binary/mod.rs b/src/binary/mod.rs index 80435e35..2b57b429 100644 --- a/src/binary/mod.rs +++ b/src/binary/mod.rs @@ -1266,7 +1266,7 @@ where I: StreamIsPartial, I: Stream, { - input.next_token().ok_or_else(|| { + input.peek_token().ok_or_else(|| { if PARTIAL && input.is_partial() { ErrMode::Incomplete(Needed::new(1)) } else { diff --git a/src/combinator/core.rs b/src/combinator/core.rs index c7cc62d0..f68bcd4c 100644 --- a/src/combinator/core.rs +++ b/src/combinator/core.rs @@ -19,7 +19,7 @@ pub fn rest>(input: I) -> IResult::Slice, E where I: Stream, { - trace("rest", move |input: I| Ok(input.finish())).parse_next(input) + trace("rest", move |input: I| Ok(input.peek_finish())).parse_next(input) } /// Return the length of the remaining input. @@ -176,7 +176,7 @@ where { trace("eof", move |input: I| { if input.eof_offset() == 0 { - Ok(input.next_slice(0)) + Ok(input.peek_slice(0)) } else { Err(ErrMode::from_error_kind(input, ErrorKind::Eof)) } diff --git a/src/combinator/parser.rs b/src/combinator/parser.rs index 560903b2..37fcbd34 100644 --- a/src/combinator/parser.rs +++ b/src/combinator/parser.rs @@ -542,7 +542,7 @@ where Ok((mut input, _)) => { let offset = input.offset_from(&checkpoint); input.reset(checkpoint); - let (input, recognized) = input.next_slice(offset); + let (input, recognized) = input.peek_slice(offset); Ok((input, recognized)) } Err(e) => Err(e), @@ -589,7 +589,7 @@ where Ok((mut input, result)) => { let offset = input.offset_from(&checkpoint); input.reset(checkpoint); - let (input, recognized) = input.next_slice(offset); + let (input, recognized) = input.peek_slice(offset); Ok((input, (result, recognized))) } Err(e) => Err(e), diff --git a/src/combinator/tests.rs b/src/combinator/tests.rs index 9a172160..480b94b0 100644 --- a/src/combinator/tests.rs +++ b/src/combinator/tests.rs @@ -561,7 +561,7 @@ fn alt_test() { } fn work(input: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> { - Ok(input.finish()) + Ok(input.peek_finish()) } #[allow(unused_variables)] diff --git a/src/parser.rs b/src/parser.rs index 5c3526ac..8e770527 100644 --- a/src/parser.rs +++ b/src/parser.rs @@ -284,7 +284,7 @@ pub trait Parser { /// let mut parser = separated_pair(alpha1.span(), ',', alpha1.span()); /// /// assert_eq!(parser.parse(Located::new("abcd,efgh")), Ok((0..4, 5..9))); - /// assert_eq!(parser.parse_next(Located::new("abcd;")),Err(ErrMode::Backtrack(Error::new(Located::new("abcd;").next_slice(4).0, ErrorKind::Verify)))); + /// assert_eq!(parser.parse_next(Located::new("abcd;")),Err(ErrMode::Backtrack(Error::new(Located::new("abcd;").peek_slice(4).0, ErrorKind::Verify)))); /// ``` fn span(self) -> Span where @@ -323,7 +323,7 @@ pub trait Parser { /// let mut consumed_parser = separated_pair(alpha1.value(1).with_span(), ',', alpha1.value(2).with_span()); /// /// assert_eq!(consumed_parser.parse(Located::new("abcd,efgh")), Ok(((1, 0..4), (2, 5..9)))); - /// assert_eq!(consumed_parser.parse_next(Located::new("abcd;")),Err(ErrMode::Backtrack(Error::new(Located::new("abcd;").next_slice(4).0, ErrorKind::Verify)))); + /// assert_eq!(consumed_parser.parse_next(Located::new("abcd;")),Err(ErrMode::Backtrack(Error::new(Located::new("abcd;").peek_slice(4).0, ErrorKind::Verify)))); /// /// // the second output (representing the consumed input) /// // should be the same as that of the `span` parser. diff --git a/src/stream/mod.rs b/src/stream/mod.rs index fb03e767..01b2ac3a 100644 --- a/src/stream/mod.rs +++ b/src/stream/mod.rs @@ -429,7 +429,14 @@ pub trait Stream: fn eof_offset(&self) -> usize; /// Split off the next token from the input - fn next_token(&self) -> Option<(Self, Self::Token)>; + fn next_token(&mut self) -> Option; + /// Split off the next token from the input + #[inline(always)] + fn peek_token(&self) -> Option<(Self, Self::Token)> { + let mut peek = self.clone(); + let token = peek.next_token()?; + Some((peek, token)) + } /// Finds the offset of the next matching token fn offset_for

(&self, predicate: P) -> Option @@ -456,13 +463,27 @@ pub trait Stream: /// * Indexes must uphold invariants of the stream, like for `str` they must lie on UTF-8 /// sequence boundaries. /// - fn next_slice(&self, offset: usize) -> (Self, Self::Slice); + fn next_slice(&mut self, offset: usize) -> Self::Slice; + /// Split off a slice of tokens from the input + #[inline(always)] + fn peek_slice(&self, offset: usize) -> (Self, Self::Slice) { + let mut peek = self.clone(); + let slice = peek.next_slice(offset); + (peek, slice) + } /// Advance to the end of the stream #[inline(always)] - fn finish(&self) -> (Self, Self::Slice) { + fn finish(&mut self) -> Self::Slice { self.next_slice(self.eof_offset()) } + /// Advance to the end of the stream + #[inline(always)] + fn peek_finish(&self) -> (Self, Self::Slice) { + let mut peek = self.clone(); + let slice = peek.finish(); + (peek, slice) + } /// Save the current parse location within the stream fn checkpoint(&self) -> Self::Checkpoint; @@ -495,9 +516,10 @@ where } #[inline(always)] - fn next_token(&self) -> Option<(Self, Self::Token)> { - self.split_first() - .map(|(token, next)| (next, token.clone())) + fn next_token(&mut self) -> Option { + let (token, next) = self.split_first()?; + *self = next; + Some(token.clone()) } #[inline(always)] @@ -516,9 +538,10 @@ where } } #[inline(always)] - fn next_slice(&self, offset: usize) -> (Self, Self::Slice) { + fn next_slice(&mut self, offset: usize) -> Self::Slice { let (slice, next) = self.split_at(offset); - (next, slice) + *self = next; + slice } #[inline(always)] @@ -549,10 +572,11 @@ impl<'i> Stream for &'i str { } #[inline(always)] - fn next_token(&self) -> Option<(Self, Self::Token)> { + fn next_token(&mut self) -> Option { let c = self.chars().next()?; let offset = c.len(); - Some((&self[offset..], c)) + *self = &self[offset..]; + Some(c) } #[inline(always)] @@ -584,9 +608,10 @@ impl<'i> Stream for &'i str { } } #[inline(always)] - fn next_slice(&self, offset: usize) -> (Self, Self::Slice) { + fn next_slice(&mut self, offset: usize) -> Self::Slice { let (slice, next) = self.split_at(offset); - (next, slice) + *self = next; + slice } #[inline(always)] @@ -617,11 +642,13 @@ impl<'i> Stream for &'i Bytes { } #[inline(always)] - fn next_token(&self) -> Option<(Self, Self::Token)> { + fn next_token(&mut self) -> Option { if self.is_empty() { None } else { - Some((Bytes::from_bytes(&self[1..]), self[0])) + let token = self[0]; + *self = &self[1..]; + Some(token) } } @@ -641,9 +668,10 @@ impl<'i> Stream for &'i Bytes { } } #[inline(always)] - fn next_slice(&self, offset: usize) -> (Self, Self::Slice) { - let (next, slice) = (&self.0).next_slice(offset); - (Bytes::from_bytes(next), slice) + fn next_slice(&mut self, offset: usize) -> Self::Slice { + let (slice, next) = self.0.split_at(offset); + *self = Bytes::from_bytes(next); + slice } #[inline(always)] @@ -674,11 +702,13 @@ impl<'i> Stream for &'i BStr { } #[inline(always)] - fn next_token(&self) -> Option<(Self, Self::Token)> { + fn next_token(&mut self) -> Option { if self.is_empty() { None } else { - Some((BStr::from_bytes(&self[1..]), self[0])) + let token = self[0]; + *self = &self[1..]; + Some(token) } } @@ -698,9 +728,10 @@ impl<'i> Stream for &'i BStr { } } #[inline(always)] - fn next_slice(&self, offset: usize) -> (Self, Self::Slice) { - let (next, slice) = (&self.0).next_slice(offset); - (BStr::from_bytes(next), slice) + fn next_slice(&mut self, offset: usize) -> Self::Slice { + let (slice, next) = self.0.split_at(offset); + *self = BStr::from_bytes(next); + slice } #[inline(always)] @@ -742,7 +773,7 @@ where } #[inline(always)] - fn next_token(&self) -> Option<(Self, Self::Token)> { + fn next_token(&mut self) -> Option { next_bit(self) } @@ -766,11 +797,13 @@ where } } #[inline(always)] - fn next_slice(&self, offset: usize) -> (Self, Self::Slice) { + fn next_slice(&mut self, offset: usize) -> Self::Slice { let byte_offset = (offset + self.1) / 8; let end_offset = (offset + self.1) % 8; - let (i, s) = self.0.next_slice(byte_offset); - ((i, end_offset), (s, self.1, end_offset)) + let s = self.0.next_slice(byte_offset); + let start_offset = self.1; + self.1 = end_offset; + (s, start_offset, end_offset) } #[inline(always)] @@ -796,33 +829,36 @@ where { type Item = (usize, bool); fn next(&mut self) -> Option { - let (next, b) = next_bit(&self.i)?; + let b = next_bit(&mut self.i)?; let o = self.o; - self.i = next; self.o += 1; Some((o, b)) } } -fn next_bit(i: &(I, usize)) -> Option<((I, usize), bool)> +fn next_bit(i: &mut (I, usize)) -> Option where I: Stream, { if i.eof_offset() == 0 { return None; } + let offset = i.1; - let i = i.clone(); - let (next_i, byte) = i.0.next_token()?; - let bit = (byte >> i.1) & 0x1 == 0x1; + let mut next_i = i.0.clone(); + let byte = next_i.next_token()?; + let bit = (byte >> offset) & 0x1 == 0x1; - let next_offset = i.1 + 1; + let next_offset = offset + 1; if next_offset == 8 { - Some(((next_i, 0), bit)) + i.0 = next_i; + i.1 = 0; + Some(bit) } else { - Some(((i.0, next_offset), bit)) + i.1 = next_offset; + Some(bit) } } @@ -844,15 +880,8 @@ impl Stream for Located { } #[inline(always)] - fn next_token(&self) -> Option<(Self, Self::Token)> { - let (next, token) = self.input.next_token()?; - Some(( - Self { - initial: self.initial.clone(), - input: next, - }, - token, - )) + fn next_token(&mut self) -> Option { + self.input.next_token() } #[inline(always)] @@ -867,15 +896,8 @@ impl Stream for Located { self.input.offset_at(tokens) } #[inline(always)] - fn next_slice(&self, offset: usize) -> (Self, Self::Slice) { - let (next, slice) = self.input.next_slice(offset); - ( - Self { - initial: self.initial.clone(), - input: next, - }, - slice, - ) + fn next_slice(&mut self, offset: usize) -> Self::Slice { + self.input.next_slice(offset) } #[inline(always)] @@ -906,15 +928,8 @@ impl Stream for Stateful Option<(Self, Self::Token)> { - let (next, token) = self.input.next_token()?; - Some(( - Self { - input: next, - state: self.state.clone(), - }, - token, - )) + fn next_token(&mut self) -> Option { + self.input.next_token() } #[inline(always)] @@ -929,15 +944,8 @@ impl Stream for Stateful (Self, Self::Slice) { - let (next, slice) = self.input.next_slice(offset); - ( - Self { - input: next, - state: self.state.clone(), - }, - slice, - ) + fn next_slice(&mut self, offset: usize) -> Self::Slice { + self.input.next_slice(offset) } #[inline(always)] @@ -968,15 +976,8 @@ impl Stream for Partial { } #[inline(always)] - fn next_token(&self) -> Option<(Self, Self::Token)> { - let (next, token) = self.input.next_token()?; - Some(( - Partial { - input: next, - partial: self.partial, - }, - token, - )) + fn next_token(&mut self) -> Option { + self.input.next_token() } #[inline(always)] @@ -991,15 +992,8 @@ impl Stream for Partial { self.input.offset_at(tokens) } #[inline(always)] - fn next_slice(&self, offset: usize) -> (Self, Self::Slice) { - let (next, slice) = self.input.next_slice(offset); - ( - Partial { - input: next, - partial: self.partial, - }, - slice, - ) + fn next_slice(&mut self, offset: usize) -> Self::Slice { + self.input.next_slice(offset) } #[inline(always)] diff --git a/src/stream/tests.rs b/src/stream/tests.rs index 87ce19bd..e653ad9e 100644 --- a/src/stream/tests.rs +++ b/src/stream/tests.rs @@ -37,7 +37,7 @@ fn test_bit_stream_empty() { let actual = i.eof_offset(); assert_eq!(actual, 0); - let actual = i.next_token(); + let actual = i.peek_token(); assert_eq!(actual, None); let actual = i.offset_for(|b| b); @@ -46,7 +46,7 @@ fn test_bit_stream_empty() { let actual = i.offset_at(1); assert_eq!(actual, Err(Needed::new(1))); - let (actual_input, actual_slice) = i.next_slice(0); + let (actual_input, actual_slice) = i.peek_slice(0); assert_eq!(actual_input, (&b""[..], 0)); assert_eq!(actual_slice, (&b""[..], 0, 0)); } @@ -80,18 +80,18 @@ fn bit_stream_inner(byte_len: usize, start: usize) { let mut curr_i = i; let mut curr_offset = 0; - while let Some((next_i, _token)) = curr_i.next_token() { + while let Some((next_i, _token)) = curr_i.peek_token() { let to_offset = curr_i.offset_from(&i); assert_eq!(curr_offset, to_offset); - let (slice_i, _) = i.next_slice(curr_offset); + let (slice_i, _) = i.peek_slice(curr_offset); assert_eq!(curr_i, slice_i); let at_offset = i.offset_at(curr_offset).unwrap(); assert_eq!(curr_offset, at_offset); let eof_offset = curr_i.eof_offset(); - let (next_eof_i, eof_slice) = curr_i.next_slice(eof_offset); + let (next_eof_i, eof_slice) = curr_i.peek_slice(eof_offset); assert_eq!(next_eof_i, (&b""[..], 0)); let eof_slice_i = (eof_slice.0, eof_slice.1); assert_eq!(eof_slice_i, curr_i); diff --git a/src/token/mod.rs b/src/token/mod.rs index a7f1d019..96843e1c 100644 --- a/src/token/mod.rs +++ b/src/token/mod.rs @@ -63,7 +63,7 @@ where I: StreamIsPartial, I: Stream, { - input.next_token().ok_or_else(|| { + input.peek_token().ok_or_else(|| { if PARTIAL && input.is_partial() { ErrMode::Incomplete(Needed::new(1)) } else { @@ -143,7 +143,7 @@ where { let tag_len = t.slice_len(); match i.compare(t) { - CompareResult::Ok => Ok(i.next_slice(tag_len)), + CompareResult::Ok => Ok(i.peek_slice(tag_len)), CompareResult::Incomplete if PARTIAL && i.is_partial() => { Err(ErrMode::Incomplete(Needed::new(tag_len - i.eof_offset()))) } @@ -229,7 +229,7 @@ where let tag_len = t.slice_len(); match (i).compare_no_case(t) { - CompareResult::Ok => Ok(i.next_slice(tag_len)), + CompareResult::Ok => Ok(i.peek_slice(tag_len)), CompareResult::Incomplete if PARTIAL && i.is_partial() => { Err(ErrMode::Incomplete(Needed::new(tag_len - i.eof_offset()))) } @@ -566,7 +566,7 @@ where let offset = input .offset_for(predicate) .ok_or_else(|| ErrMode::Incomplete(Needed::new(1)))?; - Ok(input.next_slice(offset)) + Ok(input.peek_slice(offset)) } /// Looks for the first element of the input type for which the condition returns true @@ -589,7 +589,7 @@ where if offset == 0 { Err(ErrMode::from_error_kind(input.clone(), e)) } else { - Ok(input.next_slice(offset)) + Ok(input.peek_slice(offset)) } } @@ -607,7 +607,7 @@ where let offset = input .offset_for(predicate) .unwrap_or_else(|| input.eof_offset()); - Ok(input.next_slice(offset)) + Ok(input.peek_slice(offset)) } /// Looks for the first element of the input type for which the condition returns true @@ -630,7 +630,7 @@ where if offset == 0 { Err(ErrMode::from_error_kind(input.clone(), e)) } else { - Ok(input.next_slice(offset)) + Ok(input.peek_slice(offset)) } } @@ -655,18 +655,18 @@ where if processed < m { return Err(ErrMode::from_error_kind(input, ErrorKind::Slice)); } else { - return Ok(input.next_slice(offset)); + return Ok(input.peek_slice(offset)); } } else { if processed == n { - return Ok(input.next_slice(offset)); + return Ok(input.peek_slice(offset)); } final_count = processed + 1; } } if PARTIAL && input.is_partial() { if final_count == n { - Ok(input.finish()) + Ok(input.peek_finish()) } else { let needed = if m > input.eof_offset() { m - input.eof_offset() @@ -677,7 +677,7 @@ where } } else { if m <= final_count { - Ok(input.finish()) + Ok(input.peek_finish()) } else { Err(ErrMode::from_error_kind(input, ErrorKind::Slice)) } @@ -899,7 +899,7 @@ where I: Stream, { match i.offset_at(c) { - Ok(offset) => Ok(i.next_slice(offset)), + Ok(offset) => Ok(i.peek_slice(offset)), Err(e) if PARTIAL && i.is_partial() => Err(ErrMode::Incomplete(e)), Err(_needed) => Err(ErrMode::from_error_kind(i, ErrorKind::Slice)), } @@ -975,7 +975,7 @@ where T: SliceLen, { match i.find_slice(t) { - Some(offset) => Ok(i.next_slice(offset)), + Some(offset) => Ok(i.peek_slice(offset)), None if PARTIAL && i.is_partial() => Err(ErrMode::Incomplete(Needed::Unknown)), None => Err(ErrMode::from_error_kind(i, ErrorKind::Slice)), } @@ -1055,6 +1055,6 @@ where match i.find_slice(t) { None if PARTIAL && i.is_partial() => Err(ErrMode::Incomplete(Needed::Unknown)), None | Some(0) => Err(ErrMode::from_error_kind(i, ErrorKind::Slice)), - Some(offset) => Ok(i.next_slice(offset)), + Some(offset) => Ok(i.peek_slice(offset)), } } diff --git a/src/trace/internals.rs b/src/trace/internals.rs index c520cc79..77b2d277 100644 --- a/src/trace/internals.rs +++ b/src/trace/internals.rs @@ -89,7 +89,7 @@ pub fn start( let eof_offset = input.eof_offset(); let offset = input.offset_at(input_width).unwrap_or(eof_offset); - let (_, slice) = input.next_slice(offset); + let (_, slice) = input.peek_slice(offset); // The debug version of `slice` might be wider, either due to rendering one byte as two nibbles or // escaping in strings.