From 2aa4a82499d4becd2284cdb482213d541b8804dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 28 Apr 2024 16:29:10 +0200 Subject: Adding upstream version 86.0.1. Signed-off-by: Daniel Baumann --- third_party/rust/nom/src/multi/macros.rs | 988 ++++++++++++++++++++++++++++++ third_party/rust/nom/src/multi/mod.rs | 997 +++++++++++++++++++++++++++++++ 2 files changed, 1985 insertions(+) create mode 100644 third_party/rust/nom/src/multi/macros.rs create mode 100644 third_party/rust/nom/src/multi/mod.rs (limited to 'third_party/rust/nom/src/multi') diff --git a/third_party/rust/nom/src/multi/macros.rs b/third_party/rust/nom/src/multi/macros.rs new file mode 100644 index 0000000000..10b66b8424 --- /dev/null +++ b/third_party/rust/nom/src/multi/macros.rs @@ -0,0 +1,988 @@ +//! Parsers for applying parsers multiple times + +/// `separated_list!(I -> IResult, I -> IResult) => I -> IResult>` +/// separated_list(sep, X) returns a Vec +/// +/// ```rust +/// # #[macro_use] extern crate nom; +/// # use nom::{Err, error::ErrorKind, Needed, IResult}; +/// use nom::multi::separated_list; +/// use nom::bytes::complete::tag; +/// +/// # fn main() { +/// named!(parser<&str, Vec<&str>>, separated_list!(tag("|"), tag("abc"))); +/// +/// 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(""), Ok(("", vec![]))); +/// assert_eq!(parser("def|abc"), Ok(("def|abc", vec![]))); +/// # } +/// ``` +#[cfg(feature = "alloc")] +#[macro_export(local_inner_macros)] +macro_rules! separated_list( + ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => ( + separated_list!($i, |i| $submac!(i, $($args)*), |i| $submac2!(i, $($args2)*)) + ); + + ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => ( + separated_list!($i, |i| $submac!(i, $($args)*), $g); + ); + + ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => ( + separated_list!($i, $f, |i| $submac!(i, $($args)*)); + ); + + ($i:expr, $f:expr, $g:expr) => ( + $crate::multi::separated_listc($i, $f, $g) + ); +); + +/// `separated_nonempty_list!(I -> IResult, I -> IResult) => I -> IResult>` +/// separated_nonempty_list(sep, X) returns a Vec +/// +/// it will return an error if there is no element in the list +/// ```rust +/// # #[macro_use] extern crate nom; +/// # use nom::{Err, error::ErrorKind, Needed, IResult}; +/// use nom::multi::separated_nonempty_list; +/// use nom::bytes::complete::tag; +/// +/// # fn main() { +/// named!(parser<&str, Vec<&str>>, separated_nonempty_list!(tag("|"), tag("abc"))); +/// +/// 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(Err::Error(("", ErrorKind::Tag)))); +/// assert_eq!(parser("def|abc"), Err(Err::Error(("def|abc", ErrorKind::Tag)))); +/// # } +/// ``` +#[cfg(feature = "alloc")] +#[macro_export(local_inner_macros)] +macro_rules! separated_nonempty_list( + ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => ( + separated_nonempty_list!($i, |i| $submac!(i, $($args)*), |i| $submac2!(i, $($args2)*)) + ); + + ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => ( + separated_nonempty_list!($i, |i| $submac!(i, $($args)*), $g); + ); + + ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => ( + separated_nonempty_list!($i, $f, |i| $submac!(i, $($args)*)); + ); + + ($i:expr, $f:expr, $g:expr) => ( + $crate::multi::separated_nonempty_listc($i, $f, $g) + ); +); + +/// `many0!(I -> IResult) => I -> IResult>` +/// Applies the parser 0 or more times and returns the list of results in a Vec. +/// +/// The embedded parser may return Incomplete. +/// +/// `many0` will only return `Error` if the embedded parser does not consume any input +/// (to avoid infinite loops). +/// +/// ``` +/// # #[macro_use] extern crate nom; +/// # fn main() { +/// named!(multi<&[u8], Vec<&[u8]> >, many0!( tag!( "abcd" ) ) ); +/// +/// let a = b"abcdabcdefgh"; +/// let b = b"azerty"; +/// +/// let res = vec![&b"abcd"[..], &b"abcd"[..]]; +/// assert_eq!(multi(&a[..]),Ok((&b"efgh"[..], res))); +/// assert_eq!(multi(&b[..]),Ok((&b"azerty"[..], Vec::new()))); +/// # } +/// ``` +/// +#[cfg(feature = "alloc")] +#[macro_export(local_inner_macros)] +macro_rules! many0( + ($i:expr, $submac:ident!( $($args:tt)* )) => ( + many0!($i, |i| $submac!(i, $($args)*)) + ); + ($i:expr, $f:expr) => ( + $crate::multi::many0c($i, $f) + ); +); + +/// `many1!(I -> IResult) => I -> IResult>` +/// Applies the parser 1 or more times and returns the list of results in a Vec +/// +/// the embedded parser may return Incomplete +/// +/// ``` +/// # #[macro_use] extern crate nom; +/// # use nom::Err; +/// # use nom::error::ErrorKind; +/// # fn main() { +/// named!(multi<&[u8], Vec<&[u8]> >, many1!( tag!( "abcd" ) ) ); +/// +/// let a = b"abcdabcdefgh"; +/// let b = b"azerty"; +/// +/// let res = vec![&b"abcd"[..], &b"abcd"[..]]; +/// assert_eq!(multi(&a[..]), Ok((&b"efgh"[..], res))); +/// assert_eq!(multi(&b[..]), Err(Err::Error(error_position!(&b[..], ErrorKind::Tag)))); +/// # } +/// ``` +#[cfg(feature = "alloc")] +#[macro_export(local_inner_macros)] +macro_rules! many1( + ($i:expr, $submac:ident!( $($args:tt)* )) => ( + many1!($i, |i| $submac!(i, $($args)*)) + ); + ($i:expr, $f:expr) => ( + $crate::multi::many1c($i, $f) + ); +); + +/// `many_till!(I -> IResult, I -> IResult) => I -> IResult, P)>` +/// Applies the first parser until the second applies. Returns a tuple containing the list +/// of results from the first in a Vec and the result of the second. +/// +/// The first embedded parser may return Incomplete +/// +/// ``` +/// # #[macro_use] extern crate nom; +/// # use nom::Err; +/// # use nom::error::ErrorKind; +/// # fn main() { +/// named!(multi<&[u8], (Vec<&[u8]>, &[u8]) >, many_till!( tag!( "abcd" ), tag!( "efgh" ) ) ); +/// +/// let a = b"abcdabcdefghabcd"; +/// let b = b"efghabcd"; +/// let c = b"azerty"; +/// +/// let res_a = (vec![&b"abcd"[..], &b"abcd"[..]], &b"efgh"[..]); +/// let res_b: (Vec<&[u8]>, &[u8]) = (Vec::new(), &b"efgh"[..]); +/// assert_eq!(multi(&a[..]),Ok((&b"abcd"[..], res_a))); +/// assert_eq!(multi(&b[..]),Ok((&b"abcd"[..], res_b))); +/// assert_eq!(multi(&c[..]), Err(Err::Error(error_node_position!(&c[..], ErrorKind::ManyTill, +/// error_position!(&c[..], ErrorKind::Tag))))); +/// # } +/// ``` +#[cfg(feature = "alloc")] +#[macro_export(local_inner_macros)] +macro_rules! many_till( + ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => ( + many_till!($i, |i| $submac!(i, $($args)*), |i| $submac2!(i, $($args2)*)) + ); + + ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => ( + many_till!($i, |i| $submac!(i, $($args)*), $g); + ); + + ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => ( + many_till!($i, $f, |i| $submac!(i, $($args)*)); + ); + + ($i:expr, $f:expr, $g:expr) => ( + $crate::multi::many_tillc($i, $f, $g) + ); +); + +/// `many_m_n!(usize, usize, I -> IResult) => I -> IResult>` +/// Applies the parser between m and n times (n included) and returns the list of +/// results in a Vec +/// +/// the embedded parser may return Incomplete +/// +/// ``` +/// # #[macro_use] extern crate nom; +/// # use nom::Err; +/// # use nom::error::ErrorKind; +/// # fn main() { +/// named!(multi<&[u8], Vec<&[u8]> >, many_m_n!(2, 4, tag!( "abcd" ) ) ); +/// +/// let a = b"abcdefgh"; +/// let b = b"abcdabcdefgh"; +/// let c = b"abcdabcdabcdabcdabcdefgh"; +/// +/// assert_eq!(multi(&a[..]), Err(Err::Error(error_position!(&b"efgh"[..], ErrorKind::Tag)))); +/// let res = vec![&b"abcd"[..], &b"abcd"[..]]; +/// assert_eq!(multi(&b[..]),Ok((&b"efgh"[..], res))); +/// let res2 = vec![&b"abcd"[..], &b"abcd"[..], &b"abcd"[..], &b"abcd"[..]]; +/// assert_eq!(multi(&c[..]),Ok((&b"abcdefgh"[..], res2))); +/// # } +/// ``` +#[cfg(feature = "alloc")] +#[macro_export(local_inner_macros)] +macro_rules! many_m_n( + ($i:expr, $m:expr, $n: expr, $submac:ident!( $($args:tt)* )) => ( + many_m_n!($i, $m, $n, |i| $submac!(i, $($args)*)) + ); + ($i:expr, $m:expr, $n: expr, $f:expr) => ( + $crate::multi::many_m_nc($i, $m, $n, $f) + ); +); + +/// `many0_count!(I -> IResult) => I -> IResult` +/// Applies the parser 0 or more times and returns the number of times the parser was applied. +/// +/// `many0_count` will only return `Error` if the embedded parser does not consume any input +/// (to avoid infinite loops). +/// +/// ``` +/// #[macro_use] extern crate nom; +/// use nom::character::streaming::digit1; +/// +/// named!(number<&[u8], usize>, many0_count!(pair!(digit1, tag!(",")))); +/// +/// fn main() { +/// assert_eq!(number(&b"123,45,abc"[..]), Ok((&b"abc"[..], 2))); +/// } +/// ``` +/// +#[macro_export] +macro_rules! many0_count { + ($i:expr, $submac:ident!( $($args:tt)* )) => ( + $crate::multi::many0_countc($i, |i| $submac!(i, $($args)*)) + ); + + ($i:expr, $f:expr) => ( + $crate::multi::many0_countc($i, $f) + ); +} + +/// `many1_count!(I -> IResult) => I -> IResult` +/// Applies the parser 1 or more times and returns the number of times the parser was applied. +/// +/// ``` +/// #[macro_use] extern crate nom; +/// use nom::character::streaming::digit1; +/// +/// named!(number<&[u8], usize>, many1_count!(pair!(digit1, tag!(",")))); +/// +/// fn main() { +/// assert_eq!(number(&b"123,45,abc"[..]), Ok((&b"abc"[..], 2))); +/// } +/// ``` +/// +#[macro_export] +macro_rules! many1_count { + ($i:expr, $submac:ident!( $($args:tt)* )) => ( + $crate::multi::many1_countc($i, |i| $submac!(i, $($args)*)) + ); + + ($i:expr, $f:expr) => ( + $crate::multi::many1_countc($i, $f) + ); +} + +/// `count!(I -> IResult, nb) => I -> IResult>` +/// Applies the child parser a specified number of times +/// +/// ``` +/// # #[macro_use] extern crate nom; +/// # use nom::Err; +/// # use nom::error::ErrorKind; +/// # fn main() { +/// named!(counter< Vec<&[u8]> >, count!( tag!( "abcd" ), 2 ) ); +/// +/// let a = b"abcdabcdabcdef"; +/// let b = b"abcdefgh"; +/// let res = vec![&b"abcd"[..], &b"abcd"[..]]; +/// +/// assert_eq!(counter(&a[..]),Ok((&b"abcdef"[..], res))); +/// assert_eq!(counter(&b[..]), Err(Err::Error(error_position!(&b"efgh"[..], ErrorKind::Tag)))); +/// # } +/// ``` +/// +#[cfg(feature = "alloc")] +#[macro_export(local_inner_macros)] +macro_rules! count( + ($i:expr, $submac:ident!( $($args:tt)* ), $count: expr) => ( + count!($i, |i| $submac!(i, $($args)*), $count) + ); + ($i:expr, $f:expr, $count: expr) => ( + $crate::multi::count($f, $count)($i) + ); +); + +/// `length_count!(I -> IResult, I -> IResult) => I -> IResult>` +/// gets a number from the first parser, then applies the second parser that many times +/// +/// ```rust +/// # #[macro_use] extern crate nom; +/// # use nom::{Err, Needed}; +/// # use nom::error::ErrorKind; +/// use nom::number::complete::be_u8; +/// # fn main() { +/// named!(parser>, length_count!(be_u8, tag!("abc"))); +/// +/// assert_eq!(parser(&b"\x02abcabcabc"[..]), Ok(((&b"abc"[..], vec![&b"abc"[..], &b"abc"[..]])))); +/// assert_eq!(parser(&b"\x04abcabcabc"[..]), Err(Err::Incomplete(Needed::Size(3)))); +/// # } +/// ``` +#[macro_export(local_inner_macros)] +#[cfg(feature = "alloc")] +macro_rules! length_count( + ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => ( + { + use $crate::lib::std::result::Result::*; + use $crate::Err; + + match $submac!($i, $($args)*) { + Err(e) => Err(Err::convert(e)), + Ok((i, o)) => { + match count!(i, $submac2!($($args2)*), o as usize) { + Err(e) => Err(Err::convert(e)), + Ok((i2, o2)) => Ok((i2, o2)) + } + } + } + } + ); + + ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => ( + length_count!($i, $submac!($($args)*), call!($g)); + ); + + ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => ( + length_count!($i, call!($f), $submac!($($args)*)); + ); + + ($i:expr, $f:expr, $g:expr) => ( + length_count!($i, call!($f), call!($g)); + ); +); + +/// `length_data!(I -> IResult) => O` +/// +/// `length_data` gets a number from the first parser, then takes a subslice of the input +/// of that size and returns that subslice +/// +/// ```rust +/// # #[macro_use] extern crate nom; +/// # use nom::{Err, Needed}; +/// # use nom::error::ErrorKind; +/// use nom::number::complete::be_u8; +/// # fn main() { +/// named!(parser, length_data!(be_u8)); +/// +/// assert_eq!(parser(&b"\x06abcabcabc"[..]), Ok((&b"abc"[..], &b"abcabc"[..]))); +/// assert_eq!(parser(&b"\x06abc"[..]), Err(Err::Incomplete(Needed::Size(6)))); +/// # } +/// ``` +#[macro_export(local_inner_macros)] +macro_rules! length_data( + ($i:expr, $submac:ident!( $($args:tt)* )) => ({ + $crate::multi::length_data(|i| $submac!(i, $($args)*))($i) + }); + + ($i:expr, $f:expr) => ( + $crate::multi::length_data($f)($i) + ); +); + +/// `length_value!(I -> IResult, I -> IResult) => I -> IResult` +/// +/// Gets a number from the first parser, takes a subslice of the input of that size, +/// then applies the second parser on that subslice. If the second parser returns +/// `Incomplete`, `length_value` will return an error +/// +/// ```rust +/// # #[macro_use] extern crate nom; +/// # use nom::{Err, Needed}; +/// # use nom::error::ErrorKind; +/// use nom::number::complete::be_u8; +/// use nom::character::complete::alpha0; +/// use nom::bytes::complete::tag; +/// # fn main() { +/// named!(parser, length_value!(be_u8, alpha0)); +/// +/// assert_eq!(parser(&b"\x06abcabcabc"[..]), Ok((&b"abc"[..], &b"abcabc"[..]))); +/// assert_eq!(parser(&b"\x06abc"[..]), Err(Err::Incomplete(Needed::Size(6)))); +/// # } +/// ``` +#[macro_export(local_inner_macros)] +macro_rules! length_value( + ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => ( + length_value!($i, |i| $submac!(i, $($args)*), |i| $submac2!(i, $($args2)*)) + ); + + ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => ( + length_value!($i, |i| $submac!(i, $($args)*), $g); + ); + + ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => ( + length_value!($i, $f, |i| $submac!(i, $($args)*)); + ); + + ($i:expr, $f:expr, $g:expr) => ( + $crate::multi::length_valuec($i, $f, $g); + ); +); + +/// `fold_many0!(I -> IResult, R, Fn(R, O) -> R) => I -> IResult` +/// Applies the parser 0 or more times and folds the list of return values +/// +/// the embedded parser may return Incomplete +/// +/// ``` +/// # #[macro_use] extern crate nom; +/// # fn main() { +/// named!(multi<&[u8], Vec<&[u8]> >, +/// fold_many0!( tag!( "abcd" ), Vec::new(), |mut acc: Vec<_>, item| { +/// acc.push(item); +/// acc +/// })); +/// +/// let a = b"abcdabcdefgh"; +/// let b = b"azerty"; +/// +/// let res = vec![&b"abcd"[..], &b"abcd"[..]]; +/// assert_eq!(multi(&a[..]),Ok((&b"efgh"[..], res))); +/// assert_eq!(multi(&b[..]),Ok((&b"azerty"[..], Vec::new()))); +/// # } +/// ``` +/// 0 or more +#[macro_export(local_inner_macros)] +macro_rules! fold_many0( + ($i:expr, $submac:ident!( $($args:tt)* ), $init:expr, $fold_f:expr) => ( + fold_many0!($i, |i| $submac!(i, $($args)*), $init, $fold_f) + ); + ($i:expr, $f:expr, $init:expr, $fold_f:expr) => ( + $crate::multi::fold_many0($f, $init, $fold_f)($i) + ); +); + +/// `fold_many1!(I -> IResult, R, Fn(R, O) -> R) => I -> IResult` +/// Applies the parser 1 or more times and folds the list of return values +/// +/// the embedded parser may return Incomplete +/// +/// ``` +/// # #[macro_use] extern crate nom; +/// # use nom::Err; +/// # use nom::error::ErrorKind; +/// # fn main() { +/// named!(multi<&[u8], Vec<&[u8]> >, +/// fold_many1!( tag!( "abcd" ), Vec::new(), |mut acc: Vec<_>, item| { +/// acc.push(item); +/// acc +/// })); +/// +/// let a = b"abcdabcdefgh"; +/// let b = b"azerty"; +/// +/// let res = vec![&b"abcd"[..], &b"abcd"[..]]; +/// assert_eq!(multi(&a[..]),Ok((&b"efgh"[..], res))); +/// assert_eq!(multi(&b[..]), Err(Err::Error(error_position!(&b[..], ErrorKind::Many1)))); +/// # } +/// ``` +#[macro_export(local_inner_macros)] +macro_rules! fold_many1( + ($i:expr, $submac:ident!( $($args:tt)* ), $init:expr, $fold_f:expr) => ( + fold_many1!($i, |i| $submac!(i, $($args)*), $init, $fold_f) + ); + ($i:expr, $f:expr, $init:expr, $fold_f:expr) => ( + $crate::multi::fold_many1c($i, $f, $init, $fold_f) + ); + ($i:expr, $f:expr, $init:expr, $fold_f:expr) => ( + fold_many1!($i, call!($f), $init, $fold_f); + ); +); + +/// `fold_many_m_n!(usize, usize, I -> IResult, R, Fn(R, O) -> R) => I -> IResult` +/// Applies the parser between m and n times (n included) and folds the list of return value +/// +/// the embedded parser may return Incomplete +/// +/// ``` +/// # #[macro_use] extern crate nom; +/// # use nom::Err; +/// # use nom::error::ErrorKind; +/// # fn main() { +/// named!(multi<&[u8], Vec<&[u8]> >, +/// fold_many_m_n!(2, 4, tag!( "abcd" ), Vec::new(), |mut acc: Vec<_>, item| { +/// acc.push(item); +/// acc +/// })); +/// +/// let a = b"abcdefgh"; +/// let b = b"abcdabcdefgh"; +/// let c = b"abcdabcdabcdabcdabcdefgh"; +/// +/// assert_eq!(multi(&a[..]), Err(Err::Error(error_position!(&a[..], ErrorKind::ManyMN)))); +/// let res = vec![&b"abcd"[..], &b"abcd"[..]]; +/// assert_eq!(multi(&b[..]),Ok((&b"efgh"[..], res))); +/// let res2 = vec![&b"abcd"[..], &b"abcd"[..], &b"abcd"[..], &b"abcd"[..]]; +/// assert_eq!(multi(&c[..]),Ok((&b"abcdefgh"[..], res2))); +/// # } +/// ``` +#[macro_export(local_inner_macros)] +macro_rules! fold_many_m_n( + ($i:expr, $m:expr, $n:expr, $submac:ident!( $($args:tt)* ), $init:expr, $fold_f:expr) => ( + fold_many_m_n!($i, $m, $n, |i| $submac!(i, $($args)*), $init, $fold_f) + ); + ($i:expr, $m:expr, $n:expr, $f:expr, $init:expr, $fold_f:expr) => ( + $crate::multi::fold_many_m_nc($i, $m, $n, $f, $init, $fold_f) + ); +); + +#[cfg(test)] +mod tests { + use crate::internal::{Err, IResult, Needed}; + use crate::error::ParseError; + use crate::lib::std::str::{self, FromStr}; + #[cfg(feature = "alloc")] + use crate::lib::std::vec::Vec; + use crate::character::streaming::digit1 as digit; + use crate::number::streaming::{be_u16, be_u8}; + use crate::error::ErrorKind; + + // reproduce the tag and take macros, because of module import order + macro_rules! tag ( + ($i:expr, $inp: expr) => ( + { + #[inline(always)] + fn as_bytes(b: &T) -> &[u8] { + b.as_bytes() + } + + let expected = $inp; + let bytes = as_bytes(&expected); + + tag_bytes!($i,bytes) + } + ); + ); + + macro_rules! tag_bytes ( + ($i:expr, $bytes: expr) => ( + { + use $crate::lib::std::cmp::min; + let len = $i.len(); + let blen = $bytes.len(); + let m = min(len, blen); + let reduced = &$i[..m]; + let b = &$bytes[..m]; + + let res: IResult<_,_,_> = if reduced != b { + Err($crate::Err::Error($crate::error::make_error($i, $crate::error::ErrorKind::Tag))) + } else if m < blen { + Err($crate::Err::Incomplete(Needed::Size(blen))) + } else { + Ok((&$i[blen..], reduced)) + }; + res + } + ); + ); + + #[test] + #[cfg(feature = "alloc")] + fn separated_list() { + named!(multi<&[u8],Vec<&[u8]> >, separated_list!(tag!(","), tag!("abcd"))); + named!(multi_empty<&[u8],Vec<&[u8]> >, separated_list!(tag!(","), tag!(""))); + named!(multi_longsep<&[u8],Vec<&[u8]> >, separated_list!(tag!(".."), tag!("abcd"))); + + let a = &b"abcdef"[..]; + let b = &b"abcd,abcdef"[..]; + let c = &b"azerty"[..]; + let d = &b",,abc"[..]; + let e = &b"abcd,abcd,ef"[..]; + let f = &b"abc"[..]; + let g = &b"abcd."[..]; + let h = &b"abcd,abc"[..]; + + let res1 = vec![&b"abcd"[..]]; + assert_eq!(multi(a), Ok((&b"ef"[..], res1))); + let res2 = vec![&b"abcd"[..], &b"abcd"[..]]; + assert_eq!(multi(b), Ok((&b"ef"[..], res2))); + assert_eq!(multi(c), Ok((&b"azerty"[..], Vec::new()))); + assert_eq!(multi_empty(d), Err(Err::Error(error_position!(d, ErrorKind::SeparatedList)))); + //let res3 = vec![&b""[..], &b""[..], &b""[..]]; + //assert_eq!(multi_empty(d),Ok((&b"abc"[..], res3))); + let res4 = vec![&b"abcd"[..], &b"abcd"[..]]; + assert_eq!(multi(e), Ok((&b",ef"[..], res4))); + + assert_eq!(multi(f), Err(Err::Incomplete(Needed::Size(4)))); + assert_eq!(multi_longsep(g), Err(Err::Incomplete(Needed::Size(2)))); + assert_eq!(multi(h), Err(Err::Incomplete(Needed::Size(4)))); + } + + #[test] + #[cfg(feature = "alloc")] + fn separated_nonempty_list() { + named!(multi<&[u8],Vec<&[u8]> >, separated_nonempty_list!(tag!(","), tag!("abcd"))); + named!(multi_longsep<&[u8],Vec<&[u8]> >, separated_nonempty_list!(tag!(".."), tag!("abcd"))); + + let a = &b"abcdef"[..]; + let b = &b"abcd,abcdef"[..]; + let c = &b"azerty"[..]; + let d = &b"abcd,abcd,ef"[..]; + + let f = &b"abc"[..]; + let g = &b"abcd."[..]; + let h = &b"abcd,abc"[..]; + + let res1 = vec![&b"abcd"[..]]; + assert_eq!(multi(a), Ok((&b"ef"[..], res1))); + let res2 = vec![&b"abcd"[..], &b"abcd"[..]]; + assert_eq!(multi(b), Ok((&b"ef"[..], res2))); + assert_eq!(multi(c), Err(Err::Error(error_position!(c, ErrorKind::Tag)))); + let res3 = vec![&b"abcd"[..], &b"abcd"[..]]; + assert_eq!(multi(d), Ok((&b",ef"[..], res3))); + + assert_eq!(multi(f), Err(Err::Incomplete(Needed::Size(4)))); + assert_eq!(multi_longsep(g), Err(Err::Incomplete(Needed::Size(2)))); + assert_eq!(multi(h), Err(Err::Incomplete(Needed::Size(4)))); + } + + #[test] + #[cfg(feature = "alloc")] + fn many0() { + named!(tag_abcd, tag!("abcd")); + named!(tag_empty, tag!("")); + named!( multi<&[u8],Vec<&[u8]> >, many0!(tag_abcd) ); + named!( multi_empty<&[u8],Vec<&[u8]> >, many0!(tag_empty) ); + + assert_eq!(multi(&b"abcdef"[..]), Ok((&b"ef"[..], vec![&b"abcd"[..]]))); + assert_eq!(multi(&b"abcdabcdefgh"[..]), Ok((&b"efgh"[..], vec![&b"abcd"[..], &b"abcd"[..]]))); + assert_eq!(multi(&b"azerty"[..]), Ok((&b"azerty"[..], Vec::new()))); + assert_eq!(multi(&b"abcdab"[..]), Err(Err::Incomplete(Needed::Size(4)))); + assert_eq!(multi(&b"abcd"[..]), Err(Err::Incomplete(Needed::Size(4)))); + assert_eq!(multi(&b""[..]), Err(Err::Incomplete(Needed::Size(4)))); + assert_eq!( + multi_empty(&b"abcdef"[..]), + Err(Err::Error(error_position!(&b"abcdef"[..], ErrorKind::Many0))) + ); + } + + #[cfg(nightly)] + use test::Bencher; + + #[cfg(nightly)] + #[bench] + fn many0_bench(b: &mut Bencher) { + named!(multi<&[u8],Vec<&[u8]> >, many0!(tag!("abcd"))); + b.iter(|| multi(&b"abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd"[..])); + } + + #[test] + #[cfg(feature = "alloc")] + fn many1() { + named!(multi<&[u8],Vec<&[u8]> >, many1!(tag!("abcd"))); + + let a = &b"abcdef"[..]; + let b = &b"abcdabcdefgh"[..]; + let c = &b"azerty"[..]; + let d = &b"abcdab"[..]; + + let res1 = vec![&b"abcd"[..]]; + assert_eq!(multi(a), Ok((&b"ef"[..], res1))); + let res2 = vec![&b"abcd"[..], &b"abcd"[..]]; + assert_eq!(multi(b), Ok((&b"efgh"[..], res2))); + assert_eq!(multi(c), Err(Err::Error(error_position!(c, ErrorKind::Tag)))); + assert_eq!(multi(d), Err(Err::Incomplete(Needed::Size(4)))); + } + + #[test] + #[cfg(feature = "alloc")] + fn many_till() { + named!(multi<&[u8], (Vec<&[u8]>, &[u8]) >, many_till!( tag!( "abcd" ), tag!( "efgh" ) ) ); + + let a = b"abcdabcdefghabcd"; + let b = b"efghabcd"; + let c = b"azerty"; + + let res_a = (vec![&b"abcd"[..], &b"abcd"[..]], &b"efgh"[..]); + let res_b: (Vec<&[u8]>, &[u8]) = (Vec::new(), &b"efgh"[..]); + assert_eq!(multi(&a[..]), Ok((&b"abcd"[..], res_a))); + assert_eq!(multi(&b[..]), Ok((&b"abcd"[..], res_b))); + assert_eq!( + multi(&c[..]), + Err(Err::Error(error_node_position!( + &c[..], + ErrorKind::ManyTill, + error_position!(&c[..], ErrorKind::Tag) + ))) + ); + } + + #[test] + #[cfg(feature = "std")] + fn infinite_many() { + fn tst(input: &[u8]) -> IResult<&[u8], &[u8]> { + println!("input: {:?}", input); + Err(Err::Error(error_position!(input, ErrorKind::Tag))) + } + + // should not go into an infinite loop + named!(multi0<&[u8],Vec<&[u8]> >, many0!(tst)); + let a = &b"abcdef"[..]; + assert_eq!(multi0(a), Ok((a, Vec::new()))); + + named!(multi1<&[u8],Vec<&[u8]> >, many1!(tst)); + let a = &b"abcdef"[..]; + assert_eq!(multi1(a), Err(Err::Error(error_position!(a, ErrorKind::Tag)))); + } + + #[test] + #[cfg(feature = "alloc")] + fn many_m_n() { + named!(multi<&[u8],Vec<&[u8]> >, many_m_n!(2, 4, tag!("Abcd"))); + + let a = &b"Abcdef"[..]; + let b = &b"AbcdAbcdefgh"[..]; + let c = &b"AbcdAbcdAbcdAbcdefgh"[..]; + let d = &b"AbcdAbcdAbcdAbcdAbcdefgh"[..]; + let e = &b"AbcdAb"[..]; + + assert_eq!(multi(a), Err(Err::Error(error_position!(&b"ef"[..], ErrorKind::Tag)))); + let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]]; + assert_eq!(multi(b), Ok((&b"efgh"[..], res1))); + let res2 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]]; + assert_eq!(multi(c), Ok((&b"efgh"[..], res2))); + let res3 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]]; + assert_eq!(multi(d), Ok((&b"Abcdefgh"[..], res3))); + assert_eq!(multi(e), Err(Err::Incomplete(Needed::Size(4)))); + } + + #[test] + #[cfg(feature = "alloc")] + fn count() { + const TIMES: usize = 2; + named!(tag_abc, tag!("abc")); + named!( cnt_2<&[u8], Vec<&[u8]> >, count!(tag_abc, TIMES ) ); + + assert_eq!(cnt_2(&b"abcabcabcdef"[..]), Ok((&b"abcdef"[..], vec![&b"abc"[..], &b"abc"[..]]))); + assert_eq!(cnt_2(&b"ab"[..]), Err(Err::Incomplete(Needed::Size(3)))); + assert_eq!(cnt_2(&b"abcab"[..]), Err(Err::Incomplete(Needed::Size(3)))); + assert_eq!(cnt_2(&b"xxx"[..]), Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))); + assert_eq!( + cnt_2(&b"xxxabcabcdef"[..]), + Err(Err::Error(error_position!(&b"xxxabcabcdef"[..], ErrorKind::Tag))) + ); + assert_eq!( + cnt_2(&b"abcxxxabcdef"[..]), + Err(Err::Error(error_position!(&b"xxxabcdef"[..], ErrorKind::Tag))) + ); + } + + #[test] + #[cfg(feature = "alloc")] + fn count_zero() { + const TIMES: usize = 0; + named!(tag_abc, tag!("abc")); + named!( counter_2<&[u8], Vec<&[u8]> >, count!(tag_abc, TIMES ) ); + + let done = &b"abcabcabcdef"[..]; + let parsed_done = Vec::new(); + let rest = done; + let incomplete_1 = &b"ab"[..]; + let parsed_incompl_1 = Vec::new(); + let incomplete_2 = &b"abcab"[..]; + let parsed_incompl_2 = Vec::new(); + let error = &b"xxx"[..]; + let error_remain = &b"xxx"[..]; + let parsed_err = Vec::new(); + let error_1 = &b"xxxabcabcdef"[..]; + let parsed_err_1 = Vec::new(); + let error_1_remain = &b"xxxabcabcdef"[..]; + let error_2 = &b"abcxxxabcdef"[..]; + let parsed_err_2 = Vec::new(); + let error_2_remain = &b"abcxxxabcdef"[..]; + + assert_eq!(counter_2(done), Ok((rest, parsed_done))); + assert_eq!(counter_2(incomplete_1), Ok((incomplete_1, parsed_incompl_1))); + assert_eq!(counter_2(incomplete_2), Ok((incomplete_2, parsed_incompl_2))); + assert_eq!(counter_2(error), Ok((error_remain, parsed_err))); + assert_eq!(counter_2(error_1), Ok((error_1_remain, parsed_err_1))); + assert_eq!(counter_2(error_2), Ok((error_2_remain, parsed_err_2))); + } + + #[derive(Debug, Clone, PartialEq)] + pub struct NilError; + + impl From<(I,ErrorKind)> for NilError { + fn from(_: (I, ErrorKind)) -> Self { + NilError + } + } + + impl ParseError for NilError { + fn from_error_kind(_: I, _: ErrorKind) -> NilError { + NilError + } + fn append(_: I, _: ErrorKind, _: NilError) -> NilError { + NilError + } + } + + named!(pub number, map_res!( + map_res!( + digit, + str::from_utf8 + ), + FromStr::from_str + )); + + #[test] + #[cfg(feature = "alloc")] + fn length_count() { + named!(tag_abc, tag!(&b"abc"[..])); + named!( cnt<&[u8], Vec<&[u8]> >, length_count!(number, tag_abc) ); + + assert_eq!(cnt(&b"2abcabcabcdef"[..]), Ok((&b"abcdef"[..], vec![&b"abc"[..], &b"abc"[..]]))); + assert_eq!(cnt(&b"2ab"[..]), Err(Err::Incomplete(Needed::Size(3)))); + assert_eq!(cnt(&b"3abcab"[..]), Err(Err::Incomplete(Needed::Size(3)))); + assert_eq!(cnt(&b"xxx"[..]), Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Digit)))); + assert_eq!( + cnt(&b"2abcxxx"[..]), + Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag))) + ); + } + + #[test] + fn length_data() { + named!( take<&[u8], &[u8]>, length_data!(number) ); + + assert_eq!(take(&b"6abcabcabcdef"[..]), Ok((&b"abcdef"[..], &b"abcabc"[..]))); + assert_eq!(take(&b"3ab"[..]), Err(Err::Incomplete(Needed::Size(3)))); + assert_eq!(take(&b"xxx"[..]), Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Digit)))); + assert_eq!(take(&b"2abcxxx"[..]), Ok((&b"cxxx"[..], &b"ab"[..]))); + } + + #[test] + fn length_value_test() { + named!(length_value_1<&[u8], u16 >, length_value!(be_u8, be_u16)); + named!(length_value_2<&[u8], (u8, u8) >, length_value!(be_u8, tuple!(be_u8, be_u8))); + + let i1 = [0, 5, 6]; + assert_eq!(length_value_1(&i1), Err(Err::Error(error_position!(&b""[..], ErrorKind::Complete)))); + assert_eq!(length_value_2(&i1), Err(Err::Error(error_position!(&b""[..], ErrorKind::Complete)))); + + let i2 = [1, 5, 6, 3]; + assert_eq!( + length_value_1(&i2), + Err(Err::Error(error_position!(&i2[1..2], ErrorKind::Complete))) + ); + assert_eq!( + length_value_2(&i2), + Err(Err::Error(error_position!(&i2[1..2], ErrorKind::Complete))) + ); + + let i3 = [2, 5, 6, 3, 4, 5, 7]; + assert_eq!(length_value_1(&i3), Ok((&i3[3..], 1286))); + assert_eq!(length_value_2(&i3), Ok((&i3[3..], (5, 6)))); + + let i4 = [3, 5, 6, 3, 4, 5]; + assert_eq!(length_value_1(&i4), Ok((&i4[4..], 1286))); + assert_eq!(length_value_2(&i4), Ok((&i4[4..], (5, 6)))); + } + + #[test] + #[cfg(feature = "alloc")] + fn fold_many0() { + fn fold_into_vec(mut acc: Vec, item: T) -> Vec { + acc.push(item); + acc + }; + named!(tag_abcd, tag!("abcd")); + named!(tag_empty, tag!("")); + named!( multi<&[u8],Vec<&[u8]> >, fold_many0!(tag_abcd, Vec::new(), fold_into_vec) ); + named!( multi_empty<&[u8],Vec<&[u8]> >, fold_many0!(tag_empty, Vec::new(), fold_into_vec) ); + + assert_eq!(multi(&b"abcdef"[..]), Ok((&b"ef"[..], vec![&b"abcd"[..]]))); + assert_eq!(multi(&b"abcdabcdefgh"[..]), Ok((&b"efgh"[..], vec![&b"abcd"[..], &b"abcd"[..]]))); + assert_eq!(multi(&b"azerty"[..]), Ok((&b"azerty"[..], Vec::new()))); + assert_eq!(multi(&b"abcdab"[..]), Err(Err::Incomplete(Needed::Size(4)))); + assert_eq!(multi(&b"abcd"[..]), Err(Err::Incomplete(Needed::Size(4)))); + assert_eq!(multi(&b""[..]), Err(Err::Incomplete(Needed::Size(4)))); + assert_eq!( + multi_empty(&b"abcdef"[..]), + Err(Err::Error(error_position!(&b"abcdef"[..], ErrorKind::Many0))) + ); + } + + #[test] + #[cfg(feature = "alloc")] + fn fold_many1() { + fn fold_into_vec(mut acc: Vec, item: T) -> Vec { + acc.push(item); + acc + }; + named!(multi<&[u8],Vec<&[u8]> >, fold_many1!(tag!("abcd"), Vec::new(), fold_into_vec)); + + let a = &b"abcdef"[..]; + let b = &b"abcdabcdefgh"[..]; + let c = &b"azerty"[..]; + let d = &b"abcdab"[..]; + + let res1 = vec![&b"abcd"[..]]; + assert_eq!(multi(a), Ok((&b"ef"[..], res1))); + let res2 = vec![&b"abcd"[..], &b"abcd"[..]]; + assert_eq!(multi(b), Ok((&b"efgh"[..], res2))); + assert_eq!(multi(c), Err(Err::Error(error_position!(c, ErrorKind::Many1)))); + assert_eq!(multi(d), Err(Err::Incomplete(Needed::Size(4)))); + } + + #[test] + #[cfg(feature = "alloc")] + fn fold_many_m_n() { + fn fold_into_vec(mut acc: Vec, item: T) -> Vec { + acc.push(item); + acc + }; + named!(multi<&[u8],Vec<&[u8]> >, fold_many_m_n!(2, 4, tag!("Abcd"), Vec::new(), fold_into_vec)); + + let a = &b"Abcdef"[..]; + let b = &b"AbcdAbcdefgh"[..]; + let c = &b"AbcdAbcdAbcdAbcdefgh"[..]; + let d = &b"AbcdAbcdAbcdAbcdAbcdefgh"[..]; + let e = &b"AbcdAb"[..]; + + assert_eq!(multi(a), Err(Err::Error(error_position!(a, ErrorKind::ManyMN)))); + let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]]; + assert_eq!(multi(b), Ok((&b"efgh"[..], res1))); + let res2 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]]; + assert_eq!(multi(c), Ok((&b"efgh"[..], res2))); + let res3 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]]; + assert_eq!(multi(d), Ok((&b"Abcdefgh"[..], res3))); + assert_eq!(multi(e), Err(Err::Incomplete(Needed::Size(4)))); + } + + #[test] + fn many0_count() { + named!( + count0_nums(&[u8]) -> usize, + many0_count!(pair!(digit, tag!(","))) + ); + + assert_eq!(count0_nums(&b"123,junk"[..]), Ok((&b"junk"[..], 1))); + + assert_eq!(count0_nums(&b"123,45,junk"[..]), Ok((&b"junk"[..], 2))); + + assert_eq!(count0_nums(&b"1,2,3,4,5,6,7,8,9,0,junk"[..]), Ok((&b"junk"[..], 10))); + + assert_eq!(count0_nums(&b"hello"[..]), Ok((&b"hello"[..], 0))); + } + + #[test] + fn many1_count() { + named!( + count1_nums(&[u8]) -> usize, + many1_count!(pair!(digit, tag!(","))) + ); + + assert_eq!(count1_nums(&b"123,45,junk"[..]), Ok((&b"junk"[..], 2))); + + assert_eq!(count1_nums(&b"1,2,3,4,5,6,7,8,9,0,junk"[..]), Ok((&b"junk"[..], 10))); + + assert_eq!( + count1_nums(&b"hello"[..]), + Err(Err::Error(error_position!(&b"hello"[..], ErrorKind::Many1Count))) + ); + } + +} diff --git a/third_party/rust/nom/src/multi/mod.rs b/third_party/rust/nom/src/multi/mod.rs new file mode 100644 index 0000000000..e8f26dd771 --- /dev/null +++ b/third_party/rust/nom/src/multi/mod.rs @@ -0,0 +1,997 @@ +//! combinators applying their child parser multiple times + +#[macro_use] +mod macros; + +use crate::internal::{Err, IResult, Needed}; +use crate::error::ParseError; +use crate::traits::{InputLength, InputTake, ToUsize}; +#[cfg(feature = "alloc")] +use crate::lib::std::vec::Vec; +use crate::error::ErrorKind; + +/// Repeats the embedded parser until it fails +/// and returns the results in a `Vec`. +/// +/// # Arguments +/// * `f` The parser to apply. +/// +/// *Note*: if the parser passed to `many0` accepts empty inputs +/// (like `alpha0` or `digit0`), `many0` will return an error, +/// to prevent going into an infinite loop +/// +/// ```rust +/// # use nom::{Err, error::ErrorKind, Needed, IResult}; +/// use nom::multi::many0; +/// use nom::bytes::complete::tag; +/// +/// fn parser(s: &str) -> IResult<&str, Vec<&str>> { +/// many0(tag("abc"))(s) +/// } +/// +/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"]))); +/// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"]))); +/// assert_eq!(parser("123123"), Ok(("123123", vec![]))); +/// assert_eq!(parser(""), Ok(("", vec![]))); +/// ``` +#[cfg(feature = "alloc")] +pub fn many0(f: F) -> impl Fn(I) -> IResult, E> +where + I: Clone + PartialEq, + F: Fn(I) -> IResult, + E: ParseError, +{ + move |i: I| { + let mut acc = crate::lib::std::vec::Vec::with_capacity(4); + let mut i = i.clone(); + loop { + match f(i.clone()) { + Err(Err::Error(_)) => return Ok((i, acc)), + Err(e) => return Err(e), + Ok((i1, o)) => { + if i1 == i { + return Err(Err::Error(E::from_error_kind(i, ErrorKind::Many0))); + } + + i = i1; + acc.push(o); + } + } + } + } +} +// this implementation is used for type inference issues in macros +#[doc(hidden)] +#[cfg(feature = "alloc")] +pub fn many0c(input: I, f: F) -> IResult, E> +where + I: Clone + PartialEq, + F: Fn(I) -> IResult, + E: ParseError, +{ + many0(f)(input) +} + +/// Runs the embedded parser until it fails and +/// returns the results in a `Vec`. Fails if +/// the embedded parser does not produce at least +/// one result. +/// +/// # Arguments +/// * `f` The parser to apply. +/// +/// *Note*: if the parser passed to `many1` accepts empty inputs +/// (like `alpha0` or `digit0`), `many1` will return an error, +/// to prevent going into an infinite loop +/// +/// ```rust +/// # use nom::{Err, error::ErrorKind, Needed, IResult}; +/// use nom::multi::many1; +/// use nom::bytes::complete::tag; +/// +/// fn parser(s: &str) -> IResult<&str, Vec<&str>> { +/// many1(tag("abc"))(s) +/// } +/// +/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"]))); +/// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"]))); +/// assert_eq!(parser("123123"), Err(Err::Error(("123123", ErrorKind::Tag)))); +/// assert_eq!(parser(""), Err(Err::Error(("", ErrorKind::Tag)))); +/// ``` +#[cfg(feature = "alloc")] +pub fn many1(f: F) -> impl Fn(I) -> IResult, E> +where + I: Clone + PartialEq, + F: Fn(I) -> IResult, + E: ParseError, +{ + move |i: I| { + let mut i = i.clone(); + match f(i.clone()) { + Err(Err::Error(err)) => return Err(Err::Error(E::append(i, ErrorKind::Many1, err))), + Err(e) => return Err(e), + Ok((i1, o)) => { + let mut acc = crate::lib::std::vec::Vec::with_capacity(4); + acc.push(o); + i = i1; + + loop { + match f(i.clone()) { + Err(Err::Error(_)) => return Ok((i, acc)), + Err(e) => return Err(e), + Ok((i1, o)) => { + if i1 == i { + return Err(Err::Error(E::from_error_kind(i, ErrorKind::Many1))); + } + + i = i1; + acc.push(o); + } + } + } + } + } + } +} + +// this implementation is used for type inference issues in macros +#[doc(hidden)] +#[cfg(feature = "alloc")] +pub fn many1c(input: I, f: F) -> IResult, E> +where + I: Clone + Copy + PartialEq, + F: Fn(I) -> IResult, + E: ParseError, +{ + many1(f)(input) +} + +/// Applies the parser `f` until the parser `g` produces +/// a result. Returns a pair consisting of the results of +/// `f` in a `Vec` and the result of `g`. +/// ```rust +/// # use nom::{Err, error::ErrorKind, Needed, IResult}; +/// use nom::multi::many_till; +/// use nom::bytes::complete::tag; +/// +/// fn parser(s: &str) -> IResult<&str, (Vec<&str>, &str)> { +/// many_till(tag("abc"), tag("end"))(s) +/// }; +/// +/// assert_eq!(parser("abcabcend"), Ok(("", (vec!["abc", "abc"], "end")))); +/// assert_eq!(parser("abc123end"), Err(Err::Error(("123end", ErrorKind::Tag)))); +/// assert_eq!(parser("123123end"), Err(Err::Error(("123123end", ErrorKind::Tag)))); +/// assert_eq!(parser(""), Err(Err::Error(("", ErrorKind::Tag)))); +/// assert_eq!(parser("abcendefg"), Ok(("efg", (vec!["abc"], "end")))); +/// ``` +#[cfg(feature = "alloc")] +pub fn many_till(f: F, g: G) -> impl Fn(I) -> IResult, P), E> +where + I: Clone + PartialEq, + F: Fn(I) -> IResult, + G: Fn(I) -> IResult, + E: ParseError, +{ + move |i: I| { + let mut res = crate::lib::std::vec::Vec::new(); + let mut i = i.clone(); + loop { + match g(i.clone()) { + Ok((i1, o)) => return Ok((i1, (res, o))), + Err(Err::Error(_)) => { + match f(i.clone()) { + Err(Err::Error(err)) => + return Err(Err::Error(E::append(i, ErrorKind::ManyTill, err))), + Err(e) => return Err(e), + Ok((i1, o)) => { + // loop trip must always consume (otherwise infinite loops) + if i1 == i { + return Err(Err::Error(E::from_error_kind(i1, ErrorKind::ManyTill))); + } + + res.push(o); + i = i1; + } + } + }, + Err(e) => return Err(e), + } + } + } +} + +// this implementation is used for type inference issues in macros +#[doc(hidden)] +#[cfg(feature = "alloc")] +pub fn many_tillc(i: I, f: F, g: G) -> IResult, P), E> +where + I: Clone + PartialEq, + F: Fn(I) -> IResult, + G: Fn(I) -> IResult, + E: ParseError, +{ + many_till(f, g)(i) +} + +/// Alternates between two parsers to produce +/// a list of elements. +/// # Arguments +/// * `sep` Parses the separator between list elements. +/// * `f` Parses the elements of the list. +/// +/// ```rust +/// # use nom::{Err, error::ErrorKind, Needed, IResult}; +/// use nom::multi::separated_list; +/// use nom::bytes::complete::tag; +/// +/// fn parser(s: &str) -> IResult<&str, Vec<&str>> { +/// separated_list(tag("|"), tag("abc"))(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(""), Ok(("", vec![]))); +/// assert_eq!(parser("def|abc"), Ok(("def|abc", vec![]))); +/// ``` +#[cfg(feature = "alloc")] +pub fn separated_list(sep: G, f: F) -> impl Fn(I) -> IResult, E> +where + I: Clone + PartialEq, + F: Fn(I) -> IResult, + G: Fn(I) -> IResult, + E: ParseError, +{ + move |i: I| { + let mut res = Vec::new(); + let mut i = i.clone(); + + match f(i.clone()) { + Err(Err::Error(_)) => return Ok((i, res)), + Err(e) => return Err(e), + Ok((i1, o)) => { + if i1 == i { + return Err(Err::Error(E::from_error_kind(i1, ErrorKind::SeparatedList))); + } + + res.push(o); + i = i1; + } + } + + loop { + match sep(i.clone()) { + Err(Err::Error(_)) => return Ok((i, res)), + Err(e) => return Err(e), + Ok((i1, _)) => { + if i1 == i { + return Err(Err::Error(E::from_error_kind(i1, ErrorKind::SeparatedList))); + } + + match f(i1.clone()) { + Err(Err::Error(_)) => return Ok((i, res)), + Err(e) => return Err(e), + Ok((i2, o)) => { + if i2 == i { + return Err(Err::Error(E::from_error_kind(i2, ErrorKind::SeparatedList))); + } + + res.push(o); + i = i2; + } + } + } + } + } + } +} + +// this implementation is used for type inference issues in macros +#[doc(hidden)] +#[cfg(feature = "alloc")] +pub fn separated_listc(i: I, sep: G, f: F) -> IResult, E> +where + I: Clone + PartialEq, + F: Fn(I) -> IResult, + G: Fn(I) -> IResult, + E: ParseError, +{ + separated_list(sep, f)(i) +} + +/// Alternates between two parsers to produce +/// a list of elements. Fails if the element +/// parser does not produce at least one element. +/// # Arguments +/// * `sep` Parses the separator between list elements. +/// * `f` Parses the elements of the list. +/// ```rust +/// # #[macro_use] extern crate nom; +/// # use nom::{Err, error::ErrorKind, Needed, IResult}; +/// use nom::multi::separated_nonempty_list; +/// use nom::bytes::complete::tag; +/// +/// fn parser(s: &str) -> IResult<&str, Vec<&str>> { +/// separated_nonempty_list(tag("|"), tag("abc"))(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(Err::Error(("", ErrorKind::Tag)))); +/// assert_eq!(parser("def|abc"), Err(Err::Error(("def|abc", ErrorKind::Tag)))); +/// ``` +#[cfg(feature = "alloc")] +pub fn separated_nonempty_list(sep: G, f: F) -> impl Fn(I) -> IResult, E> +where + I: Clone + PartialEq, + F: Fn(I) -> IResult, + G: Fn(I) -> IResult, + E: ParseError, +{ + move |i: I| { + let mut res = Vec::new(); + let mut i = i.clone(); + + // Parse the first element + match f(i.clone()) { + Err(e)=> return Err(e), + Ok((i1, o)) => { + if i1 == i { + return Err(Err::Error(E::from_error_kind(i1, ErrorKind::SeparatedList))); + } + + res.push(o); + i = i1; + } + } + + loop { + match sep(i.clone()) { + Err(Err::Error(_)) => return Ok((i, res)), + Err(e) => return Err(e), + Ok((i1, _)) => { + if i1 == i { + return Err(Err::Error(E::from_error_kind(i1, ErrorKind::SeparatedList))); + } + + match f(i1.clone()) { + Err(Err::Error(_)) => return Ok((i, res)), + Err(e) => return Err(e), + Ok((i2, o)) => { + if i2 == i { + return Err(Err::Error(E::from_error_kind(i2, ErrorKind::SeparatedList))); + } + + res.push(o); + i = i2; + } + } + } + } + } + } +} + +// this implementation is used for type inference issues in macros +#[doc(hidden)] +#[cfg(feature = "alloc")] +pub fn separated_nonempty_listc(i: I, sep: G, f: F) -> IResult, E> +where + I: Clone + PartialEq, + F: Fn(I) -> IResult, + G: Fn(I) -> IResult, + E: ParseError, +{ + separated_nonempty_list(sep, f)(i) +} + +/// Repeats the embedded parser `n` times or until it fails +/// and returns the results in a `Vec`. Fails if the +/// embedded parser does not succeed at least `m` times. +/// # Arguments +/// * `m` The minimum number of iterations. +/// * `n` The maximum number of iterations. +/// * `f` The parser to apply. +/// ```rust +/// # #[macro_use] extern crate nom; +/// # use nom::{Err, error::ErrorKind, Needed, IResult}; +/// use nom::multi::many_m_n; +/// use nom::bytes::complete::tag; +/// +/// fn parser(s: &str) -> IResult<&str, Vec<&str>> { +/// many_m_n(0, 2, tag("abc"))(s) +/// } +/// +/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"]))); +/// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"]))); +/// assert_eq!(parser("123123"), Ok(("123123", vec![]))); +/// assert_eq!(parser(""), Ok(("", vec![]))); +/// assert_eq!(parser("abcabcabc"), Ok(("abc", vec!["abc", "abc"]))); +/// ``` +#[cfg(feature = "alloc")] +pub fn many_m_n(m: usize, n: usize, f: F) -> impl Fn(I) -> IResult, E> +where + I: Clone + PartialEq, + F: Fn(I) -> IResult, + E: ParseError, +{ + move |i: I| { + let mut res = crate::lib::std::vec::Vec::with_capacity(m); + let mut input = i.clone(); + let mut count: usize = 0; + + if n == 0 { + return Ok((i, vec!())) + } + + loop { + let _i = input.clone(); + match f(_i) { + Ok((i, o)) => { + // do not allow parsers that do not consume input (causes infinite loops) + if i == input { + return Err(Err::Error(E::from_error_kind(input, ErrorKind::ManyMN))); + } + + res.push(o); + input = i; + count += 1; + + if count == n { + return Ok((input, res)); + } + } + Err(Err::Error(e)) => { + if count < m { + return Err(Err::Error(E::append(input, ErrorKind::ManyMN, e))); + } else { + return Ok((input, res)); + } + } + Err(e) => { + return Err(e); + } + } + } + } +} + +// this implementation is used for type inference issues in macros +#[doc(hidden)] +#[cfg(feature = "alloc")] +pub fn many_m_nc(i: I, m: usize, n: usize, f: F) -> IResult, E> +where + I: Clone + PartialEq, + F: Fn(I) -> IResult, + E: ParseError, +{ + many_m_n(m, n, f)(i) +} + +/// Repeats the embedded parser until it fails +/// and returns the number of successful iterations. +/// # Arguments +/// * `f` The parser to apply. +/// ```rust +/// # #[macro_use] extern crate nom; +/// # use nom::{Err, error::ErrorKind, Needed, IResult}; +/// use nom::multi::many0_count; +/// use nom::bytes::complete::tag; +/// +/// fn parser(s: &str) -> IResult<&str, usize> { +/// many0_count(tag("abc"))(s) +/// } +/// +/// assert_eq!(parser("abcabc"), Ok(("", 2))); +/// assert_eq!(parser("abc123"), Ok(("123", 1))); +/// assert_eq!(parser("123123"), Ok(("123123", 0))); +/// assert_eq!(parser(""), Ok(("", 0))); +/// ``` +pub fn many0_count(f: F) -> impl Fn(I) -> IResult +where + I: Clone + PartialEq, + F: Fn(I) -> IResult, + E: ParseError, +{ + move |i: I| { + let mut input = i.clone(); + let mut count = 0; + + loop { + let input_ = input.clone(); + match f(input_) { + Ok((i, _)) => { + // loop trip must always consume (otherwise infinite loops) + if i == input { + return Err(Err::Error(E::from_error_kind(input, ErrorKind::Many0Count))); + } + + input = i; + count += 1; + } + + Err(Err::Error(_)) => return Ok((input, count)), + + Err(e) => return Err(e), + } + } + } +} + +#[doc(hidden)] +pub fn many0_countc(i: I, f: F) -> IResult +where + I: Clone + PartialEq, + F: Fn(I) -> IResult, + E: ParseError, +{ + many0_count(f)(i) +} + +/// Repeats the embedded parser until it fails +/// and returns the number of successful iterations. +/// Fails if the embedded parser does not succeed +/// at least once. +/// # Arguments +/// * `f` The parser to apply. +/// ```rust +/// # #[macro_use] extern crate nom; +/// # use nom::{Err, error::ErrorKind, Needed, IResult}; +/// use nom::multi::many1_count; +/// use nom::bytes::complete::tag; +/// +/// fn parser(s: &str) -> IResult<&str, usize> { +/// many1_count(tag("abc"))(s) +/// } +/// +/// assert_eq!(parser("abcabc"), Ok(("", 2))); +/// assert_eq!(parser("abc123"), Ok(("123", 1))); +/// assert_eq!(parser("123123"), Err(Err::Error(("123123", ErrorKind::Many1Count)))); +/// assert_eq!(parser(""), Err(Err::Error(("", ErrorKind::Many1Count)))); +/// ``` +pub fn many1_count(f: F) -> impl Fn(I) -> IResult +where + I: Clone + PartialEq, + F: Fn(I) -> IResult, + E: ParseError, +{ + move |i: I| { + let i_ = i.clone(); + match f(i_) { + Err(Err::Error(_)) => Err(Err::Error(E::from_error_kind(i, ErrorKind::Many1Count))), + Err(i) => Err(i), + Ok((i1, _)) => { + let mut count = 1; + let mut input = i1; + + loop { + let input_ = input.clone(); + match f(input_) { + Err(Err::Error(_)) => return Ok((input, count)), + Err(e) => return Err(e), + Ok((i, _)) => { + if i == input { + return Err(Err::Error(E::from_error_kind(i, ErrorKind::Many1Count))); + } + + count += 1; + input = i; + } + } + } + } + } + } +} + +#[doc(hidden)] +pub fn many1_countc(i: I, f: F) -> IResult +where + I: Clone + PartialEq, + F: Fn(I) -> IResult, + E: ParseError, +{ + many1_count(f)(i) +} + +/// Runs the embedded parser a specified number +/// of times. Returns the results in a `Vec`. +/// # Arguments +/// * `f` The parser to apply. +/// * `count` How often to apply the parser. +/// ```rust +/// # #[macro_use] extern crate nom; +/// # use nom::{Err, error::ErrorKind, Needed, IResult}; +/// use nom::multi::count; +/// use nom::bytes::complete::tag; +/// +/// fn parser(s: &str) -> IResult<&str, Vec<&str>> { +/// count(tag("abc"), 2)(s) +/// } +/// +/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"]))); +/// assert_eq!(parser("abc123"), Err(Err::Error(("123", ErrorKind::Tag)))); +/// assert_eq!(parser("123123"), Err(Err::Error(("123123", ErrorKind::Tag)))); +/// assert_eq!(parser(""), Err(Err::Error(("", ErrorKind::Tag)))); +/// assert_eq!(parser("abcabcabc"), Ok(("abc", vec!["abc", "abc"]))); +/// ``` +#[cfg(feature = "alloc")] +pub fn count(f: F, count: usize) -> impl Fn(I) -> IResult, E> +where + I: Clone + PartialEq, + F: Fn(I) -> IResult, + E: ParseError, +{ + move |i: I | { + let mut input = i.clone(); + let mut res = crate::lib::std::vec::Vec::new(); + + for _ in 0..count { + let input_ = input.clone(); + match f(input_) { + Ok((i, o)) => { + res.push(o); + input = i; + } + Err(Err::Error(e)) => { + return Err(Err::Error(E::append(i, ErrorKind::Count, e))); + } + Err(e) => { + return Err(e); + } + } + } + + Ok((input, res)) + } +} + +/// Applies a parser until it fails and accumulates +/// the results using a given function and initial value. +/// # Arguments +/// * `f` The parser to apply. +/// * `init` The initial value. +/// * `g` The function that combines a result of `f` with +/// the current accumulator. +/// ```rust +/// # #[macro_use] extern crate nom; +/// # use nom::{Err, error::ErrorKind, Needed, IResult}; +/// use nom::multi::fold_many0; +/// use nom::bytes::complete::tag; +/// +/// fn parser(s: &str) -> IResult<&str, Vec<&str>> { +/// fold_many0( +/// tag("abc"), +/// Vec::new(), +/// |mut acc: Vec<_>, item| { +/// acc.push(item); +/// acc +/// } +/// )(s) +/// } +/// +/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"]))); +/// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"]))); +/// assert_eq!(parser("123123"), Ok(("123123", vec![]))); +/// assert_eq!(parser(""), Ok(("", vec![]))); +/// ``` +pub fn fold_many0(f: F, init: R, g: G) -> impl Fn(I) -> IResult +where + I: Clone + PartialEq, + F: Fn(I) -> IResult, + G: Fn(R, O) -> R, + E: ParseError, + R: Clone, +{ + move |i: I| { + let mut res = init.clone(); + let mut input = i.clone(); + + loop { + let i_ = input.clone(); + match f(i_) { + Ok((i, o)) => { + // loop trip must always consume (otherwise infinite loops) + if i == input { + return Err(Err::Error(E::from_error_kind(input, ErrorKind::Many0))); + } + + res = g(res, o); + input = i; + } + Err(Err::Error(_)) => { + return Ok((input, res)); + } + Err(e) => { + return Err(e); + } + } + } + } +} + +#[doc(hidden)] +pub fn fold_many0c(i: I, f: F, init: R, g: G) -> IResult +where + I: Clone + PartialEq, + F: Fn(I) -> IResult, + G: Fn(R, O) -> R, + E: ParseError, + R: Clone, +{ + fold_many0(f, init, g)(i) +} + +/// Applies a parser until it fails and accumulates +/// the results using a given function and initial value. +/// Fails if the embedded parser does not succeed at least +/// once. +/// # Arguments +/// * `f` The parser to apply. +/// * `init` The initial value. +/// * `g` The function that combines a result of `f` with +/// the current accumulator. +/// ```rust +/// # #[macro_use] extern crate nom; +/// # use nom::{Err, error::ErrorKind, Needed, IResult}; +/// use nom::multi::fold_many1; +/// use nom::bytes::complete::tag; +/// +/// fn parser(s: &str) -> IResult<&str, Vec<&str>> { +/// fold_many1( +/// tag("abc"), +/// Vec::new(), +/// |mut acc: Vec<_>, item| { +/// acc.push(item); +/// acc +/// } +/// )(s) +/// } +/// +/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"]))); +/// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"]))); +/// assert_eq!(parser("123123"), Err(Err::Error(("123123", ErrorKind::Many1)))); +/// assert_eq!(parser(""), Err(Err::Error(("", ErrorKind::Many1)))); +/// ``` +pub fn fold_many1(f: F, init: R, g: G) -> impl Fn(I) -> IResult +where + I: Clone + PartialEq, + F: Fn(I) -> IResult, + G: Fn(R, O) -> R, + E: ParseError, + R: Clone, +{ + move |i: I| { + let _i = i.clone(); + let init = init.clone(); + match f(_i) { + Err(Err::Error(_)) => Err(Err::Error(E::from_error_kind(i, ErrorKind::Many1))), + Err(e) => return Err(e), + Ok((i1, o1)) => { + let mut acc = g(init, o1); + let mut input = i1; + + loop { + let _input = input.clone(); + match f(_input) { + Err(Err::Error(_)) => { + break; + } + Err(e) => return Err(e), + Ok((i, o)) => { + if i == input { + return Err(Err::Failure(E::from_error_kind(i, ErrorKind::Many1))); + } + + acc = g(acc, o); + input = i; + } + } + } + + Ok((input, acc)) + } + } + } +} + +#[doc(hidden)] +pub fn fold_many1c(i: I, f: F, init: R, g: G) -> IResult +where + I: Clone + PartialEq, + F: Fn(I) -> IResult, + G: Fn(R, O) -> R, + E: ParseError, + R: Clone, +{ + fold_many1(f, init, g)(i) +} + +/// Applies a parser `n` times or until it fails and accumulates +/// the results using a given function and initial value. +/// Fails if the embedded parser does not succeed at least `m` +/// times. +/// # Arguments +/// * `m` The minimum number of iterations. +/// * `n` The maximum number of iterations. +/// * `f` The parser to apply. +/// * `init` The initial value. +/// * `g` The function that combines a result of `f` with +/// the current accumulator. +/// ```rust +/// # #[macro_use] extern crate nom; +/// # use nom::{Err, error::ErrorKind, Needed, IResult}; +/// use nom::multi::fold_many_m_n; +/// use nom::bytes::complete::tag; +/// +/// fn parser(s: &str) -> IResult<&str, Vec<&str>> { +/// fold_many_m_n( +/// 0, +/// 2, +/// tag("abc"), +/// Vec::new(), +/// |mut acc: Vec<_>, item| { +/// acc.push(item); +/// acc +/// } +/// )(s) +/// } +/// +/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"]))); +/// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"]))); +/// assert_eq!(parser("123123"), Ok(("123123", vec![]))); +/// assert_eq!(parser(""), Ok(("", vec![]))); +/// assert_eq!(parser("abcabcabc"), Ok(("abc", vec!["abc", "abc"]))); +/// ``` +pub fn fold_many_m_n(m: usize, n: usize, f: F, init: R, g: G) -> impl Fn(I) ->IResult +where + I: Clone + PartialEq, + F: Fn(I) -> IResult, + G: Fn(R, O) -> R, + E: ParseError, + R: Clone, +{ + move |i: I| { + let mut acc = init.clone(); + let mut input = i.clone(); + for count in 0..n { + let _input = input.clone(); + match f(_input) { + Ok((i, o)) => { + // do not allow parsers that do not consume input (causes infinite loops) + if i == input { + return Err(Err::Error(E::from_error_kind(i, ErrorKind::ManyMN))); + } + + acc = g(acc, o); + input = i; + } + //FInputXMError: handle failure properly + Err(Err::Error(_)) => if count < m { + return Err(Err::Error(E::from_error_kind(i, ErrorKind::ManyMN))); + } else { + break; + } + Err(e) => return Err(e), + } + } + + Ok((input, acc)) + } +} + +#[doc(hidden)] +pub fn fold_many_m_nc(i: I, m: usize, n: usize, f: F, init: R, g: G) -> IResult +where + I: Clone + PartialEq, + F: Fn(I) -> IResult, + G: Fn(R, O) -> R, + E: ParseError, + R: Clone, +{ + fold_many_m_n(m, n, f, init, g)(i) +} + +/// Gets a number from the parser and returns a +/// subslice of the input of that size. +/// If the parser returns Incomplete, +/// length_data will return an error. +/// # Arguments +/// * `f` The parser to apply. +/// ```rust +/// # #[macro_use] extern crate nom; +/// # use nom::{Err, error::ErrorKind, Needed, IResult}; +/// # use nom::Needed::Size; +/// use nom::number::complete::be_u16; +/// use nom::multi::length_data; +/// use nom::bytes::complete::tag; +/// +/// fn parser(s: &[u8]) -> IResult<&[u8], &[u8]> { +/// length_data(be_u16)(s) +/// } +/// +/// assert_eq!(parser(b"\x00\x03abcefg"), Ok((&b"efg"[..], &b"abc"[..]))); +/// assert_eq!(parser(b"\x00\x03"), Err(Err::Incomplete(Size(3)))); +/// ``` +pub fn length_data(f: F) -> impl Fn(I) -> IResult +where + I: Clone + InputLength + InputTake, + N: Copy + ToUsize, + F: Fn(I) -> IResult, + E: ParseError, +{ + move |i: I| { + let (i, length) = f(i)?; + + let length: usize = length.to_usize(); + + if i.input_len() < length { + Err(Err::Incomplete(Needed::Size(length))) + } else { + Ok(i.take_split(length)) + } + } +} + +/// Gets a number from the first parser, +/// takes a subslice of the input of that size, +/// then applies the second parser on that subslice. +/// If the second parser returns Incomplete, +/// length_value will return an error. +/// # Arguments +/// * `f` The parser to apply. +/// ```rust +/// # #[macro_use] extern crate nom; +/// # use nom::{Err, error::ErrorKind, Needed, IResult}; +/// # use nom::Needed::Size; +/// use nom::number::complete::be_u16; +/// use nom::multi::length_value; +/// use nom::bytes::complete::tag; +/// +/// fn parser(s: &[u8]) -> IResult<&[u8], &[u8]> { +/// length_value(be_u16, tag("abc"))(s) +/// } +/// +/// assert_eq!(parser(b"\x00\x03abcefg"), Ok((&b"efg"[..], &b"abc"[..]))); +/// assert_eq!(parser(b"\x00\x03123123"), Err(Err::Error((&b"123"[..], ErrorKind::Tag)))); +/// assert_eq!(parser(b"\x00\x03"), Err(Err::Incomplete(Size(3)))); +/// ``` +pub fn length_value(f: F, g: G) -> impl Fn(I) -> IResult +where + I: Clone + InputLength + InputTake, + N: Copy + ToUsize, + F: Fn(I) -> IResult, + G: Fn(I) -> IResult, + E: ParseError, +{ + move |i: I| { + let (i, length) = f(i)?; + + let length: usize = length.to_usize(); + + if i.input_len() < length { + Err(Err::Incomplete(Needed::Size(length))) + } else { + let (rest, i) = i.take_split(length); + match g(i.clone()) { + Err(Err::Incomplete(_)) => + Err(Err::Error(E::from_error_kind(i, ErrorKind::Complete))), + Err(e) => Err(e), + Ok((_, o)) => Ok((rest,o)), + } + } + } +} + +#[doc(hidden)] +pub fn length_valuec(i: I, f: F, g: G) -> IResult +where + I: Clone + InputLength + InputTake, + N: Copy + ToUsize, + F: Fn(I) -> IResult, + G: Fn(I) -> IResult, + E: ParseError, +{ + length_value(f, g)(i) +} -- cgit v1.2.3