1//! Character specific parsers and combinators, complete input version.
2//!
3//! Functions recognizing specific characters.
4
5use crate::branch::alt;
6use crate::combinator::opt;
7use crate::error::ErrorKind;
8use crate::error::ParseError;
9use crate::internal::{Err, IResult};
10use crate::lib::std::ops::{Range, RangeFrom, RangeTo};
11use crate::traits::{
12 AsChar, FindToken, InputIter, InputLength, InputTake, InputTakeAtPosition, Slice,
13};
14use crate::traits::{Compare, CompareResult};
15
16/// Recognizes one character.
17///
18/// *Complete version*: Will return an error if there's not enough input data.
19/// # Example
20///
21/// ```
22/// # use nom::{Err, error::{ErrorKind, Error}, IResult};
23/// # use nom::character::complete::char;
24/// fn parser(i: &str) -> IResult<&str, char> {
25/// char('a')(i)
26/// }
27/// assert_eq!(parser("abc"), Ok(("bc", 'a')));
28/// assert_eq!(parser(" abc"), Err(Err::Error(Error::new(" abc", ErrorKind::Char))));
29/// assert_eq!(parser("bc"), Err(Err::Error(Error::new("bc", ErrorKind::Char))));
30/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Char))));
31/// ```
32pub fn char<I, Error: ParseError<I>>(c: char) -> impl Fn(I) -> IResult<I, char, Error>
33where
34 I: Slice<RangeFrom<usize>> + InputIter,
35 <I as InputIter>::Item: AsChar,
36{
37 move |i: I| match (i).iter_elements().next().map(|t: impl AsChar| {
38 let b: bool = t.as_char() == c;
39 (&c, b)
40 }) {
41 Some((c: &char, true)) => Ok((i.slice(range:c.len()..), c.as_char())),
42 _ => Err(Err::Error(Error::from_char(input:i, c))),
43 }
44}
45
46/// Recognizes one character and checks that it satisfies a predicate
47///
48/// *Complete version*: Will return an error if there's not enough input data.
49/// # Example
50///
51/// ```
52/// # use nom::{Err, error::{ErrorKind, Error}, Needed, IResult};
53/// # use nom::character::complete::satisfy;
54/// fn parser(i: &str) -> IResult<&str, char> {
55/// satisfy(|c| c == 'a' || c == 'b')(i)
56/// }
57/// assert_eq!(parser("abc"), Ok(("bc", 'a')));
58/// assert_eq!(parser("cd"), Err(Err::Error(Error::new("cd", ErrorKind::Satisfy))));
59/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Satisfy))));
60/// ```
61pub fn satisfy<F, I, Error: ParseError<I>>(cond: F) -> impl Fn(I) -> IResult<I, char, Error>
62where
63 I: Slice<RangeFrom<usize>> + InputIter,
64 <I as InputIter>::Item: AsChar,
65 F: Fn(char) -> bool,
66{
67 move |i: I| match (i).iter_elements().next().map(|t: impl AsChar| {
68 let c: char = t.as_char();
69 let b: bool = cond(c);
70 (c, b)
71 }) {
72 Some((c: char, true)) => Ok((i.slice(range:c.len()..), c)),
73 _ => Err(Err::Error(Error::from_error_kind(input:i, kind:ErrorKind::Satisfy))),
74 }
75}
76
77/// Recognizes one of the provided characters.
78///
79/// *Complete version*: Will return an error if there's not enough input data.
80/// # Example
81///
82/// ```
83/// # use nom::{Err, error::ErrorKind};
84/// # use nom::character::complete::one_of;
85/// assert_eq!(one_of::<_, _, (&str, ErrorKind)>("abc")("b"), Ok(("", 'b')));
86/// assert_eq!(one_of::<_, _, (&str, ErrorKind)>("a")("bc"), Err(Err::Error(("bc", ErrorKind::OneOf))));
87/// assert_eq!(one_of::<_, _, (&str, ErrorKind)>("a")(""), Err(Err::Error(("", ErrorKind::OneOf))));
88/// ```
89pub fn one_of<I, T, Error: ParseError<I>>(list: T) -> impl Fn(I) -> IResult<I, char, Error>
90where
91 I: Slice<RangeFrom<usize>> + InputIter,
92 <I as InputIter>::Item: AsChar + Copy,
93 T: FindToken<<I as InputIter>::Item>,
94{
95 move |i: I| match (i).iter_elements().next().map(|c: impl AsChar + Copy| (c, list.find_token(c))) {
96 Some((c: impl AsChar + Copy, true)) => Ok((i.slice(range:c.len()..), c.as_char())),
97 _ => Err(Err::Error(Error::from_error_kind(input:i, kind:ErrorKind::OneOf))),
98 }
99}
100
101/// Recognizes a character that is not in the provided characters.
102///
103/// *Complete version*: Will return an error if there's not enough input data.
104/// # Example
105///
106/// ```
107/// # use nom::{Err, error::ErrorKind};
108/// # use nom::character::complete::none_of;
109/// assert_eq!(none_of::<_, _, (&str, ErrorKind)>("abc")("z"), Ok(("", 'z')));
110/// assert_eq!(none_of::<_, _, (&str, ErrorKind)>("ab")("a"), Err(Err::Error(("a", ErrorKind::NoneOf))));
111/// assert_eq!(none_of::<_, _, (&str, ErrorKind)>("a")(""), Err(Err::Error(("", ErrorKind::NoneOf))));
112/// ```
113pub fn none_of<I, T, Error: ParseError<I>>(list: T) -> impl Fn(I) -> IResult<I, char, Error>
114where
115 I: Slice<RangeFrom<usize>> + InputIter,
116 <I as InputIter>::Item: AsChar + Copy,
117 T: FindToken<<I as InputIter>::Item>,
118{
119 move |i: I| match (i).iter_elements().next().map(|c: impl AsChar + Copy| (c, !list.find_token(c))) {
120 Some((c: impl AsChar + Copy, true)) => Ok((i.slice(range:c.len()..), c.as_char())),
121 _ => Err(Err::Error(Error::from_error_kind(input:i, kind:ErrorKind::NoneOf))),
122 }
123}
124
125/// Recognizes the string "\r\n".
126///
127/// *Complete version*: Will return an error if there's not enough input data.
128/// # Example
129///
130/// ```
131/// # use nom::{Err, error::{Error, ErrorKind}, IResult};
132/// # use nom::character::complete::crlf;
133/// fn parser(input: &str) -> IResult<&str, &str> {
134/// crlf(input)
135/// }
136///
137/// assert_eq!(parser("\r\nc"), Ok(("c", "\r\n")));
138/// assert_eq!(parser("ab\r\nc"), Err(Err::Error(Error::new("ab\r\nc", ErrorKind::CrLf))));
139/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::CrLf))));
140/// ```
141pub fn crlf<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
142where
143 T: Slice<Range<usize>> + Slice<RangeFrom<usize>>,
144 T: InputIter,
145 T: Compare<&'static str>,
146{
147 match input.compare("\r\n") {
148 //FIXME: is this the right index?
149 CompareResult::Ok => Ok((input.slice(range:2..), input.slice(range:0..2))),
150 _ => {
151 let e: ErrorKind = ErrorKind::CrLf;
152 Err(Err::Error(E::from_error_kind(input, kind:e)))
153 }
154 }
155}
156
157//FIXME: there's still an incomplete
158/// Recognizes a string of any char except '\r\n' or '\n'.
159///
160/// *Complete version*: Will return an error if there's not enough input data.
161/// # Example
162///
163/// ```
164/// # use nom::{Err, error::{Error, ErrorKind}, IResult, Needed};
165/// # use nom::character::complete::not_line_ending;
166/// fn parser(input: &str) -> IResult<&str, &str> {
167/// not_line_ending(input)
168/// }
169///
170/// assert_eq!(parser("ab\r\nc"), Ok(("\r\nc", "ab")));
171/// assert_eq!(parser("ab\nc"), Ok(("\nc", "ab")));
172/// assert_eq!(parser("abc"), Ok(("", "abc")));
173/// assert_eq!(parser(""), Ok(("", "")));
174/// assert_eq!(parser("a\rb\nc"), Err(Err::Error(Error { input: "a\rb\nc", code: ErrorKind::Tag })));
175/// assert_eq!(parser("a\rbc"), Err(Err::Error(Error { input: "a\rbc", code: ErrorKind::Tag })));
176/// ```
177pub fn not_line_ending<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
178where
179 T: Slice<Range<usize>> + Slice<RangeFrom<usize>> + Slice<RangeTo<usize>>,
180 T: InputIter + InputLength,
181 T: Compare<&'static str>,
182 <T as InputIter>::Item: AsChar,
183 <T as InputIter>::Item: AsChar,
184{
185 match input.position(|item| {
186 let c = item.as_char();
187 c == '\r' || c == '\n'
188 }) {
189 None => Ok((input.slice(input.input_len()..), input)),
190 Some(index) => {
191 let mut it = input.slice(index..).iter_elements();
192 let nth = it.next().unwrap().as_char();
193 if nth == '\r' {
194 let sliced = input.slice(index..);
195 let comp = sliced.compare("\r\n");
196 match comp {
197 //FIXME: calculate the right index
198 CompareResult::Ok => Ok((input.slice(index..), input.slice(..index))),
199 _ => {
200 let e: ErrorKind = ErrorKind::Tag;
201 Err(Err::Error(E::from_error_kind(input, e)))
202 }
203 }
204 } else {
205 Ok((input.slice(index..), input.slice(..index)))
206 }
207 }
208 }
209}
210
211/// Recognizes an end of line (both '\n' and '\r\n').
212///
213/// *Complete version*: Will return an error if there's not enough input data.
214/// # Example
215///
216/// ```
217/// # use nom::{Err, error::{Error, ErrorKind}, IResult, Needed};
218/// # use nom::character::complete::line_ending;
219/// fn parser(input: &str) -> IResult<&str, &str> {
220/// line_ending(input)
221/// }
222///
223/// assert_eq!(parser("\r\nc"), Ok(("c", "\r\n")));
224/// assert_eq!(parser("ab\r\nc"), Err(Err::Error(Error::new("ab\r\nc", ErrorKind::CrLf))));
225/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::CrLf))));
226/// ```
227pub fn line_ending<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
228where
229 T: Slice<Range<usize>> + Slice<RangeFrom<usize>> + Slice<RangeTo<usize>>,
230 T: InputIter + InputLength,
231 T: Compare<&'static str>,
232{
233 match input.compare("\n") {
234 CompareResult::Ok => Ok((input.slice(range:1..), input.slice(range:0..1))),
235 CompareResult::Incomplete => Err(Err::Error(E::from_error_kind(input, kind:ErrorKind::CrLf))),
236 CompareResult::Error => {
237 match input.compare("\r\n") {
238 //FIXME: is this the right index?
239 CompareResult::Ok => Ok((input.slice(range:2..), input.slice(range:0..2))),
240 _ => Err(Err::Error(E::from_error_kind(input, kind:ErrorKind::CrLf))),
241 }
242 }
243 }
244}
245
246/// Matches a newline character '\n'.
247///
248/// *Complete version*: Will return an error if there's not enough input data.
249/// # Example
250///
251/// ```
252/// # use nom::{Err, error::{Error, ErrorKind}, IResult, Needed};
253/// # use nom::character::complete::newline;
254/// fn parser(input: &str) -> IResult<&str, char> {
255/// newline(input)
256/// }
257///
258/// assert_eq!(parser("\nc"), Ok(("c", '\n')));
259/// assert_eq!(parser("\r\nc"), Err(Err::Error(Error::new("\r\nc", ErrorKind::Char))));
260/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Char))));
261/// ```
262pub fn newline<I, Error: ParseError<I>>(input: I) -> IResult<I, char, Error>
263where
264 I: Slice<RangeFrom<usize>> + InputIter,
265 <I as InputIter>::Item: AsChar,
266{
267 char('\n')(input)
268}
269
270/// Matches a tab character '\t'.
271///
272/// *Complete version*: Will return an error if there's not enough input data.
273/// # Example
274///
275/// ```
276/// # use nom::{Err, error::{Error, ErrorKind}, IResult, Needed};
277/// # use nom::character::complete::tab;
278/// fn parser(input: &str) -> IResult<&str, char> {
279/// tab(input)
280/// }
281///
282/// assert_eq!(parser("\tc"), Ok(("c", '\t')));
283/// assert_eq!(parser("\r\nc"), Err(Err::Error(Error::new("\r\nc", ErrorKind::Char))));
284/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Char))));
285/// ```
286pub fn tab<I, Error: ParseError<I>>(input: I) -> IResult<I, char, Error>
287where
288 I: Slice<RangeFrom<usize>> + InputIter,
289 <I as InputIter>::Item: AsChar,
290{
291 char('\t')(input)
292}
293
294/// Matches one byte as a character. Note that the input type will
295/// accept a `str`, but not a `&[u8]`, unlike many other nom parsers.
296///
297/// *Complete version*: Will return an error if there's not enough input data.
298/// # Example
299///
300/// ```
301/// # use nom::{character::complete::anychar, Err, error::{Error, ErrorKind}, IResult};
302/// fn parser(input: &str) -> IResult<&str, char> {
303/// anychar(input)
304/// }
305///
306/// assert_eq!(parser("abc"), Ok(("bc",'a')));
307/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Eof))));
308/// ```
309pub fn anychar<T, E: ParseError<T>>(input: T) -> IResult<T, char, E>
310where
311 T: InputIter + InputLength + Slice<RangeFrom<usize>>,
312 <T as InputIter>::Item: AsChar,
313{
314 let mut it: impl AsChar = input.iter_indices();
315 match it.next() {
316 None => Err(Err::Error(E::from_error_kind(input, kind:ErrorKind::Eof))),
317 Some((_, c: impl AsChar)) => match it.next() {
318 None => Ok((input.slice(range:input.input_len()..), c.as_char())),
319 Some((idx: usize, _)) => Ok((input.slice(range:idx..), c.as_char())),
320 },
321 }
322}
323
324/// Recognizes zero or more lowercase and uppercase ASCII alphabetic characters: a-z, A-Z
325///
326/// *Complete version*: Will return the whole input if no terminating token is found (a non
327/// alphabetic character).
328/// # Example
329///
330/// ```
331/// # use nom::{Err, error::ErrorKind, IResult, Needed};
332/// # use nom::character::complete::alpha0;
333/// fn parser(input: &str) -> IResult<&str, &str> {
334/// alpha0(input)
335/// }
336///
337/// assert_eq!(parser("ab1c"), Ok(("1c", "ab")));
338/// assert_eq!(parser("1c"), Ok(("1c", "")));
339/// assert_eq!(parser(""), Ok(("", "")));
340/// ```
341pub fn alpha0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
342where
343 T: InputTakeAtPosition,
344 <T as InputTakeAtPosition>::Item: AsChar,
345{
346 input.split_at_position_complete(|item: impl AsChar| !item.is_alpha())
347}
348
349/// Recognizes one or more lowercase and uppercase ASCII alphabetic characters: a-z, A-Z
350///
351/// *Complete version*: Will return an error if there's not enough input data,
352/// or the whole input if no terminating token is found (a non alphabetic character).
353/// # Example
354///
355/// ```
356/// # use nom::{Err, error::{Error, ErrorKind}, IResult, Needed};
357/// # use nom::character::complete::alpha1;
358/// fn parser(input: &str) -> IResult<&str, &str> {
359/// alpha1(input)
360/// }
361///
362/// assert_eq!(parser("aB1c"), Ok(("1c", "aB")));
363/// assert_eq!(parser("1c"), Err(Err::Error(Error::new("1c", ErrorKind::Alpha))));
364/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Alpha))));
365/// ```
366pub fn alpha1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
367where
368 T: InputTakeAtPosition,
369 <T as InputTakeAtPosition>::Item: AsChar,
370{
371 input.split_at_position1_complete(|item| !item.is_alpha(), e:ErrorKind::Alpha)
372}
373
374/// Recognizes zero or more ASCII numerical characters: 0-9
375///
376/// *Complete version*: Will return an error if there's not enough input data,
377/// or the whole input if no terminating token is found (a non digit character).
378/// # Example
379///
380/// ```
381/// # use nom::{Err, error::ErrorKind, IResult, Needed};
382/// # use nom::character::complete::digit0;
383/// fn parser(input: &str) -> IResult<&str, &str> {
384/// digit0(input)
385/// }
386///
387/// assert_eq!(parser("21c"), Ok(("c", "21")));
388/// assert_eq!(parser("21"), Ok(("", "21")));
389/// assert_eq!(parser("a21c"), Ok(("a21c", "")));
390/// assert_eq!(parser(""), Ok(("", "")));
391/// ```
392pub fn digit0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
393where
394 T: InputTakeAtPosition,
395 <T as InputTakeAtPosition>::Item: AsChar,
396{
397 input.split_at_position_complete(|item: impl AsChar| !item.is_dec_digit())
398}
399
400/// Recognizes one or more ASCII numerical characters: 0-9
401///
402/// *Complete version*: Will return an error if there's not enough input data,
403/// or the whole input if no terminating token is found (a non digit character).
404/// # Example
405///
406/// ```
407/// # use nom::{Err, error::{Error, ErrorKind}, IResult, Needed};
408/// # use nom::character::complete::digit1;
409/// fn parser(input: &str) -> IResult<&str, &str> {
410/// digit1(input)
411/// }
412///
413/// assert_eq!(parser("21c"), Ok(("c", "21")));
414/// assert_eq!(parser("c1"), Err(Err::Error(Error::new("c1", ErrorKind::Digit))));
415/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Digit))));
416/// ```
417///
418/// ## Parsing an integer
419/// You can use `digit1` in combination with [`map_res`] to parse an integer:
420///
421/// ```
422/// # use nom::{Err, error::{Error, ErrorKind}, IResult, Needed};
423/// # use nom::combinator::map_res;
424/// # use nom::character::complete::digit1;
425/// fn parser(input: &str) -> IResult<&str, u32> {
426/// map_res(digit1, str::parse)(input)
427/// }
428///
429/// assert_eq!(parser("416"), Ok(("", 416)));
430/// assert_eq!(parser("12b"), Ok(("b", 12)));
431/// assert!(parser("b").is_err());
432/// ```
433///
434/// [`map_res`]: crate::combinator::map_res
435pub fn digit1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
436where
437 T: InputTakeAtPosition,
438 <T as InputTakeAtPosition>::Item: AsChar,
439{
440 input.split_at_position1_complete(|item| !item.is_dec_digit(), e:ErrorKind::Digit)
441}
442
443/// Recognizes zero or more ASCII hexadecimal numerical characters: 0-9, A-F, a-f
444///
445/// *Complete version*: Will return the whole input if no terminating token is found (a non hexadecimal digit character).
446/// # Example
447///
448/// ```
449/// # use nom::{Err, error::ErrorKind, IResult, Needed};
450/// # use nom::character::complete::hex_digit0;
451/// fn parser(input: &str) -> IResult<&str, &str> {
452/// hex_digit0(input)
453/// }
454///
455/// assert_eq!(parser("21cZ"), Ok(("Z", "21c")));
456/// assert_eq!(parser("Z21c"), Ok(("Z21c", "")));
457/// assert_eq!(parser(""), Ok(("", "")));
458/// ```
459pub fn hex_digit0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
460where
461 T: InputTakeAtPosition,
462 <T as InputTakeAtPosition>::Item: AsChar,
463{
464 input.split_at_position_complete(|item: impl AsChar| !item.is_hex_digit())
465}
466/// Recognizes one or more ASCII hexadecimal numerical characters: 0-9, A-F, a-f
467///
468/// *Complete version*: Will return an error if there's not enough input data,
469/// or the whole input if no terminating token is found (a non hexadecimal digit character).
470/// # Example
471///
472/// ```
473/// # use nom::{Err, error::{Error, ErrorKind}, IResult, Needed};
474/// # use nom::character::complete::hex_digit1;
475/// fn parser(input: &str) -> IResult<&str, &str> {
476/// hex_digit1(input)
477/// }
478///
479/// assert_eq!(parser("21cZ"), Ok(("Z", "21c")));
480/// assert_eq!(parser("H2"), Err(Err::Error(Error::new("H2", ErrorKind::HexDigit))));
481/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::HexDigit))));
482/// ```
483pub fn hex_digit1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
484where
485 T: InputTakeAtPosition,
486 <T as InputTakeAtPosition>::Item: AsChar,
487{
488 input.split_at_position1_complete(|item| !item.is_hex_digit(), e:ErrorKind::HexDigit)
489}
490
491/// Recognizes zero or more octal characters: 0-7
492///
493/// *Complete version*: Will return the whole input if no terminating token is found (a non octal
494/// digit character).
495/// # Example
496///
497/// ```
498/// # use nom::{Err, error::ErrorKind, IResult, Needed};
499/// # use nom::character::complete::oct_digit0;
500/// fn parser(input: &str) -> IResult<&str, &str> {
501/// oct_digit0(input)
502/// }
503///
504/// assert_eq!(parser("21cZ"), Ok(("cZ", "21")));
505/// assert_eq!(parser("Z21c"), Ok(("Z21c", "")));
506/// assert_eq!(parser(""), Ok(("", "")));
507/// ```
508pub fn oct_digit0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
509where
510 T: InputTakeAtPosition,
511 <T as InputTakeAtPosition>::Item: AsChar,
512{
513 input.split_at_position_complete(|item: impl AsChar| !item.is_oct_digit())
514}
515
516/// Recognizes one or more octal characters: 0-7
517///
518/// *Complete version*: Will return an error if there's not enough input data,
519/// or the whole input if no terminating token is found (a non octal digit character).
520/// # Example
521///
522/// ```
523/// # use nom::{Err, error::{Error, ErrorKind}, IResult, Needed};
524/// # use nom::character::complete::oct_digit1;
525/// fn parser(input: &str) -> IResult<&str, &str> {
526/// oct_digit1(input)
527/// }
528///
529/// assert_eq!(parser("21cZ"), Ok(("cZ", "21")));
530/// assert_eq!(parser("H2"), Err(Err::Error(Error::new("H2", ErrorKind::OctDigit))));
531/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::OctDigit))));
532/// ```
533pub fn oct_digit1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
534where
535 T: InputTakeAtPosition,
536 <T as InputTakeAtPosition>::Item: AsChar,
537{
538 input.split_at_position1_complete(|item| !item.is_oct_digit(), e:ErrorKind::OctDigit)
539}
540
541/// Recognizes zero or more ASCII numerical and alphabetic characters: 0-9, a-z, A-Z
542///
543/// *Complete version*: Will return the whole input if no terminating token is found (a non
544/// alphanumerical character).
545/// # Example
546///
547/// ```
548/// # use nom::{Err, error::ErrorKind, IResult, Needed};
549/// # use nom::character::complete::alphanumeric0;
550/// fn parser(input: &str) -> IResult<&str, &str> {
551/// alphanumeric0(input)
552/// }
553///
554/// assert_eq!(parser("21cZ%1"), Ok(("%1", "21cZ")));
555/// assert_eq!(parser("&Z21c"), Ok(("&Z21c", "")));
556/// assert_eq!(parser(""), Ok(("", "")));
557/// ```
558pub fn alphanumeric0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
559where
560 T: InputTakeAtPosition,
561 <T as InputTakeAtPosition>::Item: AsChar,
562{
563 input.split_at_position_complete(|item: impl AsChar| !item.is_alphanum())
564}
565
566/// Recognizes one or more ASCII numerical and alphabetic characters: 0-9, a-z, A-Z
567///
568/// *Complete version*: Will return an error if there's not enough input data,
569/// or the whole input if no terminating token is found (a non alphanumerical character).
570/// # Example
571///
572/// ```
573/// # use nom::{Err, error::{Error, ErrorKind}, IResult, Needed};
574/// # use nom::character::complete::alphanumeric1;
575/// fn parser(input: &str) -> IResult<&str, &str> {
576/// alphanumeric1(input)
577/// }
578///
579/// assert_eq!(parser("21cZ%1"), Ok(("%1", "21cZ")));
580/// assert_eq!(parser("&H2"), Err(Err::Error(Error::new("&H2", ErrorKind::AlphaNumeric))));
581/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::AlphaNumeric))));
582/// ```
583pub fn alphanumeric1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
584where
585 T: InputTakeAtPosition,
586 <T as InputTakeAtPosition>::Item: AsChar,
587{
588 input.split_at_position1_complete(|item| !item.is_alphanum(), e:ErrorKind::AlphaNumeric)
589}
590
591/// Recognizes zero or more spaces and tabs.
592///
593/// *Complete version*: Will return the whole input if no terminating token is found (a non space
594/// character).
595/// # Example
596///
597/// ```
598/// # use nom::{Err, error::ErrorKind, IResult, Needed};
599/// # use nom::character::complete::space0;
600/// fn parser(input: &str) -> IResult<&str, &str> {
601/// space0(input)
602/// }
603///
604/// assert_eq!(parser(" \t21c"), Ok(("21c", " \t")));
605/// assert_eq!(parser("Z21c"), Ok(("Z21c", "")));
606/// assert_eq!(parser(""), Ok(("", "")));
607/// ```
608pub fn space0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
609where
610 T: InputTakeAtPosition,
611 <T as InputTakeAtPosition>::Item: AsChar + Clone,
612{
613 input.split_at_position_complete(|item: impl AsChar + Clone| {
614 let c: char = item.as_char();
615 !(c == ' ' || c == '\t')
616 })
617}
618
619/// Recognizes one or more spaces and tabs.
620///
621/// *Complete version*: Will return an error if there's not enough input data,
622/// or the whole input if no terminating token is found (a non space character).
623/// # Example
624///
625/// ```
626/// # use nom::{Err, error::{Error, ErrorKind}, IResult, Needed};
627/// # use nom::character::complete::space1;
628/// fn parser(input: &str) -> IResult<&str, &str> {
629/// space1(input)
630/// }
631///
632/// assert_eq!(parser(" \t21c"), Ok(("21c", " \t")));
633/// assert_eq!(parser("H2"), Err(Err::Error(Error::new("H2", ErrorKind::Space))));
634/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Space))));
635/// ```
636pub fn space1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
637where
638 T: InputTakeAtPosition,
639 <T as InputTakeAtPosition>::Item: AsChar + Clone,
640{
641 input.split_at_position1_complete(
642 |item| {
643 let c = item.as_char();
644 !(c == ' ' || c == '\t')
645 },
646 e:ErrorKind::Space,
647 )
648}
649
650/// Recognizes zero or more spaces, tabs, carriage returns and line feeds.
651///
652/// *Complete version*: will return the whole input if no terminating token is found (a non space
653/// character).
654/// # Example
655///
656/// ```
657/// # use nom::{Err, error::ErrorKind, IResult, Needed};
658/// # use nom::character::complete::multispace0;
659/// fn parser(input: &str) -> IResult<&str, &str> {
660/// multispace0(input)
661/// }
662///
663/// assert_eq!(parser(" \t\n\r21c"), Ok(("21c", " \t\n\r")));
664/// assert_eq!(parser("Z21c"), Ok(("Z21c", "")));
665/// assert_eq!(parser(""), Ok(("", "")));
666/// ```
667pub fn multispace0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
668where
669 T: InputTakeAtPosition,
670 <T as InputTakeAtPosition>::Item: AsChar + Clone,
671{
672 input.split_at_position_complete(|item: impl AsChar + Clone| {
673 let c: char = item.as_char();
674 !(c == ' ' || c == '\t' || c == '\r' || c == '\n')
675 })
676}
677
678/// Recognizes one or more spaces, tabs, carriage returns and line feeds.
679///
680/// *Complete version*: will return an error if there's not enough input data,
681/// or the whole input if no terminating token is found (a non space character).
682/// # Example
683///
684/// ```
685/// # use nom::{Err, error::{Error, ErrorKind}, IResult, Needed};
686/// # use nom::character::complete::multispace1;
687/// fn parser(input: &str) -> IResult<&str, &str> {
688/// multispace1(input)
689/// }
690///
691/// assert_eq!(parser(" \t\n\r21c"), Ok(("21c", " \t\n\r")));
692/// assert_eq!(parser("H2"), Err(Err::Error(Error::new("H2", ErrorKind::MultiSpace))));
693/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::MultiSpace))));
694/// ```
695pub fn multispace1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
696where
697 T: InputTakeAtPosition,
698 <T as InputTakeAtPosition>::Item: AsChar + Clone,
699{
700 input.split_at_position1_complete(
701 |item| {
702 let c = item.as_char();
703 !(c == ' ' || c == '\t' || c == '\r' || c == '\n')
704 },
705 e:ErrorKind::MultiSpace,
706 )
707}
708
709pub(crate) fn sign<T, E: ParseError<T>>(input: T) -> IResult<T, bool, E>
710where
711 T: Clone + InputTake,
712 T: for<'a> dynCompare<&'a [u8]>,
713{
714 use crate::bytes::complete::tag;
715 use crate::combinator::value;
716
717 let (i: T, opt_sign: Option) = opt(alt((
718 value(val:false, parser:tag(&b"-"[..])),
719 value(val:true, parser:tag(&b"+"[..])),
720 )))(input)?;
721 let sign: bool = opt_sign.unwrap_or(default:true);
722
723 Ok((i, sign))
724}
725
726#[doc(hidden)]
727macro_rules! ints {
728 ($($t:tt)+) => {
729 $(
730 /// will parse a number in text form to a number
731 ///
732 /// *Complete version*: can parse until the end of input.
733 pub fn $t<T, E: ParseError<T>>(input: T) -> IResult<T, $t, E>
734 where
735 T: InputIter + Slice<RangeFrom<usize>> + InputLength + InputTake + Clone,
736 <T as InputIter>::Item: AsChar,
737 T: for <'a> Compare<&'a[u8]>,
738 {
739 let (i, sign) = sign(input.clone())?;
740
741 if i.input_len() == 0 {
742 return Err(Err::Error(E::from_error_kind(input, ErrorKind::Digit)));
743 }
744
745 let mut value: $t = 0;
746 if sign {
747 for (pos, c) in i.iter_indices() {
748 match c.as_char().to_digit(10) {
749 None => {
750 if pos == 0 {
751 return Err(Err::Error(E::from_error_kind(input, ErrorKind::Digit)));
752 } else {
753 return Ok((i.slice(pos..), value));
754 }
755 },
756 Some(d) => match value.checked_mul(10).and_then(|v| v.checked_add(d as $t)) {
757 None => return Err(Err::Error(E::from_error_kind(input, ErrorKind::Digit))),
758 Some(v) => value = v,
759 }
760 }
761 }
762 } else {
763 for (pos, c) in i.iter_indices() {
764 match c.as_char().to_digit(10) {
765 None => {
766 if pos == 0 {
767 return Err(Err::Error(E::from_error_kind(input, ErrorKind::Digit)));
768 } else {
769 return Ok((i.slice(pos..), value));
770 }
771 },
772 Some(d) => match value.checked_mul(10).and_then(|v| v.checked_sub(d as $t)) {
773 None => return Err(Err::Error(E::from_error_kind(input, ErrorKind::Digit))),
774 Some(v) => value = v,
775 }
776 }
777 }
778 }
779
780 Ok((i.slice(i.input_len()..), value))
781 }
782 )+
783 }
784}
785
786ints! { i8 i16 i32 i64 i128 }
787
788#[doc(hidden)]
789macro_rules! uints {
790 ($($t:tt)+) => {
791 $(
792 /// will parse a number in text form to a number
793 ///
794 /// *Complete version*: can parse until the end of input.
795 pub fn $t<T, E: ParseError<T>>(input: T) -> IResult<T, $t, E>
796 where
797 T: InputIter + Slice<RangeFrom<usize>> + InputLength,
798 <T as InputIter>::Item: AsChar,
799 {
800 let i = input;
801
802 if i.input_len() == 0 {
803 return Err(Err::Error(E::from_error_kind(i, ErrorKind::Digit)));
804 }
805
806 let mut value: $t = 0;
807 for (pos, c) in i.iter_indices() {
808 match c.as_char().to_digit(10) {
809 None => {
810 if pos == 0 {
811 return Err(Err::Error(E::from_error_kind(i, ErrorKind::Digit)));
812 } else {
813 return Ok((i.slice(pos..), value));
814 }
815 },
816 Some(d) => match value.checked_mul(10).and_then(|v| v.checked_add(d as $t)) {
817 None => return Err(Err::Error(E::from_error_kind(i, ErrorKind::Digit))),
818 Some(v) => value = v,
819 }
820 }
821 }
822
823 Ok((i.slice(i.input_len()..), value))
824 }
825 )+
826 }
827}
828
829uints! { u8 u16 u32 u64 u128 }
830
831#[cfg(test)]
832mod tests {
833 use super::*;
834 use crate::internal::Err;
835 use crate::traits::ParseTo;
836 use proptest::prelude::*;
837
838 macro_rules! assert_parse(
839 ($left: expr, $right: expr) => {
840 let res: $crate::IResult<_, _, (_, ErrorKind)> = $left;
841 assert_eq!(res, $right);
842 };
843 );
844
845 #[test]
846 fn character() {
847 let empty: &[u8] = b"";
848 let a: &[u8] = b"abcd";
849 let b: &[u8] = b"1234";
850 let c: &[u8] = b"a123";
851 let d: &[u8] = "azé12".as_bytes();
852 let e: &[u8] = b" ";
853 let f: &[u8] = b" ;";
854 //assert_eq!(alpha1::<_, (_, ErrorKind)>(a), Err(Err::Incomplete(Needed::Size(1))));
855 assert_parse!(alpha1(a), Ok((empty, a)));
856 assert_eq!(alpha1(b), Err(Err::Error((b, ErrorKind::Alpha))));
857 assert_eq!(alpha1::<_, (_, ErrorKind)>(c), Ok((&c[1..], &b"a"[..])));
858 assert_eq!(
859 alpha1::<_, (_, ErrorKind)>(d),
860 Ok(("é12".as_bytes(), &b"az"[..]))
861 );
862 assert_eq!(digit1(a), Err(Err::Error((a, ErrorKind::Digit))));
863 assert_eq!(digit1::<_, (_, ErrorKind)>(b), Ok((empty, b)));
864 assert_eq!(digit1(c), Err(Err::Error((c, ErrorKind::Digit))));
865 assert_eq!(digit1(d), Err(Err::Error((d, ErrorKind::Digit))));
866 assert_eq!(hex_digit1::<_, (_, ErrorKind)>(a), Ok((empty, a)));
867 assert_eq!(hex_digit1::<_, (_, ErrorKind)>(b), Ok((empty, b)));
868 assert_eq!(hex_digit1::<_, (_, ErrorKind)>(c), Ok((empty, c)));
869 assert_eq!(
870 hex_digit1::<_, (_, ErrorKind)>(d),
871 Ok(("zé12".as_bytes(), &b"a"[..]))
872 );
873 assert_eq!(hex_digit1(e), Err(Err::Error((e, ErrorKind::HexDigit))));
874 assert_eq!(oct_digit1(a), Err(Err::Error((a, ErrorKind::OctDigit))));
875 assert_eq!(oct_digit1::<_, (_, ErrorKind)>(b), Ok((empty, b)));
876 assert_eq!(oct_digit1(c), Err(Err::Error((c, ErrorKind::OctDigit))));
877 assert_eq!(oct_digit1(d), Err(Err::Error((d, ErrorKind::OctDigit))));
878 assert_eq!(alphanumeric1::<_, (_, ErrorKind)>(a), Ok((empty, a)));
879 //assert_eq!(fix_error!(b,(), alphanumeric), Ok((empty, b)));
880 assert_eq!(alphanumeric1::<_, (_, ErrorKind)>(c), Ok((empty, c)));
881 assert_eq!(
882 alphanumeric1::<_, (_, ErrorKind)>(d),
883 Ok(("é12".as_bytes(), &b"az"[..]))
884 );
885 assert_eq!(space1::<_, (_, ErrorKind)>(e), Ok((empty, e)));
886 assert_eq!(space1::<_, (_, ErrorKind)>(f), Ok((&b";"[..], &b" "[..])));
887 }
888
889 #[cfg(feature = "alloc")]
890 #[test]
891 fn character_s() {
892 let empty = "";
893 let a = "abcd";
894 let b = "1234";
895 let c = "a123";
896 let d = "azé12";
897 let e = " ";
898 assert_eq!(alpha1::<_, (_, ErrorKind)>(a), Ok((empty, a)));
899 assert_eq!(alpha1(b), Err(Err::Error((b, ErrorKind::Alpha))));
900 assert_eq!(alpha1::<_, (_, ErrorKind)>(c), Ok((&c[1..], &"a"[..])));
901 assert_eq!(alpha1::<_, (_, ErrorKind)>(d), Ok(("é12", &"az"[..])));
902 assert_eq!(digit1(a), Err(Err::Error((a, ErrorKind::Digit))));
903 assert_eq!(digit1::<_, (_, ErrorKind)>(b), Ok((empty, b)));
904 assert_eq!(digit1(c), Err(Err::Error((c, ErrorKind::Digit))));
905 assert_eq!(digit1(d), Err(Err::Error((d, ErrorKind::Digit))));
906 assert_eq!(hex_digit1::<_, (_, ErrorKind)>(a), Ok((empty, a)));
907 assert_eq!(hex_digit1::<_, (_, ErrorKind)>(b), Ok((empty, b)));
908 assert_eq!(hex_digit1::<_, (_, ErrorKind)>(c), Ok((empty, c)));
909 assert_eq!(hex_digit1::<_, (_, ErrorKind)>(d), Ok(("zé12", &"a"[..])));
910 assert_eq!(hex_digit1(e), Err(Err::Error((e, ErrorKind::HexDigit))));
911 assert_eq!(oct_digit1(a), Err(Err::Error((a, ErrorKind::OctDigit))));
912 assert_eq!(oct_digit1::<_, (_, ErrorKind)>(b), Ok((empty, b)));
913 assert_eq!(oct_digit1(c), Err(Err::Error((c, ErrorKind::OctDigit))));
914 assert_eq!(oct_digit1(d), Err(Err::Error((d, ErrorKind::OctDigit))));
915 assert_eq!(alphanumeric1::<_, (_, ErrorKind)>(a), Ok((empty, a)));
916 //assert_eq!(fix_error!(b,(), alphanumeric), Ok((empty, b)));
917 assert_eq!(alphanumeric1::<_, (_, ErrorKind)>(c), Ok((empty, c)));
918 assert_eq!(alphanumeric1::<_, (_, ErrorKind)>(d), Ok(("é12", "az")));
919 assert_eq!(space1::<_, (_, ErrorKind)>(e), Ok((empty, e)));
920 }
921
922 use crate::traits::Offset;
923 #[test]
924 fn offset() {
925 let a = &b"abcd;"[..];
926 let b = &b"1234;"[..];
927 let c = &b"a123;"[..];
928 let d = &b" \t;"[..];
929 let e = &b" \t\r\n;"[..];
930 let f = &b"123abcDEF;"[..];
931
932 match alpha1::<_, (_, ErrorKind)>(a) {
933 Ok((i, _)) => {
934 assert_eq!(a.offset(i) + i.len(), a.len());
935 }
936 _ => panic!("wrong return type in offset test for alpha"),
937 }
938 match digit1::<_, (_, ErrorKind)>(b) {
939 Ok((i, _)) => {
940 assert_eq!(b.offset(i) + i.len(), b.len());
941 }
942 _ => panic!("wrong return type in offset test for digit"),
943 }
944 match alphanumeric1::<_, (_, ErrorKind)>(c) {
945 Ok((i, _)) => {
946 assert_eq!(c.offset(i) + i.len(), c.len());
947 }
948 _ => panic!("wrong return type in offset test for alphanumeric"),
949 }
950 match space1::<_, (_, ErrorKind)>(d) {
951 Ok((i, _)) => {
952 assert_eq!(d.offset(i) + i.len(), d.len());
953 }
954 _ => panic!("wrong return type in offset test for space"),
955 }
956 match multispace1::<_, (_, ErrorKind)>(e) {
957 Ok((i, _)) => {
958 assert_eq!(e.offset(i) + i.len(), e.len());
959 }
960 _ => panic!("wrong return type in offset test for multispace"),
961 }
962 match hex_digit1::<_, (_, ErrorKind)>(f) {
963 Ok((i, _)) => {
964 assert_eq!(f.offset(i) + i.len(), f.len());
965 }
966 _ => panic!("wrong return type in offset test for hex_digit"),
967 }
968 match oct_digit1::<_, (_, ErrorKind)>(f) {
969 Ok((i, _)) => {
970 assert_eq!(f.offset(i) + i.len(), f.len());
971 }
972 _ => panic!("wrong return type in offset test for oct_digit"),
973 }
974 }
975
976 #[test]
977 fn is_not_line_ending_bytes() {
978 let a: &[u8] = b"ab12cd\nefgh";
979 assert_eq!(
980 not_line_ending::<_, (_, ErrorKind)>(a),
981 Ok((&b"\nefgh"[..], &b"ab12cd"[..]))
982 );
983
984 let b: &[u8] = b"ab12cd\nefgh\nijkl";
985 assert_eq!(
986 not_line_ending::<_, (_, ErrorKind)>(b),
987 Ok((&b"\nefgh\nijkl"[..], &b"ab12cd"[..]))
988 );
989
990 let c: &[u8] = b"ab12cd\r\nefgh\nijkl";
991 assert_eq!(
992 not_line_ending::<_, (_, ErrorKind)>(c),
993 Ok((&b"\r\nefgh\nijkl"[..], &b"ab12cd"[..]))
994 );
995
996 let d: &[u8] = b"ab12cd";
997 assert_eq!(
998 not_line_ending::<_, (_, ErrorKind)>(d),
999 Ok((&[][..], &d[..]))
1000 );
1001 }
1002
1003 #[test]
1004 fn is_not_line_ending_str() {
1005 /*
1006 let a: &str = "ab12cd\nefgh";
1007 assert_eq!(not_line_ending(a), Ok((&"\nefgh"[..], &"ab12cd"[..])));
1008
1009 let b: &str = "ab12cd\nefgh\nijkl";
1010 assert_eq!(not_line_ending(b), Ok((&"\nefgh\nijkl"[..], &"ab12cd"[..])));
1011
1012 let c: &str = "ab12cd\r\nefgh\nijkl";
1013 assert_eq!(not_line_ending(c), Ok((&"\r\nefgh\nijkl"[..], &"ab12cd"[..])));
1014
1015 let d = "βèƒôřè\nÂßÇáƒƭèř";
1016 assert_eq!(not_line_ending(d), Ok((&"\nÂßÇáƒƭèř"[..], &"βèƒôřè"[..])));
1017
1018 let e = "βèƒôřè\r\nÂßÇáƒƭèř";
1019 assert_eq!(not_line_ending(e), Ok((&"\r\nÂßÇáƒƭèř"[..], &"βèƒôřè"[..])));
1020 */
1021
1022 let f = "βèƒôřè\rÂßÇáƒƭèř";
1023 assert_eq!(not_line_ending(f), Err(Err::Error((f, ErrorKind::Tag))));
1024
1025 let g2: &str = "ab12cd";
1026 assert_eq!(not_line_ending::<_, (_, ErrorKind)>(g2), Ok(("", g2)));
1027 }
1028
1029 #[test]
1030 fn hex_digit_test() {
1031 let i = &b"0123456789abcdefABCDEF;"[..];
1032 assert_parse!(hex_digit1(i), Ok((&b";"[..], &i[..i.len() - 1])));
1033
1034 let i = &b"g"[..];
1035 assert_parse!(
1036 hex_digit1(i),
1037 Err(Err::Error(error_position!(i, ErrorKind::HexDigit)))
1038 );
1039
1040 let i = &b"G"[..];
1041 assert_parse!(
1042 hex_digit1(i),
1043 Err(Err::Error(error_position!(i, ErrorKind::HexDigit)))
1044 );
1045
1046 assert!(crate::character::is_hex_digit(b'0'));
1047 assert!(crate::character::is_hex_digit(b'9'));
1048 assert!(crate::character::is_hex_digit(b'a'));
1049 assert!(crate::character::is_hex_digit(b'f'));
1050 assert!(crate::character::is_hex_digit(b'A'));
1051 assert!(crate::character::is_hex_digit(b'F'));
1052 assert!(!crate::character::is_hex_digit(b'g'));
1053 assert!(!crate::character::is_hex_digit(b'G'));
1054 assert!(!crate::character::is_hex_digit(b'/'));
1055 assert!(!crate::character::is_hex_digit(b':'));
1056 assert!(!crate::character::is_hex_digit(b'@'));
1057 assert!(!crate::character::is_hex_digit(b'\x60'));
1058 }
1059
1060 #[test]
1061 fn oct_digit_test() {
1062 let i = &b"01234567;"[..];
1063 assert_parse!(oct_digit1(i), Ok((&b";"[..], &i[..i.len() - 1])));
1064
1065 let i = &b"8"[..];
1066 assert_parse!(
1067 oct_digit1(i),
1068 Err(Err::Error(error_position!(i, ErrorKind::OctDigit)))
1069 );
1070
1071 assert!(crate::character::is_oct_digit(b'0'));
1072 assert!(crate::character::is_oct_digit(b'7'));
1073 assert!(!crate::character::is_oct_digit(b'8'));
1074 assert!(!crate::character::is_oct_digit(b'9'));
1075 assert!(!crate::character::is_oct_digit(b'a'));
1076 assert!(!crate::character::is_oct_digit(b'A'));
1077 assert!(!crate::character::is_oct_digit(b'/'));
1078 assert!(!crate::character::is_oct_digit(b':'));
1079 assert!(!crate::character::is_oct_digit(b'@'));
1080 assert!(!crate::character::is_oct_digit(b'\x60'));
1081 }
1082
1083 #[test]
1084 fn full_line_windows() {
1085 use crate::sequence::pair;
1086 fn take_full_line(i: &[u8]) -> IResult<&[u8], (&[u8], &[u8])> {
1087 pair(not_line_ending, line_ending)(i)
1088 }
1089 let input = b"abc\r\n";
1090 let output = take_full_line(input);
1091 assert_eq!(output, Ok((&b""[..], (&b"abc"[..], &b"\r\n"[..]))));
1092 }
1093
1094 #[test]
1095 fn full_line_unix() {
1096 use crate::sequence::pair;
1097 fn take_full_line(i: &[u8]) -> IResult<&[u8], (&[u8], &[u8])> {
1098 pair(not_line_ending, line_ending)(i)
1099 }
1100 let input = b"abc\n";
1101 let output = take_full_line(input);
1102 assert_eq!(output, Ok((&b""[..], (&b"abc"[..], &b"\n"[..]))));
1103 }
1104
1105 #[test]
1106 fn check_windows_lineending() {
1107 let input = b"\r\n";
1108 let output = line_ending(&input[..]);
1109 assert_parse!(output, Ok((&b""[..], &b"\r\n"[..])));
1110 }
1111
1112 #[test]
1113 fn check_unix_lineending() {
1114 let input = b"\n";
1115 let output = line_ending(&input[..]);
1116 assert_parse!(output, Ok((&b""[..], &b"\n"[..])));
1117 }
1118
1119 #[test]
1120 fn cr_lf() {
1121 assert_parse!(crlf(&b"\r\na"[..]), Ok((&b"a"[..], &b"\r\n"[..])));
1122 assert_parse!(
1123 crlf(&b"\r"[..]),
1124 Err(Err::Error(error_position!(&b"\r"[..], ErrorKind::CrLf)))
1125 );
1126 assert_parse!(
1127 crlf(&b"\ra"[..]),
1128 Err(Err::Error(error_position!(&b"\ra"[..], ErrorKind::CrLf)))
1129 );
1130
1131 assert_parse!(crlf("\r\na"), Ok(("a", "\r\n")));
1132 assert_parse!(
1133 crlf("\r"),
1134 Err(Err::Error(error_position!(&"\r"[..], ErrorKind::CrLf)))
1135 );
1136 assert_parse!(
1137 crlf("\ra"),
1138 Err(Err::Error(error_position!("\ra", ErrorKind::CrLf)))
1139 );
1140 }
1141
1142 #[test]
1143 fn end_of_line() {
1144 assert_parse!(line_ending(&b"\na"[..]), Ok((&b"a"[..], &b"\n"[..])));
1145 assert_parse!(line_ending(&b"\r\na"[..]), Ok((&b"a"[..], &b"\r\n"[..])));
1146 assert_parse!(
1147 line_ending(&b"\r"[..]),
1148 Err(Err::Error(error_position!(&b"\r"[..], ErrorKind::CrLf)))
1149 );
1150 assert_parse!(
1151 line_ending(&b"\ra"[..]),
1152 Err(Err::Error(error_position!(&b"\ra"[..], ErrorKind::CrLf)))
1153 );
1154
1155 assert_parse!(line_ending("\na"), Ok(("a", "\n")));
1156 assert_parse!(line_ending("\r\na"), Ok(("a", "\r\n")));
1157 assert_parse!(
1158 line_ending("\r"),
1159 Err(Err::Error(error_position!(&"\r"[..], ErrorKind::CrLf)))
1160 );
1161 assert_parse!(
1162 line_ending("\ra"),
1163 Err(Err::Error(error_position!("\ra", ErrorKind::CrLf)))
1164 );
1165 }
1166
1167 fn digit_to_i16(input: &str) -> IResult<&str, i16> {
1168 let i = input;
1169 let (i, opt_sign) = opt(alt((char('+'), char('-'))))(i)?;
1170 let sign = match opt_sign {
1171 Some('+') => true,
1172 Some('-') => false,
1173 _ => true,
1174 };
1175
1176 let (i, s) = match digit1::<_, crate::error::Error<_>>(i) {
1177 Ok((i, s)) => (i, s),
1178 Err(_) => {
1179 return Err(Err::Error(crate::error::Error::from_error_kind(
1180 input,
1181 ErrorKind::Digit,
1182 )))
1183 }
1184 };
1185
1186 match s.parse_to() {
1187 Some(n) => {
1188 if sign {
1189 Ok((i, n))
1190 } else {
1191 Ok((i, -n))
1192 }
1193 }
1194 None => Err(Err::Error(crate::error::Error::from_error_kind(
1195 i,
1196 ErrorKind::Digit,
1197 ))),
1198 }
1199 }
1200
1201 fn digit_to_u32(i: &str) -> IResult<&str, u32> {
1202 let (i, s) = digit1(i)?;
1203 match s.parse_to() {
1204 Some(n) => Ok((i, n)),
1205 None => Err(Err::Error(crate::error::Error::from_error_kind(
1206 i,
1207 ErrorKind::Digit,
1208 ))),
1209 }
1210 }
1211
1212 proptest! {
1213 #[test]
1214 fn ints(s in "\\PC*") {
1215 let res1 = digit_to_i16(&s);
1216 let res2 = i16(s.as_str());
1217 assert_eq!(res1, res2);
1218 }
1219
1220 #[test]
1221 fn uints(s in "\\PC*") {
1222 let res1 = digit_to_u32(&s);
1223 let res2 = u32(s.as_str());
1224 assert_eq!(res1, res2);
1225 }
1226 }
1227}
1228