Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

2 files changed, 1985 insertions, 0 deletions

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,T>, I -> IResult<I,O>) => I -> IResult<I, Vec<O>>`
+/// separated_list(sep, X) returns a Vec<X>
+///
+/// ```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,T>, I -> IResult<I,O>) => I -> IResult<I, Vec<O>>`
+/// separated_nonempty_list(sep, X) returns a Vec<X>
+///
+/// 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,O>) => I -> IResult<I, Vec<O>>`
+/// 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,O>) => I -> IResult<I, Vec<O>>`
+/// 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,O>, I -> IResult<I,P>) => I -> IResult<I, (Vec<O>, 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,O>) => I -> IResult<I, Vec<O>>`
+/// 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,O>) => I -> IResult<I, usize>`
+/// 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,O>) => I -> IResult<I, usize>`
+/// 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<I,O>, nb) => I -> IResult<I, Vec<O>>`
+/// 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, nb>, I -> IResult<I,O>) => I -> IResult<I, Vec<O>>`
+/// 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<Vec<&[u8]>>, 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<I, nb>) => 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, nb>, I -> IResult<I,O>) => I -> IResult<I, O>`
+///
+/// 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<I,O>, R, Fn(R, O) -> R) => I -> IResult<I, R>`
+/// 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<I,O>, R, Fn(R, O) -> R) => I -> IResult<I, R>`
+/// 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<I,O>, R, Fn(R, O) -> R) => I -> IResult<I, R>`
+/// 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<T: $crate::AsBytes>(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<I> From<(I,ErrorKind)> for NilError {
+    fn from(_: (I, ErrorKind)) -> Self {
+      NilError
+    }
+  }
+
+  impl<I> ParseError<I> for NilError {
+    fn from_error_kind(_: I, _: ErrorKind) -> NilError {
+      NilError
+    }
+    fn append(_: I, _: ErrorKind, _: NilError) -> NilError {
+      NilError
+    }
+  }
+
+  named!(pub number<u32>, 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<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
+      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<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
+      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<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
+      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<I, O, E, F>(f: F) -> impl Fn(I) -> IResult<I, Vec<O>, E>
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  E: ParseError<I>,
+{
+  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<I, O, E, F>(input: I, f: F) -> IResult<I, Vec<O>, E>
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  E: ParseError<I>,
+{
+  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<I, O, E, F>(f: F) -> impl Fn(I) -> IResult<I, Vec<O>, E>
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  E: ParseError<I>,
+{
+  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<I, O, E, F>(input: I, f: F) -> IResult<I, Vec<O>, E>
+where
+  I: Clone + Copy + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  E: ParseError<I>,
+{
+  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<I, O, P, E, F, G>(f: F, g: G) -> impl Fn(I) -> IResult<I, (Vec<O>, P), E>
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  G: Fn(I) -> IResult<I, P, E>,
+  E: ParseError<I>,
+{
+  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, O, P, E, F, G>(i: I, f: F, g: G) -> IResult<I, (Vec<O>, P), E>
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  G: Fn(I) -> IResult<I, P, E>,
+  E: ParseError<I>,
+{
+  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<I, O, O2, E, F, G>(sep: G, f: F) -> impl Fn(I) -> IResult<I, Vec<O>, E>
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  G: Fn(I) -> IResult<I, O2, E>,
+  E: ParseError<I>,
+{
+  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, O, O2, E, F, G>(i: I, sep: G, f: F) -> IResult<I, Vec<O>, E>
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  G: Fn(I) -> IResult<I, O2, E>,
+  E: ParseError<I>,
+{
+  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<I, O, O2, E, F, G>(sep: G, f: F) -> impl Fn(I) -> IResult<I, Vec<O>, E>
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  G: Fn(I) -> IResult<I, O2, E>,
+  E: ParseError<I>,
+{
+  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, O, O2, E, F, G>(i: I, sep: G, f: F) -> IResult<I, Vec<O>, E>
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  G: Fn(I) -> IResult<I, O2, E>,
+  E: ParseError<I>,
+{
+  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<I, O, E, F>(m: usize, n: usize, f: F) -> impl Fn(I) -> IResult<I, Vec<O>, E>
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  E: ParseError<I>,
+{
+  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, O, E, F>(i: I, m: usize, n: usize, f: F) -> IResult<I, Vec<O>, E>
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  E: ParseError<I>,
+{
+  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<I, O, E, F>(f: F) -> impl Fn(I) -> IResult<I, usize, E>
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  E: ParseError<I>,
+{
+  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, O, E, F>(i: I, f: F) -> IResult<I, usize, E>
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  E: ParseError<I>,
+{
+  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<I, O, E, F>(f: F) -> impl Fn(I) -> IResult<I, usize, E>
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  E: ParseError<I>,
+{
+  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, O, E, F>(i: I, f: F) -> IResult<I, usize, E>
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  E: ParseError<I>,
+{
+  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<I, O, E, F>(f: F, count: usize) -> impl Fn(I) -> IResult<I, Vec<O>, E>
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  E: ParseError<I>,
+{
+  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<I, O, E, F, G, R>(f: F, init: R, g: G) -> impl Fn(I) -> IResult<I, R, E>
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  G: Fn(R, O) -> R,
+  E: ParseError<I>,
+  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, O, E, F, G, R>(i: I, f: F, init: R, g: G) -> IResult<I, R, E>
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  G: Fn(R, O) -> R,
+  E: ParseError<I>,
+  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<I, O, E, F, G, R>(f: F, init: R, g: G) -> impl Fn(I) -> IResult<I, R, E>
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  G: Fn(R, O) -> R,
+  E: ParseError<I>,
+  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, O, E, F, G, R>(i: I, f: F, init: R, g: G) -> IResult<I, R, E>
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  G: Fn(R, O) -> R,
+  E: ParseError<I>,
+  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<I, O, E, F, G, R>(m: usize, n: usize, f: F, init: R, g: G) -> impl Fn(I) ->IResult<I, R, E>
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  G: Fn(R, O) -> R,
+  E: ParseError<I>,
+  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, O, E, F, G, R>(i: I, m: usize, n: usize, f: F, init: R, g: G) -> IResult<I, R, E>
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E>,
+  G: Fn(R, O) -> R,
+  E: ParseError<I>,
+  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<I, N, E, F>(f: F) -> impl Fn(I) -> IResult<I, I, E>
+where
+  I: Clone + InputLength + InputTake,
+  N: Copy + ToUsize,
+  F: Fn(I) -> IResult<I, N, E>,
+  E: ParseError<I>,
+{
+  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<I, O, N, E, F, G>(f: F, g: G) -> impl Fn(I) -> IResult<I, O, E>
+where
+  I: Clone + InputLength + InputTake,
+  N: Copy + ToUsize,
+  F: Fn(I) -> IResult<I, N, E>,
+  G: Fn(I) -> IResult<I, O, E>,
+  E: ParseError<I>,
+{
+  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, O, N, E, F, G>(i: I, f: F, g: G) -> IResult<I, O, E>
+where
+  I: Clone + InputLength + InputTake,
+  N: Copy + ToUsize,
+  F: Fn(I) -> IResult<I, N, E>,
+  G: Fn(I) -> IResult<I, O, E>,
+  E: ParseError<I>,
+{
+  length_value(f, g)(i)
+}