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