1 //! Parsers recognizing numbers, complete input version
2
3 use crate::branch::alt;
4 use crate::bytes::complete::tag;
5 use crate::character::complete::{char, digit1, sign};
6 use crate::combinator::{cut, map, opt, recognize};
7 use crate::error::ParseError;
8 use crate::error::{make_error, ErrorKind};
9 use crate::internal::*;
10 use crate::lib::std::ops::{Range, RangeFrom, RangeTo};
11 use crate::sequence::{pair, tuple};
12 use crate::traits::{
13 AsBytes, AsChar, Compare, InputIter, InputLength, InputTake, InputTakeAtPosition, Offset, Slice,
14 };
15
16 #[doc(hidden)]
17 macro_rules! map(
18 // Internal parser, do not use directly
19 (__impl $i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => (
20 $crate::combinator::map(move |i| {$submac!(i, $($args)*)}, $g).parse($i)
21 );
22 ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => (
23 map!(__impl $i, $submac!($($args)*), $g)
24 );
25 ($i:expr, $f:expr, $g:expr) => (
26 map!(__impl $i, call!($f), $g)
27 );
28 );
29
30 #[doc(hidden)]
31 macro_rules! call (
32 ($i:expr, $fun:expr) => ( $fun( $i ) );
33 ($i:expr, $fun:expr, $($args:expr),* ) => ( $fun( $i, $($args),* ) );
34 );
35
36 /// Recognizes an unsigned 1 byte integer.
37 ///
38 /// *Complete version*: Returns an error if there is not enough input data.
39 /// ```rust
40 /// # use nom::{Err, error::ErrorKind, Needed};
41 /// # use nom::Needed::Size;
42 /// use nom::number::complete::be_u8;
43 ///
44 /// let parser = |s| {
45 /// be_u8(s)
46 /// };
47 ///
48 /// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"\x03abcefg"[..], 0x00)));
49 /// assert_eq!(parser(&b""[..]), Err(Err::Error((&[][..], ErrorKind::Eof))));
50 /// ```
51 #[inline]
be_u8<I, E: ParseError<I>>(input: I) -> IResult<I, u8, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,52 pub fn be_u8<I, E: ParseError<I>>(input: I) -> IResult<I, u8, E>
53 where
54 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
55 {
56 let bound: usize = 1;
57 if input.input_len() < bound {
58 Err(Err::Error(make_error(input, ErrorKind::Eof)))
59 } else {
60 let res = input.iter_elements().next().unwrap();
61
62 Ok((input.slice(bound..), res))
63 }
64 }
65
66 /// Recognizes a big endian unsigned 2 bytes integer.
67 ///
68 /// *Complete version*: Returns an error if there is not enough input data.
69 /// ```rust
70 /// # use nom::{Err, error::ErrorKind, Needed};
71 /// # use nom::Needed::Size;
72 /// use nom::number::complete::be_u16;
73 ///
74 /// let parser = |s| {
75 /// be_u16(s)
76 /// };
77 ///
78 /// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0003)));
79 /// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
80 /// ```
81 #[inline]
be_u16<I, E: ParseError<I>>(input: I) -> IResult<I, u16, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,82 pub fn be_u16<I, E: ParseError<I>>(input: I) -> IResult<I, u16, E>
83 where
84 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
85 {
86 let bound: usize = 2;
87 if input.input_len() < bound {
88 Err(Err::Error(make_error(input, ErrorKind::Eof)))
89 } else {
90 let mut res = 0u16;
91 for byte in input.iter_elements().take(bound) {
92 res = (res << 8) + byte as u16;
93 }
94
95 Ok((input.slice(bound..), res))
96 }
97 }
98
99 /// Recognizes a big endian unsigned 3 byte integer.
100 ///
101 /// *Complete version*: Returns an error if there is not enough input data.
102 /// ```rust
103 /// # use nom::{Err, error::ErrorKind, Needed};
104 /// # use nom::Needed::Size;
105 /// use nom::number::complete::be_u24;
106 ///
107 /// let parser = |s| {
108 /// be_u24(s)
109 /// };
110 ///
111 /// assert_eq!(parser(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x000305)));
112 /// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
113 /// ```
114 #[inline]
be_u24<I, E: ParseError<I>>(input: I) -> IResult<I, u32, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,115 pub fn be_u24<I, E: ParseError<I>>(input: I) -> IResult<I, u32, E>
116 where
117 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
118 {
119 let bound: usize = 3;
120 if input.input_len() < bound {
121 Err(Err::Error(make_error(input, ErrorKind::Eof)))
122 } else {
123 let mut res = 0u32;
124 for byte in input.iter_elements().take(bound) {
125 res = (res << 8) + byte as u32;
126 }
127
128 Ok((input.slice(bound..), res))
129 }
130 }
131
132 /// Recognizes a big endian unsigned 4 bytes integer.
133 ///
134 /// *Complete version*: Returns an error if there is not enough input data.
135 /// ```rust
136 /// # use nom::{Err, error::ErrorKind, Needed};
137 /// # use nom::Needed::Size;
138 /// use nom::number::complete::be_u32;
139 ///
140 /// let parser = |s| {
141 /// be_u32(s)
142 /// };
143 ///
144 /// assert_eq!(parser(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00030507)));
145 /// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
146 /// ```
147 #[inline]
be_u32<I, E: ParseError<I>>(input: I) -> IResult<I, u32, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,148 pub fn be_u32<I, E: ParseError<I>>(input: I) -> IResult<I, u32, E>
149 where
150 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
151 {
152 let bound: usize = 4;
153 if input.input_len() < bound {
154 Err(Err::Error(make_error(input, ErrorKind::Eof)))
155 } else {
156 let mut res = 0u32;
157 for byte in input.iter_elements().take(bound) {
158 res = (res << 8) + byte as u32;
159 }
160
161 Ok((input.slice(bound..), res))
162 }
163 }
164
165 /// Recognizes a big endian unsigned 8 bytes integer.
166 ///
167 /// *Complete version*: Returns an error if there is not enough input data.
168 /// ```rust
169 /// # use nom::{Err, error::ErrorKind, Needed};
170 /// # use nom::Needed::Size;
171 /// use nom::number::complete::be_u64;
172 ///
173 /// let parser = |s| {
174 /// be_u64(s)
175 /// };
176 ///
177 /// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0001020304050607)));
178 /// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
179 /// ```
180 #[inline]
be_u64<I, E: ParseError<I>>(input: I) -> IResult<I, u64, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,181 pub fn be_u64<I, E: ParseError<I>>(input: I) -> IResult<I, u64, E>
182 where
183 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
184 {
185 let bound: usize = 8;
186 if input.input_len() < bound {
187 Err(Err::Error(make_error(input, ErrorKind::Eof)))
188 } else {
189 let mut res = 0u64;
190 for byte in input.iter_elements().take(bound) {
191 res = (res << 8) + byte as u64;
192 }
193
194 Ok((input.slice(bound..), res))
195 }
196 }
197
198 /// Recognizes a big endian unsigned 16 bytes integer.
199 ///
200 /// *Complete version*: Returns an error if there is not enough input data.
201 /// ```rust
202 /// # use nom::{Err, error::ErrorKind, Needed};
203 /// # use nom::Needed::Size;
204 /// use nom::number::complete::be_u128;
205 ///
206 /// let parser = |s| {
207 /// be_u128(s)
208 /// };
209 ///
210 /// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00010203040506070001020304050607)));
211 /// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
212 /// ```
213 #[inline]
214 #[cfg(stable_i128)]
be_u128<I, E: ParseError<I>>(input: I) -> IResult<I, u128, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,215 pub fn be_u128<I, E: ParseError<I>>(input: I) -> IResult<I, u128, E>
216 where
217 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
218 {
219 let bound: usize = 16;
220 if input.input_len() < bound {
221 Err(Err::Error(make_error(input, ErrorKind::Eof)))
222 } else {
223 let mut res = 0u128;
224 for byte in input.iter_elements().take(bound) {
225 res = (res << 8) + byte as u128;
226 }
227
228 Ok((input.slice(bound..), res))
229 }
230 }
231
232 /// Recognizes a signed 1 byte integer.
233 ///
234 /// *Complete version*: Returns an error if there is not enough input data.
235 /// ```rust
236 /// # use nom::{Err, error::ErrorKind, Needed};
237 /// # use nom::Needed::Size;
238 /// use nom::number::complete::be_i8;
239 ///
240 /// let parser = |s| {
241 /// be_i8(s)
242 /// };
243 ///
244 /// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"\x03abcefg"[..], 0x00)));
245 /// assert_eq!(parser(&b""[..]), Err(Err::Error((&[][..], ErrorKind::Eof))));
246 /// ```
247 #[inline]
be_i8<I, E: ParseError<I>>(input: I) -> IResult<I, i8, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,248 pub fn be_i8<I, E: ParseError<I>>(input: I) -> IResult<I, i8, E>
249 where
250 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
251 {
252 map!(input, be_u8, |x| x as i8)
253 }
254
255 /// Recognizes a big endian signed 2 bytes integer.
256 ///
257 /// *Complete version*: Returns an error if there is not enough input data.
258 /// ```rust
259 /// # use nom::{Err, error::ErrorKind, Needed};
260 /// # use nom::Needed::Size;
261 /// use nom::number::complete::be_i16;
262 ///
263 /// let parser = |s| {
264 /// be_i16(s)
265 /// };
266 ///
267 /// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0003)));
268 /// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
269 /// ```
270 #[inline]
be_i16<I, E: ParseError<I>>(input: I) -> IResult<I, i16, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,271 pub fn be_i16<I, E: ParseError<I>>(input: I) -> IResult<I, i16, E>
272 where
273 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
274 {
275 map!(input, be_u16, |x| x as i16)
276 }
277
278 /// Recognizes a big endian signed 3 bytes integer.
279 ///
280 /// *Complete version*: Returns an error if there is not enough input data.
281 /// ```rust
282 /// # use nom::{Err, error::ErrorKind, Needed};
283 /// # use nom::Needed::Size;
284 /// use nom::number::complete::be_i24;
285 ///
286 /// let parser = |s| {
287 /// be_i24(s)
288 /// };
289 ///
290 /// assert_eq!(parser(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x000305)));
291 /// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
292 /// ```
293 #[inline]
be_i24<I, E: ParseError<I>>(input: I) -> IResult<I, i32, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,294 pub fn be_i24<I, E: ParseError<I>>(input: I) -> IResult<I, i32, E>
295 where
296 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
297 {
298 // Same as the unsigned version but we need to sign-extend manually here
299 map!(input, be_u24, |x| if x & 0x80_00_00 != 0 {
300 (x | 0xff_00_00_00) as i32
301 } else {
302 x as i32
303 })
304 }
305
306 /// Recognizes a big endian signed 4 bytes integer.
307 ///
308 /// *Complete version*: Teturns an error if there is not enough input data.
309 /// ```rust
310 /// # use nom::{Err, error::ErrorKind, Needed};
311 /// # use nom::Needed::Size;
312 /// use nom::number::complete::be_i32;
313 ///
314 /// let parser = |s| {
315 /// be_i32(s)
316 /// };
317 ///
318 /// assert_eq!(parser(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00030507)));
319 /// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
320 /// ```
321 #[inline]
be_i32<I, E: ParseError<I>>(input: I) -> IResult<I, i32, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,322 pub fn be_i32<I, E: ParseError<I>>(input: I) -> IResult<I, i32, E>
323 where
324 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
325 {
326 map!(input, be_u32, |x| x as i32)
327 }
328
329 /// Recognizes a big endian signed 8 bytes integer.
330 ///
331 /// *Complete version*: Returns an error if there is not enough input data.
332 /// ```rust
333 /// # use nom::{Err, error::ErrorKind, Needed};
334 /// # use nom::Needed::Size;
335 /// use nom::number::complete::be_i64;
336 ///
337 /// let parser = |s| {
338 /// be_i64(s)
339 /// };
340 ///
341 /// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0001020304050607)));
342 /// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
343 /// ```
344 #[inline]
be_i64<I, E: ParseError<I>>(input: I) -> IResult<I, i64, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,345 pub fn be_i64<I, E: ParseError<I>>(input: I) -> IResult<I, i64, E>
346 where
347 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
348 {
349 map!(input, be_u64, |x| x as i64)
350 }
351
352 /// Recognizes a big endian signed 16 bytes integer.
353 ///
354 /// *Complete version*: Returns an error if there is not enough input data.
355 /// ```rust
356 /// # use nom::{Err, error::ErrorKind, Needed};
357 /// # use nom::Needed::Size;
358 /// use nom::number::complete::be_i128;
359 ///
360 /// let parser = |s| {
361 /// be_i128(s)
362 /// };
363 ///
364 /// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00010203040506070001020304050607)));
365 /// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
366 /// ```
367 #[inline]
368 #[cfg(stable_i128)]
be_i128<I, E: ParseError<I>>(input: I) -> IResult<I, i128, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,369 pub fn be_i128<I, E: ParseError<I>>(input: I) -> IResult<I, i128, E>
370 where
371 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
372 {
373 map!(input, be_u128, |x| x as i128)
374 }
375
376 /// Recognizes an unsigned 1 byte integer.
377 ///
378 /// *Complete version*: Returns an error if there is not enough input data.
379 /// ```rust
380 /// # use nom::{Err, error::ErrorKind, Needed};
381 /// # use nom::Needed::Size;
382 /// use nom::number::complete::le_u8;
383 ///
384 /// let parser = |s| {
385 /// le_u8(s)
386 /// };
387 ///
388 /// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"\x03abcefg"[..], 0x00)));
389 /// assert_eq!(parser(&b""[..]), Err(Err::Error((&[][..], ErrorKind::Eof))));
390 /// ```
391 #[inline]
le_u8<I, E: ParseError<I>>(input: I) -> IResult<I, u8, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,392 pub fn le_u8<I, E: ParseError<I>>(input: I) -> IResult<I, u8, E>
393 where
394 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
395 {
396 let bound: usize = 1;
397 if input.input_len() < bound {
398 Err(Err::Error(make_error(input, ErrorKind::Eof)))
399 } else {
400 let res = input.iter_elements().next().unwrap();
401
402 Ok((input.slice(bound..), res))
403 }
404 }
405
406 /// Recognizes a little endian unsigned 2 bytes integer.
407 ///
408 /// *Complete version*: Returns an error if there is not enough input data.
409 /// ```rust
410 /// # use nom::{Err, error::ErrorKind, Needed};
411 /// # use nom::Needed::Size;
412 /// use nom::number::complete::le_u16;
413 ///
414 /// let parser = |s| {
415 /// le_u16(s)
416 /// };
417 ///
418 /// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0300)));
419 /// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
420 /// ```
421 #[inline]
le_u16<I, E: ParseError<I>>(input: I) -> IResult<I, u16, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,422 pub fn le_u16<I, E: ParseError<I>>(input: I) -> IResult<I, u16, E>
423 where
424 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
425 {
426 let bound: usize = 2;
427 if input.input_len() < bound {
428 Err(Err::Error(make_error(input, ErrorKind::Eof)))
429 } else {
430 let mut res = 0u16;
431 for (index, byte) in input.iter_indices().take(bound) {
432 res += (byte as u16) << (8 * index);
433 }
434
435 Ok((input.slice(bound..), res))
436 }
437 }
438
439 /// Recognizes a little endian unsigned 3 byte integer.
440 ///
441 /// *Complete version*: Returns an error if there is not enough input data.
442 /// ```rust
443 /// # use nom::{Err, error::ErrorKind, Needed};
444 /// # use nom::Needed::Size;
445 /// use nom::number::complete::le_u24;
446 ///
447 /// let parser = |s| {
448 /// le_u24(s)
449 /// };
450 ///
451 /// assert_eq!(parser(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x050300)));
452 /// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
453 /// ```
454 #[inline]
le_u24<I, E: ParseError<I>>(input: I) -> IResult<I, u32, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,455 pub fn le_u24<I, E: ParseError<I>>(input: I) -> IResult<I, u32, E>
456 where
457 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
458 {
459 let bound: usize = 3;
460 if input.input_len() < bound {
461 Err(Err::Error(make_error(input, ErrorKind::Eof)))
462 } else {
463 let mut res = 0u32;
464 for (index, byte) in input.iter_indices().take(bound) {
465 res += (byte as u32) << (8 * index);
466 }
467
468 Ok((input.slice(bound..), res))
469 }
470 }
471
472 /// Recognizes a little endian unsigned 4 bytes integer.
473 ///
474 /// *Complete version*: Returns an error if there is not enough input data.
475 /// ```rust
476 /// # use nom::{Err, error::ErrorKind, Needed};
477 /// # use nom::Needed::Size;
478 /// use nom::number::complete::le_u32;
479 ///
480 /// let parser = |s| {
481 /// le_u32(s)
482 /// };
483 ///
484 /// assert_eq!(parser(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07050300)));
485 /// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
486 /// ```
487 #[inline]
le_u32<I, E: ParseError<I>>(input: I) -> IResult<I, u32, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,488 pub fn le_u32<I, E: ParseError<I>>(input: I) -> IResult<I, u32, E>
489 where
490 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
491 {
492 let bound: usize = 4;
493 if input.input_len() < bound {
494 Err(Err::Error(make_error(input, ErrorKind::Eof)))
495 } else {
496 let mut res = 0u32;
497 for (index, byte) in input.iter_indices().take(bound) {
498 res += (byte as u32) << (8 * index);
499 }
500
501 Ok((input.slice(bound..), res))
502 }
503 }
504
505 /// Recognizes a little endian unsigned 8 bytes integer.
506 ///
507 /// *Complete version*: Returns an error if there is not enough input data.
508 /// ```rust
509 /// # use nom::{Err, error::ErrorKind, Needed};
510 /// # use nom::Needed::Size;
511 /// use nom::number::complete::le_u64;
512 ///
513 /// let parser = |s| {
514 /// le_u64(s)
515 /// };
516 ///
517 /// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0706050403020100)));
518 /// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
519 /// ```
520 #[inline]
le_u64<I, E: ParseError<I>>(input: I) -> IResult<I, u64, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,521 pub fn le_u64<I, E: ParseError<I>>(input: I) -> IResult<I, u64, E>
522 where
523 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
524 {
525 let bound: usize = 8;
526 if input.input_len() < bound {
527 Err(Err::Error(make_error(input, ErrorKind::Eof)))
528 } else {
529 let mut res = 0u64;
530 for (index, byte) in input.iter_indices().take(bound) {
531 res += (byte as u64) << (8 * index);
532 }
533
534 Ok((input.slice(bound..), res))
535 }
536 }
537
538 /// Recognizes a little endian unsigned 16 bytes integer.
539 ///
540 /// *Complete version*: Returns an error if there is not enough input data.
541 /// ```rust
542 /// # use nom::{Err, error::ErrorKind, Needed};
543 /// # use nom::Needed::Size;
544 /// use nom::number::complete::le_u128;
545 ///
546 /// let parser = |s| {
547 /// le_u128(s)
548 /// };
549 ///
550 /// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07060504030201000706050403020100)));
551 /// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
552 /// ```
553 #[inline]
554 #[cfg(stable_i128)]
le_u128<I, E: ParseError<I>>(input: I) -> IResult<I, u128, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,555 pub fn le_u128<I, E: ParseError<I>>(input: I) -> IResult<I, u128, E>
556 where
557 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
558 {
559 let bound: usize = 16;
560 if input.input_len() < bound {
561 Err(Err::Error(make_error(input, ErrorKind::Eof)))
562 } else {
563 let mut res = 0u128;
564 for (index, byte) in input.iter_indices().take(bound) {
565 res += (byte as u128) << (8 * index);
566 }
567
568 Ok((input.slice(bound..), res))
569 }
570 }
571
572 /// Recognizes a signed 1 byte integer.
573 ///
574 /// *Complete version*: Returns an error if there is not enough input data.
575 /// ```rust
576 /// # use nom::{Err, error::ErrorKind, Needed};
577 /// # use nom::Needed::Size;
578 /// use nom::number::complete::le_i8;
579 ///
580 /// let parser = |s| {
581 /// le_i8(s)
582 /// };
583 ///
584 /// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"\x03abcefg"[..], 0x00)));
585 /// assert_eq!(parser(&b""[..]), Err(Err::Error((&[][..], ErrorKind::Eof))));
586 /// ```
587 #[inline]
le_i8<I, E: ParseError<I>>(input: I) -> IResult<I, i8, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,588 pub fn le_i8<I, E: ParseError<I>>(input: I) -> IResult<I, i8, E>
589 where
590 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
591 {
592 map!(input, be_u8, |x| x as i8)
593 }
594
595 /// Recognizes a little endian signed 2 bytes integer.
596 ///
597 /// *Complete version*: Returns an error if there is not enough input data.
598 /// ```rust
599 /// # use nom::{Err, error::ErrorKind, Needed};
600 /// # use nom::Needed::Size;
601 /// use nom::number::complete::le_i16;
602 ///
603 /// let parser = |s| {
604 /// le_i16(s)
605 /// };
606 ///
607 /// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0300)));
608 /// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
609 /// ```
610 #[inline]
le_i16<I, E: ParseError<I>>(input: I) -> IResult<I, i16, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,611 pub fn le_i16<I, E: ParseError<I>>(input: I) -> IResult<I, i16, E>
612 where
613 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
614 {
615 map!(input, le_u16, |x| x as i16)
616 }
617
618 /// Recognizes a little endian signed 3 bytes integer.
619 ///
620 /// *Complete version*: Returns an error if there is not enough input data.
621 /// ```rust
622 /// # use nom::{Err, error::ErrorKind, Needed};
623 /// # use nom::Needed::Size;
624 /// use nom::number::complete::le_i24;
625 ///
626 /// let parser = |s| {
627 /// le_i24(s)
628 /// };
629 ///
630 /// assert_eq!(parser(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x050300)));
631 /// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
632 /// ```
633 #[inline]
le_i24<I, E: ParseError<I>>(input: I) -> IResult<I, i32, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,634 pub fn le_i24<I, E: ParseError<I>>(input: I) -> IResult<I, i32, E>
635 where
636 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
637 {
638 // Same as the unsigned version but we need to sign-extend manually here
639 map!(input, le_u24, |x| if x & 0x80_00_00 != 0 {
640 (x | 0xff_00_00_00) as i32
641 } else {
642 x as i32
643 })
644 }
645
646 /// Recognizes a little endian signed 4 bytes integer.
647 ///
648 /// *Complete version*: Returns an error if there is not enough input data.
649 /// ```rust
650 /// # use nom::{Err, error::ErrorKind, Needed};
651 /// # use nom::Needed::Size;
652 /// use nom::number::complete::le_i32;
653 ///
654 /// let parser = |s| {
655 /// le_i32(s)
656 /// };
657 ///
658 /// assert_eq!(parser(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07050300)));
659 /// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
660 /// ```
661 #[inline]
le_i32<I, E: ParseError<I>>(input: I) -> IResult<I, i32, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,662 pub fn le_i32<I, E: ParseError<I>>(input: I) -> IResult<I, i32, E>
663 where
664 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
665 {
666 map!(input, le_u32, |x| x as i32)
667 }
668
669 /// Recognizes a little endian signed 8 bytes integer.
670 ///
671 /// *Complete version*: Returns an error if there is not enough input data.
672 /// ```rust
673 /// # use nom::{Err, error::ErrorKind, Needed};
674 /// # use nom::Needed::Size;
675 /// use nom::number::complete::le_i64;
676 ///
677 /// let parser = |s| {
678 /// le_i64(s)
679 /// };
680 ///
681 /// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0706050403020100)));
682 /// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
683 /// ```
684 #[inline]
le_i64<I, E: ParseError<I>>(input: I) -> IResult<I, i64, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,685 pub fn le_i64<I, E: ParseError<I>>(input: I) -> IResult<I, i64, E>
686 where
687 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
688 {
689 map!(input, le_u64, |x| x as i64)
690 }
691
692 /// Recognizes a little endian signed 16 bytes integer.
693 ///
694 /// *Complete version*: Returns an error if there is not enough input data.
695 /// ```rust
696 /// # use nom::{Err, error::ErrorKind, Needed};
697 /// # use nom::Needed::Size;
698 /// use nom::number::complete::le_i128;
699 ///
700 /// let parser = |s| {
701 /// le_i128(s)
702 /// };
703 ///
704 /// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07060504030201000706050403020100)));
705 /// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
706 /// ```
707 #[inline]
708 #[cfg(stable_i128)]
le_i128<I, E: ParseError<I>>(input: I) -> IResult<I, i128, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,709 pub fn le_i128<I, E: ParseError<I>>(input: I) -> IResult<I, i128, E>
710 where
711 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
712 {
713 map!(input, le_u128, |x| x as i128)
714 }
715
716 /// Recognizes an unsigned 1 byte integer
717 ///
718 /// Note that endianness does not apply to 1 byte numbers.
719 /// *complete version*: returns an error if there is not enough input data
720 /// ```rust
721 /// # use nom::{Err, error::ErrorKind, Needed};
722 /// # use nom::Needed::Size;
723 /// use nom::number::complete::u8;
724 ///
725 /// let parser = |s| {
726 /// u8(s)
727 /// };
728 ///
729 /// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"\x03abcefg"[..], 0x00)));
730 /// assert_eq!(parser(&b""[..]), Err(Err::Error((&[][..], ErrorKind::Eof))));
731 /// ```
732 #[inline]
u8<I, E: ParseError<I>>(input: I) -> IResult<I, u8, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,733 pub fn u8<I, E: ParseError<I>>(input: I) -> IResult<I, u8, E>
734 where
735 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
736 {
737 let bound: usize = 1;
738 if input.input_len() < bound {
739 Err(Err::Error(make_error(input, ErrorKind::Eof)))
740 } else {
741 let res = input.iter_elements().next().unwrap();
742
743 Ok((input.slice(bound..), res))
744 }
745 }
746
747 /// Recognizes an unsigned 2 bytes integer
748 ///
749 /// If the parameter is `nom::number::Endianness::Big`, parse a big endian u16 integer,
750 /// otherwise if `nom::number::Endianness::Little` parse a little endian u16 integer.
751 /// *complete version*: returns an error if there is not enough input data
752 ///
753 /// ```rust
754 /// # use nom::{Err, error::ErrorKind, Needed};
755 /// # use nom::Needed::Size;
756 /// use nom::number::complete::u16;
757 ///
758 /// let be_u16 = |s| {
759 /// u16(nom::number::Endianness::Big)(s)
760 /// };
761 ///
762 /// assert_eq!(be_u16(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0003)));
763 /// assert_eq!(be_u16(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
764 ///
765 /// let le_u16 = |s| {
766 /// u16(nom::number::Endianness::Little)(s)
767 /// };
768 ///
769 /// assert_eq!(le_u16(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0300)));
770 /// assert_eq!(le_u16(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
771 /// ```
772 #[inline]
u16<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, u16, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,773 pub fn u16<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, u16, E>
774 where
775 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
776 {
777 match endian {
778 crate::number::Endianness::Big => be_u16,
779 crate::number::Endianness::Little => le_u16,
780 #[cfg(target_endian = "big")]
781 crate::number::Endianness::Native => be_u16,
782 #[cfg(target_endian = "little")]
783 crate::number::Endianness::Native => le_u16,
784 }
785 }
786
787 /// Recognizes an unsigned 3 byte integer
788 ///
789 /// If the parameter is `nom::number::Endianness::Big`, parse a big endian u24 integer,
790 /// otherwise if `nom::number::Endianness::Little` parse a little endian u24 integer.
791 /// *complete version*: returns an error if there is not enough input data
792 /// ```rust
793 /// # use nom::{Err, error::ErrorKind, Needed};
794 /// # use nom::Needed::Size;
795 /// use nom::number::complete::u24;
796 ///
797 /// let be_u24 = |s| {
798 /// u24(nom::number::Endianness::Big)(s)
799 /// };
800 ///
801 /// assert_eq!(be_u24(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x000305)));
802 /// assert_eq!(be_u24(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
803 ///
804 /// let le_u24 = |s| {
805 /// u24(nom::number::Endianness::Little)(s)
806 /// };
807 ///
808 /// assert_eq!(le_u24(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x050300)));
809 /// assert_eq!(le_u24(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
810 /// ```
811 #[inline]
u24<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, u32, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,812 pub fn u24<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, u32, E>
813 where
814 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
815 {
816 match endian {
817 crate::number::Endianness::Big => be_u24,
818 crate::number::Endianness::Little => le_u24,
819 #[cfg(target_endian = "big")]
820 crate::number::Endianness::Native => be_u24,
821 #[cfg(target_endian = "little")]
822 crate::number::Endianness::Native => le_u24,
823 }
824 }
825
826 /// Recognizes an unsigned 4 byte integer
827 ///
828 /// If the parameter is `nom::number::Endianness::Big`, parse a big endian u32 integer,
829 /// otherwise if `nom::number::Endianness::Little` parse a little endian u32 integer.
830 /// *complete version*: returns an error if there is not enough input data
831 /// ```rust
832 /// # use nom::{Err, error::ErrorKind, Needed};
833 /// # use nom::Needed::Size;
834 /// use nom::number::complete::u32;
835 ///
836 /// let be_u32 = |s| {
837 /// u32(nom::number::Endianness::Big)(s)
838 /// };
839 ///
840 /// assert_eq!(be_u32(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00030507)));
841 /// assert_eq!(be_u32(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
842 ///
843 /// let le_u32 = |s| {
844 /// u32(nom::number::Endianness::Little)(s)
845 /// };
846 ///
847 /// assert_eq!(le_u32(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07050300)));
848 /// assert_eq!(le_u32(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
849 /// ```
850 #[inline]
u32<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, u32, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,851 pub fn u32<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, u32, E>
852 where
853 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
854 {
855 match endian {
856 crate::number::Endianness::Big => be_u32,
857 crate::number::Endianness::Little => le_u32,
858 #[cfg(target_endian = "big")]
859 crate::number::Endianness::Native => be_u32,
860 #[cfg(target_endian = "little")]
861 crate::number::Endianness::Native => le_u32,
862 }
863 }
864
865 /// Recognizes an unsigned 8 byte integer
866 ///
867 /// If the parameter is `nom::number::Endianness::Big`, parse a big endian u64 integer,
868 /// otherwise if `nom::number::Endianness::Little` parse a little endian u64 integer.
869 /// *complete version*: returns an error if there is not enough input data
870 /// ```rust
871 /// # use nom::{Err, error::ErrorKind, Needed};
872 /// # use nom::Needed::Size;
873 /// use nom::number::complete::u64;
874 ///
875 /// let be_u64 = |s| {
876 /// u64(nom::number::Endianness::Big)(s)
877 /// };
878 ///
879 /// assert_eq!(be_u64(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0001020304050607)));
880 /// assert_eq!(be_u64(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
881 ///
882 /// let le_u64 = |s| {
883 /// u64(nom::number::Endianness::Little)(s)
884 /// };
885 ///
886 /// assert_eq!(le_u64(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0706050403020100)));
887 /// assert_eq!(le_u64(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
888 /// ```
889 #[inline]
u64<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, u64, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,890 pub fn u64<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, u64, E>
891 where
892 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
893 {
894 match endian {
895 crate::number::Endianness::Big => be_u64,
896 crate::number::Endianness::Little => le_u64,
897 #[cfg(target_endian = "big")]
898 crate::number::Endianness::Native => be_u64,
899 #[cfg(target_endian = "little")]
900 crate::number::Endianness::Native => le_u64,
901 }
902 }
903
904 /// Recognizes an unsigned 16 byte integer
905 ///
906 /// If the parameter is `nom::number::Endianness::Big`, parse a big endian u128 integer,
907 /// otherwise if `nom::number::Endianness::Little` parse a little endian u128 integer.
908 /// *complete version*: returns an error if there is not enough input data
909 /// ```rust
910 /// # use nom::{Err, error::ErrorKind, Needed};
911 /// # use nom::Needed::Size;
912 /// use nom::number::complete::u128;
913 ///
914 /// let be_u128 = |s| {
915 /// u128(nom::number::Endianness::Big)(s)
916 /// };
917 ///
918 /// assert_eq!(be_u128(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00010203040506070001020304050607)));
919 /// assert_eq!(be_u128(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
920 ///
921 /// let le_u128 = |s| {
922 /// u128(nom::number::Endianness::Little)(s)
923 /// };
924 ///
925 /// assert_eq!(le_u128(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07060504030201000706050403020100)));
926 /// assert_eq!(le_u128(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
927 /// ```
928 #[inline]
929 #[cfg(stable_i128)]
u128<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, u128, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,930 pub fn u128<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, u128, E>
931 where
932 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
933 {
934 match endian {
935 crate::number::Endianness::Big => be_u128,
936 crate::number::Endianness::Little => le_u128,
937 #[cfg(target_endian = "big")]
938 crate::number::Endianness::Native => be_u128,
939 #[cfg(target_endian = "little")]
940 crate::number::Endianness::Native => le_u128,
941 }
942 }
943
944 /// Recognizes a signed 1 byte integer
945 ///
946 /// Note that endianness does not apply to 1 byte numbers.
947 /// *complete version*: returns an error if there is not enough input data
948 /// ```rust
949 /// # use nom::{Err, error::ErrorKind, Needed};
950 /// # use nom::Needed::Size;
951 /// use nom::number::complete::i8;
952 ///
953 /// let parser = |s| {
954 /// i8(s)
955 /// };
956 ///
957 /// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"\x03abcefg"[..], 0x00)));
958 /// assert_eq!(parser(&b""[..]), Err(Err::Error((&[][..], ErrorKind::Eof))));
959 /// ```
960 #[inline]
i8<I, E: ParseError<I>>(i: I) -> IResult<I, i8, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,961 pub fn i8<I, E: ParseError<I>>(i: I) -> IResult<I, i8, E>
962 where
963 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
964 {
965 map!(i, u8, |x| x as i8)
966 }
967
968 /// Recognizes a signed 2 byte integer
969 ///
970 /// If the parameter is `nom::number::Endianness::Big`, parse a big endian i16 integer,
971 /// otherwise if `nom::number::Endianness::Little` parse a little endian i16 integer.
972 /// *complete version*: returns an error if there is not enough input data
973 /// ```rust
974 /// # use nom::{Err, error::ErrorKind, Needed};
975 /// # use nom::Needed::Size;
976 /// use nom::number::complete::i16;
977 ///
978 /// let be_i16 = |s| {
979 /// i16(nom::number::Endianness::Big)(s)
980 /// };
981 ///
982 /// assert_eq!(be_i16(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0003)));
983 /// assert_eq!(be_i16(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
984 ///
985 /// let le_i16 = |s| {
986 /// i16(nom::number::Endianness::Little)(s)
987 /// };
988 ///
989 /// assert_eq!(le_i16(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0300)));
990 /// assert_eq!(le_i16(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
991 /// ```
992 #[inline]
i16<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, i16, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,993 pub fn i16<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, i16, E>
994 where
995 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
996 {
997 match endian {
998 crate::number::Endianness::Big => be_i16,
999 crate::number::Endianness::Little => le_i16,
1000 #[cfg(target_endian = "big")]
1001 crate::number::Endianness::Native => be_i16,
1002 #[cfg(target_endian = "little")]
1003 crate::number::Endianness::Native => le_i16,
1004 }
1005 }
1006
1007 /// Recognizes a signed 3 byte integer
1008 ///
1009 /// If the parameter is `nom::number::Endianness::Big`, parse a big endian i24 integer,
1010 /// otherwise if `nom::number::Endianness::Little` parse a little endian i24 integer.
1011 /// *complete version*: returns an error if there is not enough input data
1012 /// ```rust
1013 /// # use nom::{Err, error::ErrorKind, Needed};
1014 /// # use nom::Needed::Size;
1015 /// use nom::number::complete::i24;
1016 ///
1017 /// let be_i24 = |s| {
1018 /// i24(nom::number::Endianness::Big)(s)
1019 /// };
1020 ///
1021 /// assert_eq!(be_i24(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x000305)));
1022 /// assert_eq!(be_i24(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1023 ///
1024 /// let le_i24 = |s| {
1025 /// i24(nom::number::Endianness::Little)(s)
1026 /// };
1027 ///
1028 /// assert_eq!(le_i24(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x050300)));
1029 /// assert_eq!(le_i24(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1030 /// ```
1031 #[inline]
i24<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, i32, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,1032 pub fn i24<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, i32, E>
1033 where
1034 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
1035 {
1036 match endian {
1037 crate::number::Endianness::Big => be_i24,
1038 crate::number::Endianness::Little => le_i24,
1039 #[cfg(target_endian = "big")]
1040 crate::number::Endianness::Native => be_i24,
1041 #[cfg(target_endian = "little")]
1042 crate::number::Endianness::Native => le_i24,
1043 }
1044 }
1045
1046 /// Recognizes a signed 4 byte integer
1047 ///
1048 /// If the parameter is `nom::number::Endianness::Big`, parse a big endian i32 integer,
1049 /// otherwise if `nom::number::Endianness::Little` parse a little endian i32 integer.
1050 /// *complete version*: returns an error if there is not enough input data
1051 /// ```rust
1052 /// # use nom::{Err, error::ErrorKind, Needed};
1053 /// # use nom::Needed::Size;
1054 /// use nom::number::complete::i32;
1055 ///
1056 /// let be_i32 = |s| {
1057 /// i32(nom::number::Endianness::Big)(s)
1058 /// };
1059 ///
1060 /// assert_eq!(be_i32(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00030507)));
1061 /// assert_eq!(be_i32(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1062 ///
1063 /// let le_i32 = |s| {
1064 /// i32(nom::number::Endianness::Little)(s)
1065 /// };
1066 ///
1067 /// assert_eq!(le_i32(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07050300)));
1068 /// assert_eq!(le_i32(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1069 /// ```
1070 #[inline]
i32<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, i32, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,1071 pub fn i32<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, i32, E>
1072 where
1073 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
1074 {
1075 match endian {
1076 crate::number::Endianness::Big => be_i32,
1077 crate::number::Endianness::Little => le_i32,
1078 #[cfg(target_endian = "big")]
1079 crate::number::Endianness::Native => be_i32,
1080 #[cfg(target_endian = "little")]
1081 crate::number::Endianness::Native => le_i32,
1082 }
1083 }
1084
1085 /// Recognizes a signed 8 byte integer
1086 ///
1087 /// If the parameter is `nom::number::Endianness::Big`, parse a big endian i64 integer,
1088 /// otherwise if `nom::number::Endianness::Little` parse a little endian i64 integer.
1089 /// *complete version*: returns an error if there is not enough input data
1090 /// ```rust
1091 /// # use nom::{Err, error::ErrorKind, Needed};
1092 /// # use nom::Needed::Size;
1093 /// use nom::number::complete::i64;
1094 ///
1095 /// let be_i64 = |s| {
1096 /// i64(nom::number::Endianness::Big)(s)
1097 /// };
1098 ///
1099 /// assert_eq!(be_i64(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0001020304050607)));
1100 /// assert_eq!(be_i64(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1101 ///
1102 /// let le_i64 = |s| {
1103 /// i64(nom::number::Endianness::Little)(s)
1104 /// };
1105 ///
1106 /// assert_eq!(le_i64(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0706050403020100)));
1107 /// assert_eq!(le_i64(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1108 /// ```
1109 #[inline]
i64<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, i64, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,1110 pub fn i64<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, i64, E>
1111 where
1112 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
1113 {
1114 match endian {
1115 crate::number::Endianness::Big => be_i64,
1116 crate::number::Endianness::Little => le_i64,
1117 #[cfg(target_endian = "big")]
1118 crate::number::Endianness::Native => be_i64,
1119 #[cfg(target_endian = "little")]
1120 crate::number::Endianness::Native => le_i64,
1121 }
1122 }
1123
1124 /// Recognizes a signed 16 byte integer
1125 ///
1126 /// If the parameter is `nom::number::Endianness::Big`, parse a big endian i128 integer,
1127 /// otherwise if `nom::number::Endianness::Little` parse a little endian i128 integer.
1128 /// *complete version*: returns an error if there is not enough input data
1129 /// ```rust
1130 /// # use nom::{Err, error::ErrorKind, Needed};
1131 /// # use nom::Needed::Size;
1132 /// use nom::number::complete::i128;
1133 ///
1134 /// let be_i128 = |s| {
1135 /// i128(nom::number::Endianness::Big)(s)
1136 /// };
1137 ///
1138 /// assert_eq!(be_i128(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00010203040506070001020304050607)));
1139 /// assert_eq!(be_i128(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1140 ///
1141 /// let le_i128 = |s| {
1142 /// i128(nom::number::Endianness::Little)(s)
1143 /// };
1144 ///
1145 /// assert_eq!(le_i128(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07060504030201000706050403020100)));
1146 /// assert_eq!(le_i128(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1147 /// ```
1148 #[inline]
1149 #[cfg(stable_i128)]
i128<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, i128, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,1150 pub fn i128<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, i128, E>
1151 where
1152 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
1153 {
1154 match endian {
1155 crate::number::Endianness::Big => be_i128,
1156 crate::number::Endianness::Little => le_i128,
1157 #[cfg(target_endian = "big")]
1158 crate::number::Endianness::Native => be_i128,
1159 #[cfg(target_endian = "little")]
1160 crate::number::Endianness::Native => le_i128,
1161 }
1162 }
1163
1164 /// Recognizes a big endian 4 bytes floating point number.
1165 ///
1166 /// *Complete version*: Returns an error if there is not enough input data.
1167 /// ```rust
1168 /// # use nom::{Err, error::ErrorKind, Needed};
1169 /// # use nom::Needed::Size;
1170 /// use nom::number::complete::be_f32;
1171 ///
1172 /// let parser = |s| {
1173 /// be_f32(s)
1174 /// };
1175 ///
1176 /// assert_eq!(parser(&[0x41, 0x48, 0x00, 0x00][..]), Ok((&b""[..], 12.5)));
1177 /// assert_eq!(parser(&b"abc"[..]), Err(Err::Error((&b"abc"[..], ErrorKind::Eof))));
1178 /// ```
1179 #[inline]
be_f32<I, E: ParseError<I>>(input: I) -> IResult<I, f32, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,1180 pub fn be_f32<I, E: ParseError<I>>(input: I) -> IResult<I, f32, E>
1181 where
1182 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
1183 {
1184 match be_u32(input) {
1185 Err(e) => Err(e),
1186 Ok((i, o)) => Ok((i, f32::from_bits(o))),
1187 }
1188 }
1189
1190 /// Recognizes a big endian 8 bytes floating point number.
1191 ///
1192 /// *Complete version*: Returns an error if there is not enough input data.
1193 /// ```rust
1194 /// # use nom::{Err, error::ErrorKind, Needed};
1195 /// # use nom::Needed::Size;
1196 /// use nom::number::complete::be_f64;
1197 ///
1198 /// let parser = |s| {
1199 /// be_f64(s)
1200 /// };
1201 ///
1202 /// assert_eq!(parser(&[0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]), Ok((&b""[..], 12.5)));
1203 /// assert_eq!(parser(&b"abc"[..]), Err(Err::Error((&b"abc"[..], ErrorKind::Eof))));
1204 /// ```
1205 #[inline]
be_f64<I, E: ParseError<I>>(input: I) -> IResult<I, f64, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,1206 pub fn be_f64<I, E: ParseError<I>>(input: I) -> IResult<I, f64, E>
1207 where
1208 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
1209 {
1210 match be_u64(input) {
1211 Err(e) => Err(e),
1212 Ok((i, o)) => Ok((i, f64::from_bits(o))),
1213 }
1214 }
1215
1216 /// Recognizes a little endian 4 bytes floating point number.
1217 ///
1218 /// *Complete version*: Returns an error if there is not enough input data.
1219 /// ```rust
1220 /// # use nom::{Err, error::ErrorKind, Needed};
1221 /// # use nom::Needed::Size;
1222 /// use nom::number::complete::le_f32;
1223 ///
1224 /// let parser = |s| {
1225 /// le_f32(s)
1226 /// };
1227 ///
1228 /// assert_eq!(parser(&[0x00, 0x00, 0x48, 0x41][..]), Ok((&b""[..], 12.5)));
1229 /// assert_eq!(parser(&b"abc"[..]), Err(Err::Error((&b"abc"[..], ErrorKind::Eof))));
1230 /// ```
1231 #[inline]
le_f32<I, E: ParseError<I>>(input: I) -> IResult<I, f32, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,1232 pub fn le_f32<I, E: ParseError<I>>(input: I) -> IResult<I, f32, E>
1233 where
1234 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
1235 {
1236 match le_u32(input) {
1237 Err(e) => Err(e),
1238 Ok((i, o)) => Ok((i, f32::from_bits(o))),
1239 }
1240 }
1241
1242 /// Recognizes a little endian 8 bytes floating point number.
1243 ///
1244 /// *Complete version*: Returns an error if there is not enough input data.
1245 /// ```rust
1246 /// # use nom::{Err, error::ErrorKind, Needed};
1247 /// # use nom::Needed::Size;
1248 /// use nom::number::complete::le_f64;
1249 ///
1250 /// let parser = |s| {
1251 /// le_f64(s)
1252 /// };
1253 ///
1254 /// assert_eq!(parser(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40][..]), Ok((&b""[..], 12.5)));
1255 /// assert_eq!(parser(&b"abc"[..]), Err(Err::Error((&b"abc"[..], ErrorKind::Eof))));
1256 /// ```
1257 #[inline]
le_f64<I, E: ParseError<I>>(input: I) -> IResult<I, f64, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,1258 pub fn le_f64<I, E: ParseError<I>>(input: I) -> IResult<I, f64, E>
1259 where
1260 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
1261 {
1262 match le_u64(input) {
1263 Err(e) => Err(e),
1264 Ok((i, o)) => Ok((i, f64::from_bits(o))),
1265 }
1266 }
1267
1268 /// Recognizes a 4 byte floating point number
1269 ///
1270 /// If the parameter is `nom::number::Endianness::Big`, parse a big endian f32 float,
1271 /// otherwise if `nom::number::Endianness::Little` parse a little endian f32 float.
1272 /// *complete version*: returns an error if there is not enough input data
1273 /// ```rust
1274 /// # use nom::{Err, error::ErrorKind, Needed};
1275 /// # use nom::Needed::Size;
1276 /// use nom::number::complete::f32;
1277 ///
1278 /// let be_f32 = |s| {
1279 /// f32(nom::number::Endianness::Big)(s)
1280 /// };
1281 ///
1282 /// assert_eq!(be_f32(&[0x41, 0x48, 0x00, 0x00][..]), Ok((&b""[..], 12.5)));
1283 /// assert_eq!(be_f32(&b"abc"[..]), Err(Err::Error((&b"abc"[..], ErrorKind::Eof))));
1284 ///
1285 /// let le_f32 = |s| {
1286 /// f32(nom::number::Endianness::Little)(s)
1287 /// };
1288 ///
1289 /// assert_eq!(le_f32(&[0x00, 0x00, 0x48, 0x41][..]), Ok((&b""[..], 12.5)));
1290 /// assert_eq!(le_f32(&b"abc"[..]), Err(Err::Error((&b"abc"[..], ErrorKind::Eof))));
1291 /// ```
1292 #[inline]
f32<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, f32, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,1293 pub fn f32<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, f32, E>
1294 where
1295 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
1296 {
1297 match endian {
1298 crate::number::Endianness::Big => be_f32,
1299 crate::number::Endianness::Little => le_f32,
1300 #[cfg(target_endian = "big")]
1301 crate::number::Endianness::Native => be_f32,
1302 #[cfg(target_endian = "little")]
1303 crate::number::Endianness::Native => le_f32,
1304 }
1305 }
1306
1307 /// Recognizes an 8 byte floating point number
1308 ///
1309 /// If the parameter is `nom::number::Endianness::Big`, parse a big endian f64 float,
1310 /// otherwise if `nom::number::Endianness::Little` parse a little endian f64 float.
1311 /// *complete version*: returns an error if there is not enough input data
1312 /// ```rust
1313 /// # use nom::{Err, error::ErrorKind, Needed};
1314 /// # use nom::Needed::Size;
1315 /// use nom::number::complete::f64;
1316 ///
1317 /// let be_f64 = |s| {
1318 /// f64(nom::number::Endianness::Big)(s)
1319 /// };
1320 ///
1321 /// assert_eq!(be_f64(&[0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]), Ok((&b""[..], 12.5)));
1322 /// assert_eq!(be_f64(&b"abc"[..]), Err(Err::Error((&b"abc"[..], ErrorKind::Eof))));
1323 ///
1324 /// let le_f64 = |s| {
1325 /// f64(nom::number::Endianness::Little)(s)
1326 /// };
1327 ///
1328 /// assert_eq!(le_f64(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40][..]), Ok((&b""[..], 12.5)));
1329 /// assert_eq!(le_f64(&b"abc"[..]), Err(Err::Error((&b"abc"[..], ErrorKind::Eof))));
1330 /// ```
1331 #[inline]
f64<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, f64, E> where I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,1332 pub fn f64<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn(I) -> IResult<I, f64, E>
1333 where
1334 I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength,
1335 {
1336 match endian {
1337 crate::number::Endianness::Big => be_f64,
1338 crate::number::Endianness::Little => le_f64,
1339 #[cfg(target_endian = "big")]
1340 crate::number::Endianness::Native => be_f64,
1341 #[cfg(target_endian = "little")]
1342 crate::number::Endianness::Native => le_f64,
1343 }
1344 }
1345
1346 /// Recognizes a hex-encoded integer.
1347 ///
1348 /// *Complete version*: Will parse until the end of input if it has less than 8 bytes.
1349 /// ```rust
1350 /// # use nom::{Err, error::ErrorKind, Needed};
1351 /// # use nom::Needed::Size;
1352 /// use nom::number::complete::hex_u32;
1353 ///
1354 /// let parser = |s| {
1355 /// hex_u32(s)
1356 /// };
1357 ///
1358 /// assert_eq!(parser(&b"01AE"[..]), Ok((&b""[..], 0x01AE)));
1359 /// assert_eq!(parser(&b"abc"[..]), Ok((&b""[..], 0x0ABC)));
1360 /// assert_eq!(parser(&b"ggg"[..]), Err(Err::Error((&b"ggg"[..], ErrorKind::IsA))));
1361 /// ```
1362 #[inline]
hex_u32<'a, E: ParseError<&'a [u8]>>(input: &'a [u8]) -> IResult<&'a [u8], u32, E>1363 pub fn hex_u32<'a, E: ParseError<&'a [u8]>>(input: &'a [u8]) -> IResult<&'a [u8], u32, E> {
1364 let (i, o) = crate::bytes::complete::is_a(&b"0123456789abcdefABCDEF"[..])(input)?;
1365 // Do not parse more than 8 characters for a u32
1366 let (parsed, remaining) = if o.len() <= 8 {
1367 (o, i)
1368 } else {
1369 (&input[..8], &input[8..])
1370 };
1371
1372 let res = parsed
1373 .iter()
1374 .rev()
1375 .enumerate()
1376 .map(|(k, &v)| {
1377 let digit = v as char;
1378 digit.to_digit(16).unwrap_or(0) << (k * 4)
1379 })
1380 .sum();
1381
1382 Ok((remaining, res))
1383 }
1384
1385 /// Recognizes floating point number in a byte string and returns the corresponding slice.
1386 ///
1387 /// *Complete version*: Can parse until the end of input.
1388 ///
1389 /// ```rust
1390 /// # use nom::{Err, error::ErrorKind, Needed};
1391 /// # use nom::Needed::Size;
1392 /// use nom::number::complete::recognize_float;
1393 ///
1394 /// let parser = |s| {
1395 /// recognize_float(s)
1396 /// };
1397 ///
1398 /// assert_eq!(parser("11e-1"), Ok(("", "11e-1")));
1399 /// assert_eq!(parser("123E-02"), Ok(("", "123E-02")));
1400 /// assert_eq!(parser("123K-01"), Ok(("K-01", "123")));
1401 /// assert_eq!(parser("abc"), Err(Err::Error(("abc", ErrorKind::Char))));
1402 /// ```
1403 #[rustfmt::skip]
recognize_float<T, E:ParseError<T>>(input: T) -> IResult<T, T, E> where T: Slice<RangeFrom<usize>> + Slice<RangeTo<usize>>, T: Clone + Offset, T: InputIter, <T as InputIter>::Item: AsChar, T: InputTakeAtPosition, <T as InputTakeAtPosition>::Item: AsChar,1404 pub fn recognize_float<T, E:ParseError<T>>(input: T) -> IResult<T, T, E>
1405 where
1406 T: Slice<RangeFrom<usize>> + Slice<RangeTo<usize>>,
1407 T: Clone + Offset,
1408 T: InputIter,
1409 <T as InputIter>::Item: AsChar,
1410 T: InputTakeAtPosition,
1411 <T as InputTakeAtPosition>::Item: AsChar,
1412 {
1413 recognize(
1414 tuple((
1415 opt(alt((char('+'), char('-')))),
1416 alt((
1417 map(tuple((digit1, opt(pair(char('.'), opt(digit1))))), |_| ()),
1418 map(tuple((char('.'), digit1)), |_| ())
1419 )),
1420 opt(tuple((
1421 alt((char('e'), char('E'))),
1422 opt(alt((char('+'), char('-')))),
1423 cut(digit1)
1424 )))
1425 ))
1426 )(input)
1427 }
1428
1429 // workaround until issues with minimal-lexical are fixed
1430 #[doc(hidden)]
recognize_float_or_exceptions<T, E: ParseError<T>>(input: T) -> IResult<T, T, E> where T: Slice<RangeFrom<usize>> + Slice<RangeTo<usize>>, T: Clone + Offset, T: InputIter + InputTake + Compare<&'static str>, <T as InputIter>::Item: AsChar, T: InputTakeAtPosition, <T as InputTakeAtPosition>::Item: AsChar,1431 pub fn recognize_float_or_exceptions<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
1432 where
1433 T: Slice<RangeFrom<usize>> + Slice<RangeTo<usize>>,
1434 T: Clone + Offset,
1435 T: InputIter + InputTake + Compare<&'static str>,
1436 <T as InputIter>::Item: AsChar,
1437 T: InputTakeAtPosition,
1438 <T as InputTakeAtPosition>::Item: AsChar,
1439 {
1440 alt((
1441 |i: T| {
1442 recognize_float::<_, E>(i.clone()).map_err(|e| match e {
1443 crate::Err::Error(_) => crate::Err::Error(E::from_error_kind(i, ErrorKind::Float)),
1444 crate::Err::Failure(_) => crate::Err::Failure(E::from_error_kind(i, ErrorKind::Float)),
1445 crate::Err::Incomplete(needed) => crate::Err::Incomplete(needed),
1446 })
1447 },
1448 |i: T| {
1449 crate::bytes::complete::tag_no_case::<_, _, E>("nan")(i.clone())
1450 .map_err(|_| crate::Err::Error(E::from_error_kind(i, ErrorKind::Float)))
1451 },
1452 |i: T| {
1453 crate::bytes::complete::tag_no_case::<_, _, E>("inf")(i.clone())
1454 .map_err(|_| crate::Err::Error(E::from_error_kind(i, ErrorKind::Float)))
1455 },
1456 |i: T| {
1457 crate::bytes::complete::tag_no_case::<_, _, E>("infinity")(i.clone())
1458 .map_err(|_| crate::Err::Error(E::from_error_kind(i, ErrorKind::Float)))
1459 },
1460 ))(input)
1461 }
1462
1463 /// Recognizes a floating point number in text format and returns the integer, fraction and exponent parts of the input data
1464 ///
1465 /// *Complete version*: Can parse until the end of input.
1466 ///
recognize_float_parts<T, E: ParseError<T>>(input: T) -> IResult<T, (bool, T, T, i32), E> where T: Slice<RangeFrom<usize>> + Slice<RangeTo<usize>> + Slice<Range<usize>>, T: Clone + Offset, T: InputIter + InputTake, <T as InputIter>::Item: AsChar + Copy, T: InputTakeAtPosition + InputLength, <T as InputTakeAtPosition>::Item: AsChar, T: for<'a> Compare<&'a [u8]>, T: AsBytes,1467 pub fn recognize_float_parts<T, E: ParseError<T>>(input: T) -> IResult<T, (bool, T, T, i32), E>
1468 where
1469 T: Slice<RangeFrom<usize>> + Slice<RangeTo<usize>> + Slice<Range<usize>>,
1470 T: Clone + Offset,
1471 T: InputIter + InputTake,
1472 <T as InputIter>::Item: AsChar + Copy,
1473 T: InputTakeAtPosition + InputLength,
1474 <T as InputTakeAtPosition>::Item: AsChar,
1475 T: for<'a> Compare<&'a [u8]>,
1476 T: AsBytes,
1477 {
1478 let (i, sign) = sign(input.clone())?;
1479
1480 //let (i, zeroes) = take_while(|c: <T as InputTakeAtPosition>::Item| c.as_char() == '0')(i)?;
1481 let (i, zeroes) = match i.as_bytes().iter().position(|c| *c != b'0') {
1482 Some(index) => i.take_split(index),
1483 None => i.take_split(i.input_len()),
1484 };
1485 //let (i, mut integer) = digit0(i)?;
1486 let (i, mut integer) = match i
1487 .as_bytes()
1488 .iter()
1489 .position(|c| !(*c >= b'0' && *c <= b'9'))
1490 {
1491 Some(index) => i.take_split(index),
1492 None => i.take_split(i.input_len()),
1493 };
1494
1495 if integer.input_len() == 0 && zeroes.input_len() > 0 {
1496 // keep the last zero if integer is empty
1497 integer = zeroes.slice(zeroes.input_len() - 1..);
1498 }
1499
1500 let (i, opt_dot) = opt(tag(&b"."[..]))(i)?;
1501 let (i, fraction) = if opt_dot.is_none() {
1502 let i2 = i.clone();
1503 (i2, i.slice(..0))
1504 } else {
1505 // match number, trim right zeroes
1506 let mut zero_count = 0usize;
1507 let mut position = None;
1508 for (pos, c) in i.as_bytes().iter().enumerate() {
1509 if *c >= b'0' && *c <= b'9' {
1510 if *c == b'0' {
1511 zero_count += 1;
1512 } else {
1513 zero_count = 0;
1514 }
1515 } else {
1516 position = Some(pos);
1517 break;
1518 }
1519 }
1520
1521 let position = position.unwrap_or(i.input_len());
1522
1523 let index = if zero_count == 0 {
1524 position
1525 } else if zero_count == position {
1526 position - zero_count + 1
1527 } else {
1528 position - zero_count
1529 };
1530
1531 (i.slice(position..), i.slice(..index))
1532 };
1533
1534 if integer.input_len() == 0 && fraction.input_len() == 0 {
1535 return Err(Err::Error(E::from_error_kind(input, ErrorKind::Float)));
1536 }
1537
1538 let i2 = i.clone();
1539 let (i, e) = match i.as_bytes().iter().next() {
1540 Some(b'e') => (i.slice(1..), true),
1541 Some(b'E') => (i.slice(1..), true),
1542 _ => (i, false),
1543 };
1544
1545 let (i, exp) = if e {
1546 cut(crate::character::complete::i32)(i)?
1547 } else {
1548 (i2, 0)
1549 };
1550
1551 Ok((i, (sign, integer, fraction, exp)))
1552 }
1553
1554 use crate::traits::ParseTo;
1555
1556 /// Recognizes floating point number in text format and returns a f32.
1557 ///
1558 /// *Complete version*: Can parse until the end of input.
1559 /// ```rust
1560 /// # use nom::{Err, error::ErrorKind, Needed};
1561 /// # use nom::Needed::Size;
1562 /// use nom::number::complete::float;
1563 ///
1564 /// let parser = |s| {
1565 /// float(s)
1566 /// };
1567 ///
1568 /// assert_eq!(parser("11e-1"), Ok(("", 1.1)));
1569 /// assert_eq!(parser("123E-02"), Ok(("", 1.23)));
1570 /// assert_eq!(parser("123K-01"), Ok(("K-01", 123.0)));
1571 /// assert_eq!(parser("abc"), Err(Err::Error(("abc", ErrorKind::Float))));
1572 /// ```
float<T, E: ParseError<T>>(input: T) -> IResult<T, f32, E> where T: Slice<RangeFrom<usize>> + Slice<RangeTo<usize>> + Slice<Range<usize>>, T: Clone + Offset + ParseTo<f32> + Compare<&'static str>, T: InputIter + InputLength + InputTake, <T as InputIter>::Item: AsChar + Copy, <T as InputIter>::IterElem: Clone, T: InputTakeAtPosition, <T as InputTakeAtPosition>::Item: AsChar, T: AsBytes, T: for<'a> Compare<&'a [u8]>,1573 pub fn float<T, E: ParseError<T>>(input: T) -> IResult<T, f32, E>
1574 where
1575 T: Slice<RangeFrom<usize>> + Slice<RangeTo<usize>> + Slice<Range<usize>>,
1576 T: Clone + Offset + ParseTo<f32> + Compare<&'static str>,
1577 T: InputIter + InputLength + InputTake,
1578 <T as InputIter>::Item: AsChar + Copy,
1579 <T as InputIter>::IterElem: Clone,
1580 T: InputTakeAtPosition,
1581 <T as InputTakeAtPosition>::Item: AsChar,
1582 T: AsBytes,
1583 T: for<'a> Compare<&'a [u8]>,
1584 {
1585 /*
1586 let (i, (sign, integer, fraction, exponent)) = recognize_float_parts(input)?;
1587
1588 let mut float: f32 = minimal_lexical::parse_float(
1589 integer.as_bytes().iter(),
1590 fraction.as_bytes().iter(),
1591 exponent,
1592 );
1593 if !sign {
1594 float = -float;
1595 }
1596
1597 Ok((i, float))
1598 */
1599 let (i, s) = recognize_float_or_exceptions(input)?;
1600 match s.parse_to() {
1601 Some(f) => (Ok((i, f))),
1602 None => Err(crate::Err::Error(E::from_error_kind(
1603 i,
1604 crate::error::ErrorKind::Float,
1605 ))),
1606 }
1607 }
1608
1609 /// Recognizes floating point number in text format and returns a f64.
1610 ///
1611 /// *Complete version*: Can parse until the end of input.
1612 /// ```rust
1613 /// # use nom::{Err, error::ErrorKind, Needed};
1614 /// # use nom::Needed::Size;
1615 /// use nom::number::complete::double;
1616 ///
1617 /// let parser = |s| {
1618 /// double(s)
1619 /// };
1620 ///
1621 /// assert_eq!(parser("11e-1"), Ok(("", 1.1)));
1622 /// assert_eq!(parser("123E-02"), Ok(("", 1.23)));
1623 /// assert_eq!(parser("123K-01"), Ok(("K-01", 123.0)));
1624 /// assert_eq!(parser("abc"), Err(Err::Error(("abc", ErrorKind::Float))));
1625 /// ```
double<T, E: ParseError<T>>(input: T) -> IResult<T, f64, E> where T: Slice<RangeFrom<usize>> + Slice<RangeTo<usize>> + Slice<Range<usize>>, T: Clone + Offset + ParseTo<f64> + Compare<&'static str>, T: InputIter + InputLength + InputTake, <T as InputIter>::Item: AsChar + Copy, <T as InputIter>::IterElem: Clone, T: InputTakeAtPosition, <T as InputTakeAtPosition>::Item: AsChar, T: AsBytes, T: for<'a> Compare<&'a [u8]>,1626 pub fn double<T, E: ParseError<T>>(input: T) -> IResult<T, f64, E>
1627 where
1628 T: Slice<RangeFrom<usize>> + Slice<RangeTo<usize>> + Slice<Range<usize>>,
1629 T: Clone + Offset + ParseTo<f64> + Compare<&'static str>,
1630 T: InputIter + InputLength + InputTake,
1631 <T as InputIter>::Item: AsChar + Copy,
1632 <T as InputIter>::IterElem: Clone,
1633 T: InputTakeAtPosition,
1634 <T as InputTakeAtPosition>::Item: AsChar,
1635 T: AsBytes,
1636 T: for<'a> Compare<&'a [u8]>,
1637 {
1638 /*
1639 let (i, (sign, integer, fraction, exponent)) = recognize_float_parts(input)?;
1640
1641 let mut float: f64 = minimal_lexical::parse_float(
1642 integer.as_bytes().iter(),
1643 fraction.as_bytes().iter(),
1644 exponent,
1645 );
1646 if !sign {
1647 float = -float;
1648 }
1649
1650 Ok((i, float))
1651 */
1652 let (i, s) = recognize_float_or_exceptions(input)?;
1653 match s.parse_to() {
1654 Some(f) => (Ok((i, f))),
1655 None => Err(crate::Err::Error(E::from_error_kind(
1656 i,
1657 crate::error::ErrorKind::Float,
1658 ))),
1659 }
1660 }
1661
1662 #[cfg(test)]
1663 mod tests {
1664 use super::*;
1665 use crate::error::ErrorKind;
1666 use crate::internal::Err;
1667 use proptest::prelude::*;
1668
1669 macro_rules! assert_parse(
1670 ($left: expr, $right: expr) => {
1671 let res: $crate::IResult<_, _, (_, ErrorKind)> = $left;
1672 assert_eq!(res, $right);
1673 };
1674 );
1675
1676 #[test]
i8_tests()1677 fn i8_tests() {
1678 assert_parse!(i8(&[0x00][..]), Ok((&b""[..], 0)));
1679 assert_parse!(i8(&[0x7f][..]), Ok((&b""[..], 127)));
1680 assert_parse!(i8(&[0xff][..]), Ok((&b""[..], -1)));
1681 assert_parse!(i8(&[0x80][..]), Ok((&b""[..], -128)));
1682 }
1683
1684 #[test]
be_i8_tests()1685 fn be_i8_tests() {
1686 assert_parse!(be_i8(&[0x00][..]), Ok((&b""[..], 0)));
1687 assert_parse!(be_i8(&[0x7f][..]), Ok((&b""[..], 127)));
1688 assert_parse!(be_i8(&[0xff][..]), Ok((&b""[..], -1)));
1689 assert_parse!(be_i8(&[0x80][..]), Ok((&b""[..], -128)));
1690 }
1691
1692 #[test]
be_i16_tests()1693 fn be_i16_tests() {
1694 assert_parse!(be_i16(&[0x00, 0x00][..]), Ok((&b""[..], 0)));
1695 assert_parse!(be_i16(&[0x7f, 0xff][..]), Ok((&b""[..], 32_767_i16)));
1696 assert_parse!(be_i16(&[0xff, 0xff][..]), Ok((&b""[..], -1)));
1697 assert_parse!(be_i16(&[0x80, 0x00][..]), Ok((&b""[..], -32_768_i16)));
1698 }
1699
1700 #[test]
be_u24_tests()1701 fn be_u24_tests() {
1702 assert_parse!(be_u24(&[0x00, 0x00, 0x00][..]), Ok((&b""[..], 0)));
1703 assert_parse!(be_u24(&[0x00, 0xFF, 0xFF][..]), Ok((&b""[..], 65_535_u32)));
1704 assert_parse!(
1705 be_u24(&[0x12, 0x34, 0x56][..]),
1706 Ok((&b""[..], 1_193_046_u32))
1707 );
1708 }
1709
1710 #[test]
be_i24_tests()1711 fn be_i24_tests() {
1712 assert_parse!(be_i24(&[0xFF, 0xFF, 0xFF][..]), Ok((&b""[..], -1_i32)));
1713 assert_parse!(be_i24(&[0xFF, 0x00, 0x00][..]), Ok((&b""[..], -65_536_i32)));
1714 assert_parse!(
1715 be_i24(&[0xED, 0xCB, 0xAA][..]),
1716 Ok((&b""[..], -1_193_046_i32))
1717 );
1718 }
1719
1720 #[test]
be_i32_tests()1721 fn be_i32_tests() {
1722 assert_parse!(be_i32(&[0x00, 0x00, 0x00, 0x00][..]), Ok((&b""[..], 0)));
1723 assert_parse!(
1724 be_i32(&[0x7f, 0xff, 0xff, 0xff][..]),
1725 Ok((&b""[..], 2_147_483_647_i32))
1726 );
1727 assert_parse!(be_i32(&[0xff, 0xff, 0xff, 0xff][..]), Ok((&b""[..], -1)));
1728 assert_parse!(
1729 be_i32(&[0x80, 0x00, 0x00, 0x00][..]),
1730 Ok((&b""[..], -2_147_483_648_i32))
1731 );
1732 }
1733
1734 #[test]
be_i64_tests()1735 fn be_i64_tests() {
1736 assert_parse!(
1737 be_i64(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]),
1738 Ok((&b""[..], 0))
1739 );
1740 assert_parse!(
1741 be_i64(&[0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff][..]),
1742 Ok((&b""[..], 9_223_372_036_854_775_807_i64))
1743 );
1744 assert_parse!(
1745 be_i64(&[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff][..]),
1746 Ok((&b""[..], -1))
1747 );
1748 assert_parse!(
1749 be_i64(&[0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]),
1750 Ok((&b""[..], -9_223_372_036_854_775_808_i64))
1751 );
1752 }
1753
1754 #[test]
1755 #[cfg(stable_i128)]
be_i128_tests()1756 fn be_i128_tests() {
1757 assert_parse!(
1758 be_i128(
1759 &[
1760 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1761 0x00
1762 ][..]
1763 ),
1764 Ok((&b""[..], 0))
1765 );
1766 assert_parse!(
1767 be_i128(
1768 &[
1769 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1770 0xff
1771 ][..]
1772 ),
1773 Ok((
1774 &b""[..],
1775 170_141_183_460_469_231_731_687_303_715_884_105_727_i128
1776 ))
1777 );
1778 assert_parse!(
1779 be_i128(
1780 &[
1781 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1782 0xff
1783 ][..]
1784 ),
1785 Ok((&b""[..], -1))
1786 );
1787 assert_parse!(
1788 be_i128(
1789 &[
1790 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1791 0x00
1792 ][..]
1793 ),
1794 Ok((
1795 &b""[..],
1796 -170_141_183_460_469_231_731_687_303_715_884_105_728_i128
1797 ))
1798 );
1799 }
1800
1801 #[test]
le_i8_tests()1802 fn le_i8_tests() {
1803 assert_parse!(le_i8(&[0x00][..]), Ok((&b""[..], 0)));
1804 assert_parse!(le_i8(&[0x7f][..]), Ok((&b""[..], 127)));
1805 assert_parse!(le_i8(&[0xff][..]), Ok((&b""[..], -1)));
1806 assert_parse!(le_i8(&[0x80][..]), Ok((&b""[..], -128)));
1807 }
1808
1809 #[test]
le_i16_tests()1810 fn le_i16_tests() {
1811 assert_parse!(le_i16(&[0x00, 0x00][..]), Ok((&b""[..], 0)));
1812 assert_parse!(le_i16(&[0xff, 0x7f][..]), Ok((&b""[..], 32_767_i16)));
1813 assert_parse!(le_i16(&[0xff, 0xff][..]), Ok((&b""[..], -1)));
1814 assert_parse!(le_i16(&[0x00, 0x80][..]), Ok((&b""[..], -32_768_i16)));
1815 }
1816
1817 #[test]
le_u24_tests()1818 fn le_u24_tests() {
1819 assert_parse!(le_u24(&[0x00, 0x00, 0x00][..]), Ok((&b""[..], 0)));
1820 assert_parse!(le_u24(&[0xFF, 0xFF, 0x00][..]), Ok((&b""[..], 65_535_u32)));
1821 assert_parse!(
1822 le_u24(&[0x56, 0x34, 0x12][..]),
1823 Ok((&b""[..], 1_193_046_u32))
1824 );
1825 }
1826
1827 #[test]
le_i24_tests()1828 fn le_i24_tests() {
1829 assert_parse!(le_i24(&[0xFF, 0xFF, 0xFF][..]), Ok((&b""[..], -1_i32)));
1830 assert_parse!(le_i24(&[0x00, 0x00, 0xFF][..]), Ok((&b""[..], -65_536_i32)));
1831 assert_parse!(
1832 le_i24(&[0xAA, 0xCB, 0xED][..]),
1833 Ok((&b""[..], -1_193_046_i32))
1834 );
1835 }
1836
1837 #[test]
le_i32_tests()1838 fn le_i32_tests() {
1839 assert_parse!(le_i32(&[0x00, 0x00, 0x00, 0x00][..]), Ok((&b""[..], 0)));
1840 assert_parse!(
1841 le_i32(&[0xff, 0xff, 0xff, 0x7f][..]),
1842 Ok((&b""[..], 2_147_483_647_i32))
1843 );
1844 assert_parse!(le_i32(&[0xff, 0xff, 0xff, 0xff][..]), Ok((&b""[..], -1)));
1845 assert_parse!(
1846 le_i32(&[0x00, 0x00, 0x00, 0x80][..]),
1847 Ok((&b""[..], -2_147_483_648_i32))
1848 );
1849 }
1850
1851 #[test]
le_i64_tests()1852 fn le_i64_tests() {
1853 assert_parse!(
1854 le_i64(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]),
1855 Ok((&b""[..], 0))
1856 );
1857 assert_parse!(
1858 le_i64(&[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f][..]),
1859 Ok((&b""[..], 9_223_372_036_854_775_807_i64))
1860 );
1861 assert_parse!(
1862 le_i64(&[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff][..]),
1863 Ok((&b""[..], -1))
1864 );
1865 assert_parse!(
1866 le_i64(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80][..]),
1867 Ok((&b""[..], -9_223_372_036_854_775_808_i64))
1868 );
1869 }
1870
1871 #[test]
1872 #[cfg(stable_i128)]
le_i128_tests()1873 fn le_i128_tests() {
1874 assert_parse!(
1875 le_i128(
1876 &[
1877 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1878 0x00
1879 ][..]
1880 ),
1881 Ok((&b""[..], 0))
1882 );
1883 assert_parse!(
1884 le_i128(
1885 &[
1886 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1887 0x7f
1888 ][..]
1889 ),
1890 Ok((
1891 &b""[..],
1892 170_141_183_460_469_231_731_687_303_715_884_105_727_i128
1893 ))
1894 );
1895 assert_parse!(
1896 le_i128(
1897 &[
1898 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1899 0xff
1900 ][..]
1901 ),
1902 Ok((&b""[..], -1))
1903 );
1904 assert_parse!(
1905 le_i128(
1906 &[
1907 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1908 0x80
1909 ][..]
1910 ),
1911 Ok((
1912 &b""[..],
1913 -170_141_183_460_469_231_731_687_303_715_884_105_728_i128
1914 ))
1915 );
1916 }
1917
1918 #[test]
be_f32_tests()1919 fn be_f32_tests() {
1920 assert_parse!(be_f32(&[0x00, 0x00, 0x00, 0x00][..]), Ok((&b""[..], 0_f32)));
1921 assert_parse!(
1922 be_f32(&[0x4d, 0x31, 0x1f, 0xd8][..]),
1923 Ok((&b""[..], 185_728_392_f32))
1924 );
1925 }
1926
1927 #[test]
be_f64_tests()1928 fn be_f64_tests() {
1929 assert_parse!(
1930 be_f64(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]),
1931 Ok((&b""[..], 0_f64))
1932 );
1933 assert_parse!(
1934 be_f64(&[0x41, 0xa6, 0x23, 0xfb, 0x10, 0x00, 0x00, 0x00][..]),
1935 Ok((&b""[..], 185_728_392_f64))
1936 );
1937 }
1938
1939 #[test]
le_f32_tests()1940 fn le_f32_tests() {
1941 assert_parse!(le_f32(&[0x00, 0x00, 0x00, 0x00][..]), Ok((&b""[..], 0_f32)));
1942 assert_parse!(
1943 le_f32(&[0xd8, 0x1f, 0x31, 0x4d][..]),
1944 Ok((&b""[..], 185_728_392_f32))
1945 );
1946 }
1947
1948 #[test]
le_f64_tests()1949 fn le_f64_tests() {
1950 assert_parse!(
1951 le_f64(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]),
1952 Ok((&b""[..], 0_f64))
1953 );
1954 assert_parse!(
1955 le_f64(&[0x00, 0x00, 0x00, 0x10, 0xfb, 0x23, 0xa6, 0x41][..]),
1956 Ok((&b""[..], 185_728_392_f64))
1957 );
1958 }
1959
1960 #[test]
hex_u32_tests()1961 fn hex_u32_tests() {
1962 assert_parse!(
1963 hex_u32(&b";"[..]),
1964 Err(Err::Error(error_position!(&b";"[..], ErrorKind::IsA)))
1965 );
1966 assert_parse!(hex_u32(&b"ff;"[..]), Ok((&b";"[..], 255)));
1967 assert_parse!(hex_u32(&b"1be2;"[..]), Ok((&b";"[..], 7138)));
1968 assert_parse!(hex_u32(&b"c5a31be2;"[..]), Ok((&b";"[..], 3_315_801_058)));
1969 assert_parse!(hex_u32(&b"C5A31be2;"[..]), Ok((&b";"[..], 3_315_801_058)));
1970 assert_parse!(hex_u32(&b"00c5a31be2;"[..]), Ok((&b"e2;"[..], 12_952_347)));
1971 assert_parse!(
1972 hex_u32(&b"c5a31be201;"[..]),
1973 Ok((&b"01;"[..], 3_315_801_058))
1974 );
1975 assert_parse!(hex_u32(&b"ffffffff;"[..]), Ok((&b";"[..], 4_294_967_295)));
1976 assert_parse!(hex_u32(&b"0x1be2;"[..]), Ok((&b"x1be2;"[..], 0)));
1977 assert_parse!(hex_u32(&b"12af"[..]), Ok((&b""[..], 0x12af)));
1978 }
1979
1980 #[test]
1981 #[cfg(feature = "std")]
float_test()1982 fn float_test() {
1983 let mut test_cases = vec![
1984 "+3.14",
1985 "3.14",
1986 "-3.14",
1987 "0",
1988 "0.0",
1989 "1.",
1990 ".789",
1991 "-.5",
1992 "1e7",
1993 "-1E-7",
1994 ".3e-2",
1995 "1.e4",
1996 "1.2e4",
1997 "12.34",
1998 "-1.234E-12",
1999 "-1.234e-12",
2000 "0.00000000000000000087",
2001 ];
2002
2003 for test in test_cases.drain(..) {
2004 let expected32 = str::parse::<f32>(test).unwrap();
2005 let expected64 = str::parse::<f64>(test).unwrap();
2006
2007 println!("now parsing: {} -> {}", test, expected32);
2008
2009 let larger = format!("{}", test);
2010 assert_parse!(recognize_float(&larger[..]), Ok(("", test)));
2011
2012 assert_parse!(float(larger.as_bytes()), Ok((&b""[..], expected32)));
2013 assert_parse!(float(&larger[..]), Ok(("", expected32)));
2014
2015 assert_parse!(double(larger.as_bytes()), Ok((&b""[..], expected64)));
2016 assert_parse!(double(&larger[..]), Ok(("", expected64)));
2017 }
2018
2019 let remaining_exponent = "-1.234E-";
2020 assert_parse!(
2021 recognize_float(remaining_exponent),
2022 Err(Err::Failure(("", ErrorKind::Digit)))
2023 );
2024
2025 let (_i, nan) = float::<_, ()>("NaN").unwrap();
2026 assert!(nan.is_nan());
2027
2028 let (_i, inf) = float::<_, ()>("inf").unwrap();
2029 assert!(inf.is_infinite());
2030 let (_i, inf) = float::<_, ()>("infinite").unwrap();
2031 assert!(inf.is_infinite());
2032 }
2033
2034 #[test]
configurable_endianness()2035 fn configurable_endianness() {
2036 use crate::number::Endianness;
2037
2038 fn be_tst16(i: &[u8]) -> IResult<&[u8], u16> {
2039 u16(Endianness::Big)(i)
2040 }
2041 fn le_tst16(i: &[u8]) -> IResult<&[u8], u16> {
2042 u16(Endianness::Little)(i)
2043 }
2044 assert_eq!(be_tst16(&[0x80, 0x00]), Ok((&b""[..], 32_768_u16)));
2045 assert_eq!(le_tst16(&[0x80, 0x00]), Ok((&b""[..], 128_u16)));
2046
2047 fn be_tst32(i: &[u8]) -> IResult<&[u8], u32> {
2048 u32(Endianness::Big)(i)
2049 }
2050 fn le_tst32(i: &[u8]) -> IResult<&[u8], u32> {
2051 u32(Endianness::Little)(i)
2052 }
2053 assert_eq!(
2054 be_tst32(&[0x12, 0x00, 0x60, 0x00]),
2055 Ok((&b""[..], 302_014_464_u32))
2056 );
2057 assert_eq!(
2058 le_tst32(&[0x12, 0x00, 0x60, 0x00]),
2059 Ok((&b""[..], 6_291_474_u32))
2060 );
2061
2062 fn be_tst64(i: &[u8]) -> IResult<&[u8], u64> {
2063 u64(Endianness::Big)(i)
2064 }
2065 fn le_tst64(i: &[u8]) -> IResult<&[u8], u64> {
2066 u64(Endianness::Little)(i)
2067 }
2068 assert_eq!(
2069 be_tst64(&[0x12, 0x00, 0x60, 0x00, 0x12, 0x00, 0x80, 0x00]),
2070 Ok((&b""[..], 1_297_142_246_100_992_000_u64))
2071 );
2072 assert_eq!(
2073 le_tst64(&[0x12, 0x00, 0x60, 0x00, 0x12, 0x00, 0x80, 0x00]),
2074 Ok((&b""[..], 36_028_874_334_666_770_u64))
2075 );
2076
2077 fn be_tsti16(i: &[u8]) -> IResult<&[u8], i16> {
2078 i16(Endianness::Big)(i)
2079 }
2080 fn le_tsti16(i: &[u8]) -> IResult<&[u8], i16> {
2081 i16(Endianness::Little)(i)
2082 }
2083 assert_eq!(be_tsti16(&[0x00, 0x80]), Ok((&b""[..], 128_i16)));
2084 assert_eq!(le_tsti16(&[0x00, 0x80]), Ok((&b""[..], -32_768_i16)));
2085
2086 fn be_tsti32(i: &[u8]) -> IResult<&[u8], i32> {
2087 i32(Endianness::Big)(i)
2088 }
2089 fn le_tsti32(i: &[u8]) -> IResult<&[u8], i32> {
2090 i32(Endianness::Little)(i)
2091 }
2092 assert_eq!(
2093 be_tsti32(&[0x00, 0x12, 0x60, 0x00]),
2094 Ok((&b""[..], 1_204_224_i32))
2095 );
2096 assert_eq!(
2097 le_tsti32(&[0x00, 0x12, 0x60, 0x00]),
2098 Ok((&b""[..], 6_296_064_i32))
2099 );
2100
2101 fn be_tsti64(i: &[u8]) -> IResult<&[u8], i64> {
2102 i64(Endianness::Big)(i)
2103 }
2104 fn le_tsti64(i: &[u8]) -> IResult<&[u8], i64> {
2105 i64(Endianness::Little)(i)
2106 }
2107 assert_eq!(
2108 be_tsti64(&[0x00, 0xFF, 0x60, 0x00, 0x12, 0x00, 0x80, 0x00]),
2109 Ok((&b""[..], 71_881_672_479_506_432_i64))
2110 );
2111 assert_eq!(
2112 le_tsti64(&[0x00, 0xFF, 0x60, 0x00, 0x12, 0x00, 0x80, 0x00]),
2113 Ok((&b""[..], 36_028_874_334_732_032_i64))
2114 );
2115 }
2116
2117 #[cfg(feature = "std")]
parse_f64(i: &str) -> IResult<&str, f64, ()>2118 fn parse_f64(i: &str) -> IResult<&str, f64, ()> {
2119 match recognize_float(i) {
2120 Err(e) => Err(e),
2121 Ok((i, s)) => {
2122 if s.is_empty() {
2123 return Err(Err::Error(()));
2124 }
2125 match s.parse_to() {
2126 Some(n) => Ok((i, n)),
2127 None => Err(Err::Error(())),
2128 }
2129 }
2130 }
2131 }
2132
2133 proptest! {
2134 #[test]
2135 #[cfg(feature = "std")]
2136 fn floats(s in "\\PC*") {
2137 println!("testing {}", s);
2138 let res1 = parse_f64(&s);
2139 let res2 = double::<_, ()>(s.as_str());
2140 assert_eq!(res1, res2);
2141 }
2142 }
2143 }
2144