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