summaryrefslogtreecommitdiffstats
path: root/vendor/winnow/src/branch
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/winnow/src/branch')
-rw-r--r--vendor/winnow/src/branch/mod.rs275
-rw-r--r--vendor/winnow/src/branch/tests.rs180
2 files changed, 0 insertions, 455 deletions
diff --git a/vendor/winnow/src/branch/mod.rs b/vendor/winnow/src/branch/mod.rs
deleted file mode 100644
index 6a2c9bc3a..000000000
--- a/vendor/winnow/src/branch/mod.rs
+++ /dev/null
@@ -1,275 +0,0 @@
-//! Choice combinators
-
-#[cfg(test)]
-mod tests;
-
-use crate::error::ErrMode;
-use crate::error::ErrorKind;
-use crate::error::ParseError;
-use crate::stream::Stream;
-use crate::trace::trace;
-use crate::{IResult, Parser};
-
-#[doc(inline)]
-pub use crate::dispatch;
-
-/// Helper trait for the [alt()] combinator.
-///
-/// This trait is implemented for tuples of up to 21 elements
-pub trait Alt<I, O, E> {
- /// Tests each parser in the tuple and returns the result of the first one that succeeds
- fn choice(&mut self, input: I) -> IResult<I, O, E>;
-}
-
-/// Pick the first successful parser
-///
-/// For tight control over the error, add a final case using [`fail`][crate::combinator::fail].
-/// Alternatively, with a [custom error type][crate::_topic::error], it is possible to track all
-/// errors or return the error of the parser that went the farthest in the input data.
-///
-/// When the alternative cases have unique prefixes, [`dispatch`] can offer better performance.
-///
-/// # Example
-///
-/// ```rust
-/// # use winnow::{error::ErrMode, error::Error,error::ErrorKind, error::Needed};
-/// # use winnow::prelude::*;
-/// use winnow::character::{alpha1, digit1};
-/// use winnow::branch::alt;
-/// # fn main() {
-/// fn parser(input: &str) -> IResult<&str, &str> {
-/// alt((alpha1, digit1)).parse_next(input)
-/// };
-///
-/// // the first parser, alpha1, recognizes the input
-/// assert_eq!(parser("abc"), Ok(("", "abc")));
-///
-/// // the first parser returns an error, so alt tries the second one
-/// assert_eq!(parser("123456"), Ok(("", "123456")));
-///
-/// // both parsers failed, and with the default error type, alt will return the last error
-/// assert_eq!(parser(" "), Err(ErrMode::Backtrack(Error::new(" ", ErrorKind::Slice))));
-/// # }
-/// ```
-#[doc(alias = "choice")]
-pub fn alt<I: Stream, O, E: ParseError<I>, List: Alt<I, O, E>>(
- mut l: List,
-) -> impl Parser<I, O, E> {
- trace("alt", move |i: I| l.choice(i))
-}
-
-/// Helper trait for the [permutation()] combinator.
-///
-/// This trait is implemented for tuples of up to 21 elements
-pub trait Permutation<I, O, E> {
- /// Tries to apply all parsers in the tuple in various orders until all of them succeed
- fn permutation(&mut self, input: I) -> IResult<I, O, E>;
-}
-
-/// Applies a list of parsers in any order.
-///
-/// Permutation will succeed if all of the child parsers succeeded.
-/// It takes as argument a tuple of parsers, and returns a
-/// tuple of the parser results.
-///
-/// ```rust
-/// # use winnow::{error::ErrMode,error::{Error, ErrorKind}, error::Needed};
-/// # use winnow::prelude::*;
-/// use winnow::character::{alpha1, digit1};
-/// use winnow::branch::permutation;
-/// # fn main() {
-/// fn parser(input: &str) -> IResult<&str, (&str, &str)> {
-/// permutation((alpha1, digit1)).parse_next(input)
-/// }
-///
-/// // permutation recognizes alphabetic characters then digit
-/// assert_eq!(parser("abc123"), Ok(("", ("abc", "123"))));
-///
-/// // but also in inverse order
-/// assert_eq!(parser("123abc"), Ok(("", ("abc", "123"))));
-///
-/// // it will fail if one of the parsers failed
-/// assert_eq!(parser("abc;"), Err(ErrMode::Backtrack(Error::new(";", ErrorKind::Slice))));
-/// # }
-/// ```
-///
-/// The parsers are applied greedily: if there are multiple unapplied parsers
-/// that could parse the next slice of input, the first one is used.
-/// ```rust
-/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}};
-/// # use winnow::prelude::*;
-/// use winnow::branch::permutation;
-/// use winnow::bytes::any;
-///
-/// fn parser(input: &str) -> IResult<&str, (char, char)> {
-/// permutation((any, 'a')).parse_next(input)
-/// }
-///
-/// // any parses 'b', then char('a') parses 'a'
-/// assert_eq!(parser("ba"), Ok(("", ('b', 'a'))));
-///
-/// // any parses 'a', then char('a') fails on 'b',
-/// // even though char('a') followed by any would succeed
-/// assert_eq!(parser("ab"), Err(ErrMode::Backtrack(Error::new("b", ErrorKind::Verify))));
-/// ```
-///
-pub fn permutation<I: Stream, O, E: ParseError<I>, List: Permutation<I, O, E>>(
- mut l: List,
-) -> impl Parser<I, O, E> {
- trace("permutation", move |i: I| l.permutation(i))
-}
-
-macro_rules! alt_trait(
- ($first:ident $second:ident $($id: ident)+) => (
- alt_trait!(__impl $first $second; $($id)+);
- );
- (__impl $($current:ident)*; $head:ident $($id: ident)+) => (
- alt_trait_impl!($($current)*);
-
- alt_trait!(__impl $($current)* $head; $($id)+);
- );
- (__impl $($current:ident)*; $head:ident) => (
- alt_trait_impl!($($current)*);
- alt_trait_impl!($($current)* $head);
- );
-);
-
-macro_rules! alt_trait_impl(
- ($($id:ident)+) => (
- impl<
- I: Clone, Output, Error: ParseError<I>,
- $($id: Parser<I, Output, Error>),+
- > Alt<I, Output, Error> for ( $($id),+ ) {
-
- fn choice(&mut self, input: I) -> IResult<I, Output, Error> {
- match self.0.parse_next(input.clone()) {
- Err(ErrMode::Backtrack(e)) => alt_trait_inner!(1, self, input, e, $($id)+),
- res => res,
- }
- }
- }
- );
-);
-
-macro_rules! alt_trait_inner(
- ($it:tt, $self:expr, $input:expr, $err:expr, $head:ident $($id:ident)+) => (
- match $self.$it.parse_next($input.clone()) {
- Err(ErrMode::Backtrack(e)) => {
- let err = $err.or(e);
- succ!($it, alt_trait_inner!($self, $input, err, $($id)+))
- }
- res => res,
- }
- );
- ($it:tt, $self:expr, $input:expr, $err:expr, $head:ident) => (
- Err(ErrMode::Backtrack($err.append($input, ErrorKind::Alt)))
- );
-);
-
-alt_trait!(Alt2 Alt3 Alt4 Alt5 Alt6 Alt7 Alt8 Alt9 Alt10 Alt11 Alt12 Alt13 Alt14 Alt15 Alt16 Alt17 Alt18 Alt19 Alt20 Alt21 Alt22);
-
-// Manually implement Alt for (A,), the 1-tuple type
-impl<I, O, E: ParseError<I>, A: Parser<I, O, E>> Alt<I, O, E> for (A,) {
- fn choice(&mut self, input: I) -> IResult<I, O, E> {
- self.0.parse_next(input)
- }
-}
-
-macro_rules! permutation_trait(
- (
- $name1:ident $ty1:ident $item1:ident
- $name2:ident $ty2:ident $item2:ident
- $($name3:ident $ty3:ident $item3:ident)*
- ) => (
- permutation_trait!(__impl $name1 $ty1 $item1, $name2 $ty2 $item2; $($name3 $ty3 $item3)*);
- );
- (
- __impl $($name:ident $ty:ident $item:ident),+;
- $name1:ident $ty1:ident $item1:ident $($name2:ident $ty2:ident $item2:ident)*
- ) => (
- permutation_trait_impl!($($name $ty $item),+);
- permutation_trait!(__impl $($name $ty $item),+ , $name1 $ty1 $item1; $($name2 $ty2 $item2)*);
- );
- (__impl $($name:ident $ty:ident $item:ident),+;) => (
- permutation_trait_impl!($($name $ty $item),+);
- );
-);
-
-macro_rules! permutation_trait_impl(
- ($($name:ident $ty:ident $item:ident),+) => (
- impl<
- I: Clone, $($ty),+ , Error: ParseError<I>,
- $($name: Parser<I, $ty, Error>),+
- > Permutation<I, ( $($ty),+ ), Error> for ( $($name),+ ) {
-
- fn permutation(&mut self, mut input: I) -> IResult<I, ( $($ty),+ ), Error> {
- let mut res = ($(Option::<$ty>::None),+);
-
- loop {
- let mut err: Option<Error> = None;
- permutation_trait_inner!(0, self, input, res, err, $($name)+);
-
- // If we reach here, every iterator has either been applied before,
- // or errored on the remaining input
- if let Some(err) = err {
- // There are remaining parsers, and all errored on the remaining input
- return Err(ErrMode::Backtrack(err.append(input, ErrorKind::Alt)));
- }
-
- // All parsers were applied
- match res {
- ($(Some($item)),+) => return Ok((input, ($($item),+))),
- _ => unreachable!(),
- }
- }
- }
- }
- );
-);
-
-macro_rules! permutation_trait_inner(
- ($it:tt, $self:expr, $input:ident, $res:expr, $err:expr, $head:ident $($id:ident)*) => (
- if $res.$it.is_none() {
- match $self.$it.parse_next($input.clone()) {
- Ok((i, o)) => {
- $input = i;
- $res.$it = Some(o);
- continue;
- }
- Err(ErrMode::Backtrack(e)) => {
- $err = Some(match $err {
- Some(err) => err.or(e),
- None => e,
- });
- }
- Err(e) => return Err(e),
- };
- }
- succ!($it, permutation_trait_inner!($self, $input, $res, $err, $($id)*));
- );
- ($it:tt, $self:expr, $input:ident, $res:expr, $err:expr,) => ();
-);
-
-permutation_trait!(
- P1 O1 o1
- P2 O2 o2
- P3 O3 o3
- P4 O4 o4
- P5 O5 o5
- P6 O6 o6
- P7 O7 o7
- P8 O8 o8
- P9 O9 o9
- P10 O10 o10
- P11 O11 o11
- P12 O12 o12
- P13 O13 o13
- P14 O14 o14
- P15 O15 o15
- P16 O16 o16
- P17 O17 o17
- P18 O18 o18
- P19 O19 o19
- P20 O20 o20
- P21 O21 o21
-);
diff --git a/vendor/winnow/src/branch/tests.rs b/vendor/winnow/src/branch/tests.rs
deleted file mode 100644
index 80bc163ce..000000000
--- a/vendor/winnow/src/branch/tests.rs
+++ /dev/null
@@ -1,180 +0,0 @@
-use crate::branch::{alt, permutation};
-
-use crate::error::ErrMode;
-use crate::error::ErrorKind;
-use crate::error::Needed;
-use crate::IResult;
-use crate::Parser;
-use crate::Partial;
-#[cfg(feature = "alloc")]
-use crate::{
- error::ParseError,
- lib::std::{
- fmt::Debug,
- string::{String, ToString},
- },
-};
-
-#[cfg(feature = "alloc")]
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct ErrorStr(String);
-
-#[cfg(feature = "alloc")]
-impl From<u32> for ErrorStr {
- fn from(i: u32) -> Self {
- ErrorStr(format!("custom error code: {}", i))
- }
-}
-
-#[cfg(feature = "alloc")]
-impl<'a> From<&'a str> for ErrorStr {
- fn from(i: &'a str) -> Self {
- ErrorStr(format!("custom error message: {}", i))
- }
-}
-
-#[cfg(feature = "alloc")]
-impl<I: Debug> ParseError<I> for ErrorStr {
- fn from_error_kind(input: I, kind: ErrorKind) -> Self {
- ErrorStr(format!("custom error message: ({:?}, {:?})", input, kind))
- }
-
- fn append(self, input: I, kind: ErrorKind) -> Self {
- ErrorStr(format!(
- "custom error message: ({:?}, {:?}) - {:?}",
- input, kind, self
- ))
- }
-}
-
-#[cfg(feature = "alloc")]
-#[test]
-fn alt_test() {
- fn work(input: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
- Ok((&b""[..], input))
- }
-
- #[allow(unused_variables)]
- fn dont_work(input: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
- Err(ErrMode::Backtrack(ErrorStr("abcd".to_string())))
- }
-
- fn work2(input: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
- Ok((input, &b""[..]))
- }
-
- fn alt1(i: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
- alt((dont_work, dont_work)).parse_next(i)
- }
- fn alt2(i: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
- alt((dont_work, work)).parse_next(i)
- }
- fn alt3(i: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
- alt((dont_work, dont_work, work2, dont_work)).parse_next(i)
- }
- //named!(alt1, alt!(dont_work | dont_work));
- //named!(alt2, alt!(dont_work | work));
- //named!(alt3, alt!(dont_work | dont_work | work2 | dont_work));
-
- let a = &b"abcd"[..];
- assert_eq!(
- alt1(a),
- Err(ErrMode::Backtrack(error_node_position!(
- a,
- ErrorKind::Alt,
- ErrorStr("abcd".to_string())
- )))
- );
- assert_eq!(alt2(a), Ok((&b""[..], a)));
- assert_eq!(alt3(a), Ok((a, &b""[..])));
-
- fn alt4(i: &[u8]) -> IResult<&[u8], &[u8]> {
- alt(("abcd", "efgh")).parse_next(i)
- }
- let b = &b"efgh"[..];
- assert_eq!(alt4(a), Ok((&b""[..], a)));
- assert_eq!(alt4(b), Ok((&b""[..], b)));
-}
-
-#[test]
-fn alt_incomplete() {
- fn alt1(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
- alt(("a", "bc", "def")).parse_next(i)
- }
-
- let a = &b""[..];
- assert_eq!(
- alt1(Partial::new(a)),
- Err(ErrMode::Incomplete(Needed::new(1)))
- );
- let a = &b"b"[..];
- assert_eq!(
- alt1(Partial::new(a)),
- Err(ErrMode::Incomplete(Needed::new(1)))
- );
- let a = &b"bcd"[..];
- assert_eq!(
- alt1(Partial::new(a)),
- Ok((Partial::new(&b"d"[..]), &b"bc"[..]))
- );
- let a = &b"cde"[..];
- assert_eq!(
- alt1(Partial::new(a)),
- Err(ErrMode::Backtrack(error_position!(
- Partial::new(a),
- ErrorKind::Tag
- )))
- );
- let a = &b"de"[..];
- assert_eq!(
- alt1(Partial::new(a)),
- Err(ErrMode::Incomplete(Needed::new(1)))
- );
- let a = &b"defg"[..];
- assert_eq!(
- alt1(Partial::new(a)),
- Ok((Partial::new(&b"g"[..]), &b"def"[..]))
- );
-}
-
-#[test]
-fn permutation_test() {
- #[allow(clippy::type_complexity)]
- fn perm(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, (&[u8], &[u8], &[u8])> {
- permutation(("abcd", "efg", "hi")).parse_next(i)
- }
-
- let expected = (&b"abcd"[..], &b"efg"[..], &b"hi"[..]);
-
- let a = &b"abcdefghijk"[..];
- assert_eq!(
- perm(Partial::new(a)),
- Ok((Partial::new(&b"jk"[..]), expected))
- );
- let b = &b"efgabcdhijk"[..];
- assert_eq!(
- perm(Partial::new(b)),
- Ok((Partial::new(&b"jk"[..]), expected))
- );
- let c = &b"hiefgabcdjk"[..];
- assert_eq!(
- perm(Partial::new(c)),
- Ok((Partial::new(&b"jk"[..]), expected))
- );
-
- let d = &b"efgxyzabcdefghi"[..];
- assert_eq!(
- perm(Partial::new(d)),
- Err(ErrMode::Backtrack(error_node_position!(
- Partial::new(&b"efgxyzabcdefghi"[..]),
- ErrorKind::Alt,
- error_position!(Partial::new(&b"xyzabcdefghi"[..]), ErrorKind::Tag)
- )))
- );
-
- let e = &b"efgabc"[..];
- assert_eq!(
- perm(Partial::new(e)),
- Err(ErrMode::Incomplete(Needed::new(1)))
- );
-}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-04 06:40:37 +0000