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