nom/bytes/
mod.rs

Help
1//! Parsers recognizing bytes streams
2
3pub mod complete;
4pub mod streaming;
5#[cfg(test)]
6mod tests;
7
8use core::marker::PhantomData;
9
10use crate::error::ErrorKind;
11use crate::error::ParseError;
12use crate::internal::{Err, Needed, Parser};
13use crate::lib::std::result::Result::*;
14use crate::traits::{Compare, CompareResult};
15use crate::AsChar;
16use crate::Check;
17use crate::ExtendInto;
18use crate::FindSubstring;
19use crate::FindToken;
20use crate::Input;
21use crate::IsStreaming;
22use crate::Mode;
23use crate::OutputM;
24use crate::OutputMode;
25use crate::ToUsize;
26
27/// Recognizes a pattern.
28///
29/// The input data will be compared to the tag combinator's argument and will return the part of
30/// the input that matches the argument.
31/// # Example
32/// ```rust
33/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
34/// use nom::bytes::streaming::tag;
35///
36/// fn parser(s: &str) -> IResult<&str, &str> {
37///   tag("Hello")(s)
38/// }
39///
40/// assert_eq!(parser("Hello, World!"), Ok((", World!", "Hello")));
41/// assert_eq!(parser("Something"), Err(Err::Error(Error::new("Something", ErrorKind::Tag))));
42/// assert_eq!(parser("S"), Err(Err::Error(Error::new("S", ErrorKind::Tag))));
43/// assert_eq!(parser("H"), Err(Err::Incomplete(Needed::new(4))));
44/// ```
45pub fn tag<T, I, Error: ParseError<I>>(tag: T) -> impl Parser<I, Output = I, Error = Error>
46where
47  I: Input + Compare<T>,
48  T: Input + Clone,
49{
50  Tag {
51    tag,
52    e: PhantomData,
53  }
54}
55
56/// Tag implementation
57pub struct Tag<T, E> {
58  tag: T,
59  e: PhantomData<E>,
60}
61
62impl<I, Error: ParseError<I>, T> Parser<I> for Tag<T, Error>
63where
64  I: Input + Compare<T>,
65  T: Input + Clone,
66{
67  type Output = I;
68
69  type Error = Error;
70
71  fn process<OM: OutputMode>(&mut self, i: I) -> crate::PResult<OM, I, Self::Output, Self::Error> {
72    let tag_len = self.tag.input_len();
73    let t = self.tag.clone();
74
75    match i.compare(t) {
76      CompareResult::Ok => Ok((i.take_from(tag_len), OM::Output::bind(|| i.take(tag_len)))),
77      CompareResult::Incomplete => {
78        if OM::Incomplete::is_streaming() {
79          Err(Err::Incomplete(Needed::new(tag_len - i.input_len())))
80        } else {
81          Err(Err::Error(OM::Error::bind(|| {
82            let e: ErrorKind = ErrorKind::Tag;
83            Error::from_error_kind(i, e)
84          })))
85        }
86      }
87      CompareResult::Error => Err(Err::Error(OM::Error::bind(|| {
88        let e: ErrorKind = ErrorKind::Tag;
89        Error::from_error_kind(i, e)
90      }))),
91    }
92  }
93}
94
95/// Recognizes a case insensitive pattern.
96///
97/// The input data will be compared to the tag combinator's argument and will return the part of
98/// the input that matches the argument with no regard to case.
99/// # Example
100/// ```rust
101/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
102/// use nom::bytes::streaming::tag_no_case;
103///
104/// fn parser(s: &str) -> IResult<&str, &str> {
105///   tag_no_case("hello")(s)
106/// }
107///
108/// assert_eq!(parser("Hello, World!"), Ok((", World!", "Hello")));
109/// assert_eq!(parser("hello, World!"), Ok((", World!", "hello")));
110/// assert_eq!(parser("HeLlO, World!"), Ok((", World!", "HeLlO")));
111/// assert_eq!(parser("Something"), Err(Err::Error(Error::new("Something", ErrorKind::Tag))));
112/// assert_eq!(parser(""), Err(Err::Incomplete(Needed::new(5))));
113/// ```
114pub fn tag_no_case<T, I, Error: ParseError<I>>(tag: T) -> impl Parser<I, Output = I, Error = Error>
115where
116  I: Input + Compare<T>,
117  T: Input + Clone,
118{
119  TagNoCase {
120    tag,
121    e: PhantomData,
122  }
123}
124
125/// Case insensitive Tag implementation
126pub struct TagNoCase<T, E> {
127  tag: T,
128  e: PhantomData<E>,
129}
130
131impl<I, Error: ParseError<I>, T> Parser<I> for TagNoCase<T, Error>
132where
133  I: Input + Compare<T>,
134  T: Input + Clone,
135{
136  type Output = I;
137
138  type Error = Error;
139
140  fn process<OM: OutputMode>(&mut self, i: I) -> crate::PResult<OM, I, Self::Output, Self::Error> {
141    let tag_len = self.tag.input_len();
142    let t = self.tag.clone();
143
144    match i.compare_no_case(t) {
145      CompareResult::Ok => Ok((i.take_from(tag_len), OM::Output::bind(|| i.take(tag_len)))),
146      CompareResult::Incomplete => {
147        if OM::Incomplete::is_streaming() {
148          Err(Err::Incomplete(Needed::new(tag_len - i.input_len())))
149        } else {
150          Err(Err::Error(OM::Error::bind(|| {
151            let e: ErrorKind = ErrorKind::Tag;
152            Error::from_error_kind(i, e)
153          })))
154        }
155      }
156      CompareResult::Error => Err(Err::Error(OM::Error::bind(|| {
157        let e: ErrorKind = ErrorKind::Tag;
158        Error::from_error_kind(i, e)
159      }))),
160    }
161  }
162}
163
164/// Parser wrapper for `split_at_position`
165pub struct SplitPosition<F, E> {
166  predicate: F,
167  error: PhantomData<E>,
168}
169
170impl<I, Error: ParseError<I>, F> Parser<I> for SplitPosition<F, Error>
171where
172  I: Input,
173  F: Fn(<I as Input>::Item) -> bool,
174{
175  type Output = I;
176
177  type Error = Error;
178
179  #[inline(always)]
180  fn process<OM: OutputMode>(&mut self, i: I) -> crate::PResult<OM, I, Self::Output, Self::Error> {
181    i.split_at_position_mode::<OM, _, _>(|c| (self.predicate)(c))
182  }
183}
184
185/// Parser wrapper for `split_at_position1`
186pub struct SplitPosition1<F, E> {
187  e: ErrorKind,
188  predicate: F,
189  error: PhantomData<E>,
190}
191
192impl<I, Error: ParseError<I>, F> Parser<I> for SplitPosition1<F, Error>
193where
194  I: Input,
195  F: Fn(<I as Input>::Item) -> bool,
196{
197  type Output = I;
198
199  type Error = Error;
200
201  #[inline(always)]
202  fn process<OM: OutputMode>(&mut self, i: I) -> crate::PResult<OM, I, Self::Output, Self::Error> {
203    i.split_at_position_mode1::<OM, _, _>(|c| (self.predicate)(c), self.e)
204  }
205}
206
207/// Parse till certain characters are met.
208///
209/// The parser will return the longest slice till one of the characters of the combinator's argument are met.
210///
211/// It doesn't consume the matched character.
212///
213/// It will return a `Err::Error(("", ErrorKind::IsNot))` if the pattern wasn't met.
214/// # Example
215/// ```rust
216/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
217/// use nom::bytes::complete::is_not;
218///
219/// fn not_space(s: &str) -> IResult<&str, &str> {
220///   is_not(" \t\r\n")(s)
221/// }
222///
223/// assert_eq!(not_space("Hello, World!"), Ok((" World!", "Hello,")));
224/// assert_eq!(not_space("Sometimes\t"), Ok(("\t", "Sometimes")));
225/// assert_eq!(not_space("Nospace"), Ok(("", "Nospace")));
226/// assert_eq!(not_space(""), Err(Err::Error(Error::new("", ErrorKind::IsNot))));
227/// ```
228pub fn is_not<T, I, Error: ParseError<I>>(arr: T) -> impl Parser<I, Output = I, Error = Error>
229where
230  I: Input,
231  T: FindToken<<I as Input>::Item>,
232{
233  SplitPosition1 {
234    e: ErrorKind::IsNot,
235    predicate: move |c| arr.find_token(c),
236    error: PhantomData,
237  }
238}
239
240/// Returns the longest slice of the matches the pattern.
241///
242/// The parser will return the longest slice consisting of the characters in provided in the
243/// combinator's argument.
244///
245/// It will return a `Err(Err::Error((_, ErrorKind::IsA)))` if the pattern wasn't met.
246/// # Example
247/// ```rust
248/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
249/// use nom::bytes::complete::is_a;
250///
251/// fn hex(s: &str) -> IResult<&str, &str> {
252///   is_a("1234567890ABCDEF")(s)
253/// }
254///
255/// assert_eq!(hex("123 and voila"), Ok((" and voila", "123")));
256/// assert_eq!(hex("DEADBEEF and others"), Ok((" and others", "DEADBEEF")));
257/// assert_eq!(hex("BADBABEsomething"), Ok(("something", "BADBABE")));
258/// assert_eq!(hex("D15EA5E"), Ok(("", "D15EA5E")));
259/// assert_eq!(hex(""), Err(Err::Error(Error::new("", ErrorKind::IsA))));
260/// ```
261pub fn is_a<T, I, Error: ParseError<I>>(arr: T) -> impl Parser<I, Output = I, Error = Error>
262where
263  I: Input,
264  T: FindToken<<I as Input>::Item>,
265{
266  SplitPosition1 {
267    e: ErrorKind::IsA,
268    predicate: move |c| !arr.find_token(c),
269    error: PhantomData,
270  }
271}
272
273/// Returns the longest input slice (if any) that matches the predicate.
274///
275/// The parser will return the longest slice that matches the given predicate *(a function that
276/// takes the input and returns a bool)*.
277/// # Example
278/// ```rust
279/// # use nom::{Err, error::ErrorKind, Needed, IResult};
280/// use nom::bytes::complete::take_while;
281/// use nom::character::is_alphabetic;
282///
283/// fn alpha(s: &[u8]) -> IResult<&[u8], &[u8]> {
284///   take_while(is_alphabetic)(s)
285/// }
286///
287/// assert_eq!(alpha(b"latin123"), Ok((&b"123"[..], &b"latin"[..])));
288/// assert_eq!(alpha(b"12345"), Ok((&b"12345"[..], &b""[..])));
289/// assert_eq!(alpha(b"latin"), Ok((&b""[..], &b"latin"[..])));
290/// assert_eq!(alpha(b""), Ok((&b""[..], &b""[..])));
291/// ```
292pub fn take_while<F, I, Error: ParseError<I>>(cond: F) -> impl Parser<I, Output = I, Error = Error>
293where
294  I: Input,
295  F: Fn(<I as Input>::Item) -> bool,
296{
297  SplitPosition {
298    predicate: move |c| !cond(c),
299    error: PhantomData,
300  }
301}
302
303/// Returns the longest (at least 1) input slice that matches the predicate.
304///
305/// The parser will return the longest slice that matches the given predicate *(a function that
306/// takes the input and returns a bool)*.
307///
308/// It will return an `Err(Err::Error((_, ErrorKind::TakeWhile1)))` if the pattern wasn't met.
309///
310/// # Streaming Specific
311/// *Streaming version* will return a `Err::Incomplete(Needed::new(1))` or if the pattern reaches the end of the input.
312///
313/// # Example
314/// ```rust
315/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
316/// use nom::bytes::streaming::take_while1;
317/// use nom::character::is_alphabetic;
318///
319/// fn alpha(s: &[u8]) -> IResult<&[u8], &[u8]> {
320///   take_while1(is_alphabetic)(s)
321/// }
322///
323/// assert_eq!(alpha(b"latin123"), Ok((&b"123"[..], &b"latin"[..])));
324/// assert_eq!(alpha(b"latin"), Err(Err::Incomplete(Needed::new(1))));
325/// assert_eq!(alpha(b"12345"), Err(Err::Error(Error::new(&b"12345"[..], ErrorKind::TakeWhile1))));
326/// ```
327pub fn take_while1<F, I, Error: ParseError<I>>(cond: F) -> impl Parser<I, Output = I, Error = Error>
328where
329  I: Input,
330  F: Fn(<I as Input>::Item) -> bool,
331{
332  SplitPosition1 {
333    e: ErrorKind::TakeWhile1,
334    predicate: move |c| !cond(c),
335    error: PhantomData,
336  }
337}
338
339/// Returns the longest (m <= len <= n) input slice  that matches the predicate.
340///
341/// The parser will return the longest slice that matches the given predicate *(a function that
342/// takes the input and returns a bool)*.
343///
344/// It will return an `Err::Error((_, ErrorKind::TakeWhileMN))` if the pattern wasn't met.
345/// # Streaming Specific
346/// *Streaming version* will return a `Err::Incomplete(Needed::new(1))`  if the pattern reaches the end of the input or is too short.
347///
348/// # Example
349/// ```rust
350/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
351/// use nom::bytes::streaming::take_while_m_n;
352/// use nom::character::is_alphabetic;
353///
354/// fn short_alpha(s: &[u8]) -> IResult<&[u8], &[u8]> {
355///   take_while_m_n(3, 6, is_alphabetic)(s)
356/// }
357///
358/// assert_eq!(short_alpha(b"latin123"), Ok((&b"123"[..], &b"latin"[..])));
359/// assert_eq!(short_alpha(b"lengthy"), Ok((&b"y"[..], &b"length"[..])));
360/// assert_eq!(short_alpha(b"latin"), Err(Err::Incomplete(Needed::new(1))));
361/// assert_eq!(short_alpha(b"ed"), Err(Err::Incomplete(Needed::new(1))));
362/// assert_eq!(short_alpha(b"12345"), Err(Err::Error(Error::new(&b"12345"[..], ErrorKind::TakeWhileMN))));
363/// ```
364pub fn take_while_m_n<F, I, Error: ParseError<I>>(
365  m: usize,
366  n: usize,
367  predicate: F,
368) -> impl Parser<I, Output = I, Error = Error>
369where
370  I: Input,
371  F: Fn(<I as Input>::Item) -> bool,
372{
373  TakeWhileMN {
374    m,
375    n,
376    predicate,
377    e: PhantomData,
378  }
379}
380
381/// Parser implementation for [take_while_m_n]
382pub struct TakeWhileMN<F, E> {
383  m: usize,
384  n: usize,
385  predicate: F,
386  e: PhantomData<E>,
387}
388
389impl<I, Error: ParseError<I>, F> Parser<I> for TakeWhileMN<F, Error>
390where
391  I: Input,
392  F: Fn(<I as Input>::Item) -> bool,
393{
394  type Output = I;
395  type Error = Error;
396
397  fn process<OM: OutputMode>(
398    &mut self,
399    input: I,
400  ) -> crate::PResult<OM, I, Self::Output, Self::Error> {
401    let mut count = 0;
402    for (i, (index, item)) in input.iter_indices().enumerate() {
403      if i == self.n {
404        return Ok((
405          input.take_from(index),
406          OM::Output::bind(|| input.take(index)),
407        ));
408      }
409
410      if !(self.predicate)(item) {
411        if i >= self.m {
412          return Ok((
413            input.take_from(index),
414            OM::Output::bind(|| input.take(index)),
415          ));
416        } else {
417          return Err(Err::Error(OM::Error::bind(|| {
418            Error::from_error_kind(input, ErrorKind::TakeWhileMN)
419          })));
420        }
421      }
422      count += 1;
423    }
424
425    let input_len = input.input_len();
426    if OM::Incomplete::is_streaming() {
427      let needed = if self.m > input_len {
428        self.m - input_len
429      } else {
430        1
431      };
432      Err(Err::Incomplete(Needed::new(needed)))
433    } else if count >= self.m {
434      Ok((
435        input.take_from(input_len),
436        OM::Output::bind(|| input.take(input_len)),
437      ))
438    } else {
439      Err(Err::Error(OM::Error::bind(|| {
440        Error::from_error_kind(input, ErrorKind::TakeWhileMN)
441      })))
442    }
443  }
444}
445
446/// Returns the longest input slice (if any) till a predicate is met.
447///
448/// The parser will return the longest slice till the given predicate *(a function that
449/// takes the input and returns a bool)*.
450/// # Example
451/// ```rust
452/// # use nom::{Err, error::ErrorKind, Needed, IResult};
453/// use nom::bytes::complete::take_till;
454///
455/// fn till_colon(s: &str) -> IResult<&str, &str> {
456///   take_till(|c| c == ':')(s)
457/// }
458///
459/// assert_eq!(till_colon("latin:123"), Ok((":123", "latin")));
460/// assert_eq!(till_colon(":empty matched"), Ok((":empty matched", ""))); //allowed
461/// assert_eq!(till_colon("12345"), Ok(("", "12345")));
462/// assert_eq!(till_colon(""), Ok(("", "")));
463/// ```
464#[allow(clippy::redundant_closure)]
465pub fn take_till<F, I, Error: ParseError<I>>(cond: F) -> impl Parser<I, Output = I, Error = Error>
466where
467  I: Input,
468  F: Fn(<I as Input>::Item) -> bool,
469{
470  SplitPosition {
471    predicate: cond,
472    error: PhantomData,
473  }
474}
475
476/// Returns the longest (at least 1) input slice till a predicate is met.
477///
478/// The parser will return the longest slice till the given predicate *(a function that
479/// takes the input and returns a bool)*.
480///
481/// # Streaming Specific
482/// *Streaming version* will return a `Err::Incomplete(Needed::new(1))` if the match reaches the
483/// end of input or if there was not match.
484/// # Example
485/// ```rust
486/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
487/// use nom::bytes::streaming::take_till1;
488///
489/// fn till_colon(s: &str) -> IResult<&str, &str> {
490///   take_till1(|c| c == ':')(s)
491/// }
492///
493/// assert_eq!(till_colon("latin:123"), Ok((":123", "latin")));
494/// assert_eq!(till_colon(":empty matched"), Err(Err::Error(Error::new(":empty matched", ErrorKind::TakeTill1))));
495/// assert_eq!(till_colon("12345"), Err(Err::Incomplete(Needed::new(1))));
496/// assert_eq!(till_colon(""), Err(Err::Incomplete(Needed::new(1))));
497/// ```
498#[allow(clippy::redundant_closure)]
499pub fn take_till1<F, I, Error: ParseError<I>>(cond: F) -> impl Parser<I, Output = I, Error = Error>
500where
501  I: Input,
502  F: Fn(<I as Input>::Item) -> bool,
503{
504  SplitPosition1 {
505    e: ErrorKind::TakeTill1,
506    predicate: cond,
507    error: PhantomData,
508  }
509}
510
511/// Returns an input slice containing the first N input elements (Input[..N]).
512///
513/// # Streaming Specific
514/// *Streaming version* if the input has less than N elements, `take` will
515/// return a `Err::Incomplete(Needed::new(M))` where M is the number of
516/// additional bytes the parser would need to succeed.
517/// It is well defined for `&[u8]` as the number of elements is the byte size,
518/// but for types like `&str`, we cannot know how many bytes correspond for
519/// the next few chars, so the result will be `Err::Incomplete(Needed::Unknown)`
520///
521/// # Example
522/// ```rust
523/// # use nom::{Err, error::ErrorKind, Needed, IResult};
524/// use nom::bytes::streaming::take;
525///
526/// fn take6(s: &str) -> IResult<&str, &str> {
527///   take(6usize)(s)
528/// }
529///
530/// assert_eq!(take6("1234567"), Ok(("7", "123456")));
531/// assert_eq!(take6("things"), Ok(("", "things")));
532/// assert_eq!(take6("short"), Err(Err::Incomplete(Needed::Unknown)));
533/// ```
534pub fn take<C, I, Error: ParseError<I>>(count: C) -> impl Parser<I, Output = I, Error = Error>
535where
536  I: Input,
537  C: ToUsize,
538{
539  Take {
540    length: count.to_usize(),
541    e: PhantomData,
542  }
543}
544
545/// Parser implementation for [take]
546pub struct Take<E> {
547  length: usize,
548  e: PhantomData<E>,
549}
550
551impl<I, Error: ParseError<I>> Parser<I> for Take<Error>
552where
553  I: Input,
554{
555  type Output = I;
556  type Error = Error;
557
558  fn process<OM: OutputMode>(&mut self, i: I) -> crate::PResult<OM, I, Self::Output, Self::Error> {
559    match i.slice_index(self.length) {
560      Err(needed) => {
561        if OM::Incomplete::is_streaming() {
562          Err(Err::Incomplete(needed))
563        } else {
564          Err(Err::Error(OM::Error::bind(|| {
565            let e: ErrorKind = ErrorKind::Eof;
566            Error::from_error_kind(i, e)
567          })))
568        }
569      }
570      Ok(index) => Ok((i.take_from(index), OM::Output::bind(|| i.take(index)))),
571    }
572  }
573}
574
575/// Returns the input slice up to the first occurrence of the pattern.
576///
577/// It doesn't consume the pattern.
578///
579/// # Streaming Specific
580/// *Streaming version* will return a `Err::Incomplete(Needed::new(N))` if the input doesn't
581/// contain the pattern or if the input is smaller than the pattern.
582/// # Example
583/// ```rust
584/// # use nom::{Err, error::ErrorKind, Needed, IResult};
585/// use nom::bytes::streaming::take_until;
586///
587/// fn until_eof(s: &str) -> IResult<&str, &str> {
588///   take_until("eof")(s)
589/// }
590///
591/// assert_eq!(until_eof("hello, worldeof"), Ok(("eof", "hello, world")));
592/// assert_eq!(until_eof("hello, world"), Err(Err::Incomplete(Needed::Unknown)));
593/// assert_eq!(until_eof("hello, worldeo"), Err(Err::Incomplete(Needed::Unknown)));
594/// assert_eq!(until_eof("1eof2eof"), Ok(("eof2eof", "1")));
595/// ```
596pub fn take_until<T, I, Error: ParseError<I>>(tag: T) -> impl Parser<I, Output = I, Error = Error>
597where
598  I: Input + FindSubstring<T>,
599  T: Clone,
600{
601  TakeUntil {
602    tag,
603    e: PhantomData,
604  }
605}
606
607/// Parser implementation for [take_until]
608pub struct TakeUntil<T, E> {
609  tag: T,
610  e: PhantomData<E>,
611}
612
613impl<I, T, Error: ParseError<I>> Parser<I> for TakeUntil<T, Error>
614where
615  I: Input + FindSubstring<T>,
616  T: Clone,
617{
618  type Output = I;
619  type Error = Error;
620
621  fn process<OM: OutputMode>(&mut self, i: I) -> crate::PResult<OM, I, Self::Output, Self::Error> {
622    match i.find_substring(self.tag.clone()) {
623      None => {
624        if OM::Incomplete::is_streaming() {
625          Err(Err::Incomplete(Needed::Unknown))
626        } else {
627          Err(Err::Error(OM::Error::bind(|| {
628            let e: ErrorKind = ErrorKind::TakeUntil;
629            Error::from_error_kind(i, e)
630          })))
631        }
632      }
633      Some(index) => Ok((i.take_from(index), OM::Output::bind(|| i.take(index)))),
634    }
635  }
636}
637
638/// Returns the non empty input slice up to the first occurrence of the pattern.
639///
640/// It doesn't consume the pattern.
641///
642/// # Streaming Specific
643/// *Streaming version* will return a `Err::Incomplete(Needed::new(N))` if the input doesn't
644/// contain the pattern or if the input is smaller than the pattern.
645/// # Example
646/// ```rust
647/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
648/// use nom::bytes::streaming::take_until1;
649///
650/// fn until_eof(s: &str) -> IResult<&str, &str> {
651///   take_until1("eof")(s)
652/// }
653///
654/// assert_eq!(until_eof("hello, worldeof"), Ok(("eof", "hello, world")));
655/// assert_eq!(until_eof("hello, world"), Err(Err::Incomplete(Needed::Unknown)));
656/// assert_eq!(until_eof("hello, worldeo"), Err(Err::Incomplete(Needed::Unknown)));
657/// assert_eq!(until_eof("1eof2eof"), Ok(("eof2eof", "1")));
658/// assert_eq!(until_eof("eof"),  Err(Err::Error(Error::new("eof", ErrorKind::TakeUntil))));
659/// ```
660pub fn take_until1<T, I, Error: ParseError<I>>(tag: T) -> impl Parser<I, Output = I, Error = Error>
661where
662  I: Input + FindSubstring<T>,
663  T: Clone,
664{
665  TakeUntil1 {
666    tag,
667    e: PhantomData,
668  }
669}
670
671/// Parser implementation for take_until1
672pub struct TakeUntil1<T, E> {
673  tag: T,
674  e: PhantomData<E>,
675}
676
677impl<I, T, Error: ParseError<I>> Parser<I> for TakeUntil1<T, Error>
678where
679  I: Input + FindSubstring<T>,
680  T: Clone,
681{
682  type Output = I;
683  type Error = Error;
684
685  fn process<OM: OutputMode>(&mut self, i: I) -> crate::PResult<OM, I, Self::Output, Self::Error> {
686    match i.find_substring(self.tag.clone()) {
687      None => {
688        if OM::Incomplete::is_streaming() {
689          Err(Err::Incomplete(Needed::Unknown))
690        } else {
691          Err(Err::Error(OM::Error::bind(|| {
692            let e: ErrorKind = ErrorKind::TakeUntil;
693            Error::from_error_kind(i, e)
694          })))
695        }
696      }
697      Some(0) => Err(Err::Error(OM::Error::bind(|| {
698        Error::from_error_kind(i, ErrorKind::TakeUntil)
699      }))),
700
701      Some(index) => Ok((i.take_from(index), OM::Output::bind(|| i.take(index)))),
702    }
703  }
704}
705
706/// Matches a byte string with escaped characters.
707///
708/// * The first argument matches the normal characters (it must not accept the control character)
709/// * The second argument is the control character (like `\` in most languages)
710/// * The third argument matches the escaped characters
711/// # Example
712/// ```
713/// # use nom::{Err, error::ErrorKind, Needed, IResult};
714/// # use nom::character::complete::digit1;
715/// use nom::bytes::streaming::escaped;
716/// use nom::character::streaming::one_of;
717///
718/// fn esc(s: &str) -> IResult<&str, &str> {
719///   escaped(digit1, '\\', one_of("\"n\\"))(s)
720/// }
721///
722/// assert_eq!(esc("123;"), Ok((";", "123")));
723/// assert_eq!(esc("12\\\"34;"), Ok((";", "12\\\"34")));
724/// ```
725///
726pub fn escaped<I, Error, F, G>(
727  normal: F,
728  control_char: char,
729  escapable: G,
730) -> impl Parser<I, Output = I, Error = Error>
731where
732  I: Input + Clone + crate::traits::Offset,
733  <I as Input>::Item: crate::traits::AsChar,
734  F: Parser<I, Error = Error>,
735  G: Parser<I, Error = Error>,
736  Error: ParseError<I>,
737{
738  Escaped {
739    normal,
740    escapable,
741    control_char,
742    e: PhantomData,
743  }
744}
745
746/// Parser implementation for [escaped]
747pub struct Escaped<F, G, E> {
748  normal: F,
749  escapable: G,
750  control_char: char,
751  e: PhantomData<E>,
752}
753
754impl<I, Error: ParseError<I>, F, G> Parser<I> for Escaped<F, G, Error>
755where
756  I: Input + Clone + crate::traits::Offset,
757  <I as Input>::Item: crate::traits::AsChar,
758  F: Parser<I, Error = Error>,
759  G: Parser<I, Error = Error>,
760  Error: ParseError<I>,
761{
762  type Output = I;
763  type Error = Error;
764
765  fn process<OM: OutputMode>(
766    &mut self,
767    input: I,
768  ) -> crate::PResult<OM, I, Self::Output, Self::Error> {
769    let mut i = input.clone();
770
771    while i.input_len() > 0 {
772      let current_len = i.input_len();
773
774      match self
775        .normal
776        .process::<OutputM<Check, Check, OM::Incomplete>>(i.clone())
777      {
778        Ok((i2, _)) => {
779          if i2.input_len() == 0 {
780            if OM::Incomplete::is_streaming() {
781              return Err(Err::Incomplete(Needed::Unknown));
782            } else {
783              let index = input.input_len();
784              return Ok((
785                input.take_from(index),
786                OM::Output::bind(|| input.take(index)),
787              ));
788            }
789          } else if i2.input_len() == current_len {
790            let index = input.offset(&i2);
791            return Ok((
792              input.take_from(index),
793              OM::Output::bind(|| input.take(index)),
794            ));
795          } else {
796            i = i2;
797          }
798        }
799        Err(Err::Error(_)) => {
800          // unwrap() should be safe here since index < $i.input_len()
801          if i.iter_elements().next().unwrap().as_char() == self.control_char {
802            let next = self.control_char.len_utf8();
803            if next >= i.input_len() {
804              if OM::Incomplete::is_streaming() {
805                return Err(Err::Incomplete(Needed::new(1)));
806              } else {
807                return Err(Err::Error(OM::Error::bind(|| {
808                  Error::from_error_kind(input, ErrorKind::Escaped)
809                })));
810              }
811            } else {
812              match self
813                .escapable
814                .process::<OutputM<Check, OM::Error, OM::Incomplete>>(i.take_from(next))
815              {
816                Ok((i2, _)) => {
817                  if i2.input_len() == 0 {
818                    if OM::Incomplete::is_streaming() {
819                      return Err(Err::Incomplete(Needed::Unknown));
820                    } else {
821                      let index = input.input_len();
822                      return Ok((
823                        input.take_from(index),
824                        OM::Output::bind(|| input.take(index)),
825                      ));
826                    }
827                  } else {
828                    i = i2;
829                  }
830                }
831                Err(e) => return Err(e),
832              }
833            }
834          } else {
835            let index = input.offset(&i);
836            if index == 0 {
837              return Err(Err::Error(OM::Error::bind(|| {
838                Error::from_error_kind(input, ErrorKind::Escaped)
839              })));
840            } else {
841              return Ok((
842                input.take_from(index),
843                OM::Output::bind(|| input.take(index)),
844              ));
845            }
846          }
847        }
848        Err(Err::Failure(e)) => {
849          return Err(Err::Failure(e));
850        }
851        Err(Err::Incomplete(i)) => {
852          return Err(Err::Incomplete(i));
853        }
854      }
855    }
856
857    if OM::Incomplete::is_streaming() {
858      Err(Err::Incomplete(Needed::Unknown))
859    } else {
860      let index = input.input_len();
861      Ok((
862        input.take_from(index),
863        OM::Output::bind(|| input.take(index)),
864      ))
865    }
866  }
867}
868
869/// Matches a byte string with escaped characters.
870///
871/// * The first argument matches the normal characters (it must not match the control character)
872/// * The second argument is the control character (like `\` in most languages)
873/// * The third argument matches the escaped characters and transforms them
874///
875/// As an example, the chain `abc\tdef` could be `abc    def` (it also consumes the control character)
876///
877/// ```
878/// # use nom::{Err, error::ErrorKind, Needed, IResult};
879/// # use std::str::from_utf8;
880/// use nom::bytes::streaming::{escaped_transform, tag};
881/// use nom::character::streaming::alpha1;
882/// use nom::branch::alt;
883/// use nom::combinator::value;
884///
885/// fn parser(input: &str) -> IResult<&str, String> {
886///   escaped_transform(
887///     alpha1,
888///     '\\',
889///     alt((
890///       value("\\", tag("\\")),
891///       value("\"", tag("\"")),
892///       value("\n", tag("n")),
893///     ))
894///   )(input)
895/// }
896///
897/// assert_eq!(parser("ab\\\"cd\""), Ok(("\"", String::from("ab\"cd"))));
898/// ```
899#[cfg(feature = "alloc")]
900#[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
901pub fn escaped_transform<I, Error, F, G, ExtendItem, Output>(
902  normal: F,
903  control_char: char,
904  transform: G,
905) -> impl Parser<I, Output = Output, Error = Error>
906where
907  I: Clone + crate::traits::Offset + Input,
908  I: crate::traits::ExtendInto<Item = ExtendItem, Extender = Output>,
909  <F as Parser<I>>::Output: crate::traits::ExtendInto<Item = ExtendItem, Extender = Output>,
910  <G as Parser<I>>::Output: crate::traits::ExtendInto<Item = ExtendItem, Extender = Output>,
911  <I as Input>::Item: crate::traits::AsChar,
912  F: Parser<I, Error = Error>,
913  G: Parser<I, Error = Error>,
914  Error: ParseError<I>,
915{
916  EscapedTransform {
917    normal,
918    control_char,
919    transform,
920    e: PhantomData,
921    extend: PhantomData,
922    o: PhantomData,
923  }
924}
925
926/// Parser implementation for [escaped_transform]
927pub struct EscapedTransform<F, G, E, ExtendItem, Output> {
928  normal: F,
929  transform: G,
930  control_char: char,
931  e: PhantomData<E>,
932  extend: PhantomData<ExtendItem>,
933  o: PhantomData<Output>,
934}
935
936impl<I, Error: ParseError<I>, F, G, ExtendItem, Output> Parser<I>
937  for EscapedTransform<F, G, Error, ExtendItem, Output>
938where
939  I: Clone + crate::traits::Offset + Input,
940  I: crate::traits::ExtendInto<Item = ExtendItem, Extender = Output>,
941  <F as Parser<I>>::Output: crate::traits::ExtendInto<Item = ExtendItem, Extender = Output>,
942  <G as Parser<I>>::Output: crate::traits::ExtendInto<Item = ExtendItem, Extender = Output>,
943  <I as Input>::Item: crate::traits::AsChar,
944  F: Parser<I, Error = Error>,
945  G: Parser<I, Error = Error>,
946  Error: ParseError<I>,
947{
948  type Output = Output;
949  type Error = Error;
950
951  fn process<OM: OutputMode>(
952    &mut self,
953    input: I,
954  ) -> crate::PResult<OM, I, Self::Output, Self::Error> {
955    let mut index = 0;
956    let mut res = OM::Output::bind(|| input.new_builder());
957
958    while index < input.input_len() {
959      let current_len = input.input_len();
960      let remainder = input.take_from(index);
961      match self.normal.process::<OM>(remainder.clone()) {
962        Ok((i2, o)) => {
963          res = OM::Output::combine(o, res, |o, mut res| {
964            o.extend_into(&mut res);
965            res
966          });
967          if i2.input_len() == 0 {
968            if OM::Incomplete::is_streaming() {
969              return Err(Err::Incomplete(Needed::Unknown));
970            } else {
971              let index = input.input_len();
972              return Ok((input.take_from(index), res));
973            }
974          } else if i2.input_len() == current_len {
975            return Ok((remainder, res));
976          } else {
977            index = input.offset(&i2);
978          }
979        }
980        Err(Err::Error(_)) => {
981          // unwrap() should be safe here since index < $i.input_len()
982          if remainder.iter_elements().next().unwrap().as_char() == self.control_char {
983            let next = index + self.control_char.len_utf8();
984            let input_len = input.input_len();
985
986            if next >= input_len {
987              if OM::Incomplete::is_streaming() {
988                return Err(Err::Incomplete(Needed::Unknown));
989              } else {
990                return Err(Err::Error(OM::Error::bind(|| {
991                  Error::from_error_kind(remainder, ErrorKind::EscapedTransform)
992                })));
993              }
994            } else {
995              match self.transform.process::<OM>(input.take_from(next)) {
996                Ok((i2, o)) => {
997                  res = OM::Output::combine(o, res, |o, mut res| {
998                    o.extend_into(&mut res);
999                    res
1000                  });
1001                  if i2.input_len() == 0 {
1002                    if OM::Incomplete::is_streaming() {
1003                      return Err(Err::Incomplete(Needed::Unknown));
1004                    } else {
1005                      return Ok((input.take_from(input.input_len()), res));
1006                    }
1007                  } else {
1008                    index = input.offset(&i2);
1009                  }
1010                }
1011                Err(Err::Error(e)) => return Err(Err::Error(e)),
1012                Err(Err::Failure(e)) => {
1013                  return Err(Err::Failure(e));
1014                }
1015                Err(Err::Incomplete(i)) => {
1016                  return Err(Err::Incomplete(i));
1017                }
1018              }
1019            }
1020          } else {
1021            if index == 0 {
1022              return Err(Err::Error(OM::Error::bind(|| {
1023                Error::from_error_kind(remainder, ErrorKind::EscapedTransform)
1024              })));
1025            }
1026            return Ok((remainder, res));
1027          }
1028        }
1029        Err(Err::Failure(e)) => {
1030          return Err(Err::Failure(e));
1031        }
1032        Err(Err::Incomplete(i)) => {
1033          return Err(Err::Incomplete(i));
1034        }
1035      }
1036    }
1037
1038    if OM::Incomplete::is_streaming() {
1039      Err(Err::Incomplete(Needed::Unknown))
1040    } else {
1041      Ok((input.take_from(index), res))
1042    }
1043  }
1044}
nom/bytes/mod.rs

nom/bytes/
mod.rs
