1 //! Parsers for applying parsers multiple times 2 3 /// `separated_list!(I -> IResult<I,T>, I -> IResult<I,O>) => I -> IResult<I, Vec<O>>` 4 /// separated_list(sep, X) returns Vec<X> will return Incomplete if there may be more elements 5 #[cfg(feature = "alloc")] 6 #[macro_export(local_inner_macros)] 7 macro_rules! separated_list( 8 ($i:expr, $sep:ident!( $($args:tt)* ), $submac:ident!( $($args2:tt)* )) => ( 9 { 10 use $crate::lib::std::result::Result::*; 11 use $crate::Err; 12 13 use $crate::InputLength; 14 15 //FIXME: use crate vec 16 let mut res = $crate::lib::std::vec::Vec::new(); 17 let mut input = $i.clone(); 18 19 // get the first element 20 let input_ = input.clone(); 21 match $submac!(input_, $($args2)*) { 22 Err(Err::Error(_)) => Ok((input, res)), 23 Err(e) => Err(e), 24 Ok((i,o)) => { 25 if i.input_len() == input.input_len() { 26 Err(Err::Error(error_position!(input, $crate::ErrorKind::SeparatedList))) 27 } else { 28 res.push(o); 29 input = i; 30 31 let ret; 32 33 loop { 34 // get the separator first 35 let input_ = input.clone(); 36 match $sep!(input_, $($args)*) { 37 Err(Err::Error(_)) => { 38 ret = Ok((input, res)); 39 break; 40 } 41 Err(e) => { 42 ret = Err(e); 43 break; 44 }, 45 Ok((i2,_)) => { 46 let i2_len = i2.input_len(); 47 if i2_len == input.input_len() { 48 ret = Ok((input, res)); 49 break; 50 } 51 52 // get the element next 53 match $submac!(i2, $($args2)*) { 54 Err(Err::Error(_)) => { 55 ret = Ok((input, res)); 56 break; 57 }, 58 Err(e) => { 59 ret = Err(e); 60 break; 61 }, 62 Ok((i3,o3)) => { 63 if i3.input_len() == i2_len { 64 ret = Ok((input, res)); 65 break; 66 } 67 res.push(o3); 68 input = i3; 69 } 70 } 71 } 72 } 73 } 74 75 ret 76 } 77 }, 78 } 79 } 80 ); 81 ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => ( 82 separated_list!($i, $submac!($($args)*), call!($g)); 83 ); 84 ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => ( 85 separated_list!($i, call!($f), $submac!($($args)*)); 86 ); 87 ($i:expr, $f:expr, $g:expr) => ( 88 separated_list!($i, call!($f), call!($g)); 89 ); 90 ); 91 92 /// `separated_nonempty_list!(I -> IResult<I,T>, I -> IResult<I,O>) => I -> IResult<I, Vec<O>>` 93 /// separated_nonempty_list(sep, X) returns Vec<X> will return Incomplete if there may be more elements 94 #[macro_export(local_inner_macros)] 95 macro_rules! separated_nonempty_list( 96 ($i:expr, $sep:ident!( $($args:tt)* ), $submac:ident!( $($args2:tt)* )) => ( 97 { 98 use $crate::lib::std::result::Result::*; 99 use $crate::{Err,ErrorKind}; 100 use $crate::InputLength; 101 102 let mut res = $crate::lib::std::vec::Vec::new(); 103 let mut input = $i.clone(); 104 105 // get the first element 106 let input_ = input.clone(); 107 match $submac!(input_, $($args2)*) { 108 Err(e) => Err(e), 109 Ok((i,o)) => { 110 if i.input_len() == input.input_len() { 111 let e = ErrorKind::SeparatedNonEmptyList; 112 Err(Err::Error(error_position!(input, e))) 113 } else { 114 res.push(o); 115 input = i; 116 117 let ret; 118 119 loop { 120 // get the separator first 121 let input_ = input.clone(); 122 match $sep!(input_, $($args)*) { 123 Err(Err::Error(_)) => { 124 ret = Ok((input, res)); 125 break; 126 } 127 Err(e) => { 128 ret = Err(e); 129 break; 130 }, 131 Ok((i2,_)) => { 132 let i2_len = i2.input_len(); 133 if i2_len == input.input_len() { 134 ret = Ok((input, res)); 135 break; 136 } 137 138 // get the element next 139 match $submac!(i2, $($args2)*) { 140 Err(Err::Error(_)) => { 141 ret = Ok((input, res)); 142 break; 143 }, 144 Err(e) => { 145 ret = Err(e); 146 break; 147 }, 148 Ok((i3,o3)) => { 149 if i3.input_len() == i2_len { 150 ret = Ok((input, res)); 151 break; 152 } 153 res.push(o3); 154 input = i3; 155 } 156 } 157 } 158 } 159 } 160 161 ret 162 } 163 }, 164 } 165 } 166 ); 167 ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => ( 168 separated_nonempty_list!($i, $submac!($($args)*), call!($g)); 169 ); 170 ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => ( 171 separated_nonempty_list!($i, call!($f), $submac!($($args)*)); 172 ); 173 ($i:expr, $f:expr, $g:expr) => ( 174 separated_nonempty_list!($i, call!($f), call!($g)); 175 ); 176 ); 177 178 /// `separated_list_complete!(I -> IResult<I,T>, I -> IResult<I,O>) => I -> IResult<I, Vec<O>>` 179 /// This is equivalent to the `separated_list!` combinator, except that it will return `Error` 180 /// when either the separator or element subparser returns `Incomplete`. 181 #[macro_export(local_inner_macros)] 182 macro_rules! separated_list_complete { 183 ($i:expr, $sep:ident!( $($args:tt)* ), $submac:ident!( $($args2:tt)* )) => ({ 184 separated_list!($i, complete!($sep!($($args)*)), complete!($submac!($($args2)*))) 185 }); 186 187 ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => ( 188 separated_list_complete!($i, $submac!($($args)*), call!($g)); 189 ); 190 ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => ( 191 separated_list_complete!($i, call!($f), $submac!($($args)*)); 192 ); 193 ($i:expr, $f:expr, $g:expr) => ( 194 separated_list_complete!($i, call!($f), call!($g)); 195 ); 196 } 197 198 /// `separated_nonempty_list_complete!(I -> IResult<I,T>, I -> IResult<I,O>) => I -> IResult<I, Vec<O>>` 199 /// This is equivalent to the `separated_nonempty_list!` combinator, except that it will return 200 /// `Error` when either the separator or element subparser returns `Incomplete`. 201 #[macro_export(local_inner_macros)] 202 macro_rules! separated_nonempty_list_complete { 203 ($i:expr, $sep:ident!( $($args:tt)* ), $submac:ident!( $($args2:tt)* )) => ({ 204 separated_nonempty_list!($i, complete!($sep!($($args)*)), complete!($submac!($($args2)*))) 205 }); 206 207 ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => ( 208 separated_nonempty_list_complete!($i, $submac!($($args)*), call!($g)); 209 ); 210 ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => ( 211 separated_nonempty_list_complete!($i, call!($f), $submac!($($args)*)); 212 ); 213 ($i:expr, $f:expr, $g:expr) => ( 214 separated_nonempty_list_complete!($i, call!($f), call!($g)); 215 ); 216 } 217 218 /// `many0!(I -> IResult<I,O>) => I -> IResult<I, Vec<O>>` 219 /// Applies the parser 0 or more times and returns the list of results in a Vec. 220 /// 221 /// The embedded parser may return Incomplete. 222 /// 223 /// `many0` will only return `Error` if the embedded parser does not consume any input 224 /// (to avoid infinite loops). 225 /// 226 /// ``` 227 /// # #[macro_use] extern crate nom; 228 /// # fn main() { 229 /// named!(multi<&[u8], Vec<&[u8]> >, many0!( tag!( "abcd" ) ) ); 230 /// 231 /// let a = b"abcdabcdefgh"; 232 /// let b = b"azerty"; 233 /// 234 /// let res = vec![&b"abcd"[..], &b"abcd"[..]]; 235 /// assert_eq!(multi(&a[..]),Ok((&b"efgh"[..], res))); 236 /// assert_eq!(multi(&b[..]),Ok((&b"azerty"[..], Vec::new()))); 237 /// # } 238 /// ``` 239 /// 240 #[cfg(feature = "alloc")] 241 #[macro_export(local_inner_macros)] 242 macro_rules! many0( 243 ($i:expr, $submac:ident!( $($args:tt)* )) => ( 244 { 245 use $crate::lib::std::result::Result::*; 246 use $crate::{Err,AtEof}; 247 248 let ret; 249 let mut res = $crate::lib::std::vec::Vec::new(); 250 let mut input = $i.clone(); 251 252 loop { 253 let input_ = input.clone(); 254 match $submac!(input_, $($args)*) { 255 Ok((i, o)) => { 256 // loop trip must always consume (otherwise infinite loops) 257 if i == input { 258 259 if i.at_eof() { 260 ret = Ok((input, res)); 261 } else { 262 ret = Err(Err::Error(error_position!(input, $crate::ErrorKind::Many0))); 263 } 264 break; 265 } 266 res.push(o); 267 268 input = i; 269 }, 270 Err(Err::Error(_)) => { 271 ret = Ok((input, res)); 272 break; 273 }, 274 Err(e) => { 275 ret = Err(e); 276 break; 277 }, 278 } 279 } 280 281 ret 282 } 283 ); 284 ($i:expr, $f:expr) => ( 285 many0!($i, call!($f)); 286 ); 287 ); 288 289 /// `many1!(I -> IResult<I,O>) => I -> IResult<I, Vec<O>>` 290 /// Applies the parser 1 or more times and returns the list of results in a Vec 291 /// 292 /// the embedded parser may return Incomplete 293 /// 294 /// ``` 295 /// # #[macro_use] extern crate nom; 296 /// # use nom::Err; 297 /// # use nom::ErrorKind; 298 /// # use nom::types::CompleteByteSlice; 299 /// # fn main() { 300 /// named!(multi<&[u8], Vec<&[u8]> >, many1!( tag!( "abcd" ) ) ); 301 /// 302 /// let a = b"abcdabcdefgh"; 303 /// let b = b"azerty"; 304 /// 305 /// let res = vec![&b"abcd"[..], &b"abcd"[..]]; 306 /// assert_eq!(multi(&a[..]), Ok((&b"efgh"[..], res))); 307 /// assert_eq!(multi(&b[..]), Err(Err::Error(error_position!(&b[..], ErrorKind::Many1)))); 308 /// 309 /// named!(multi_complete<CompleteByteSlice, Vec<CompleteByteSlice> >, many1!( tag!( "abcd" ) ) ); 310 /// let c = CompleteByteSlice(b"abcdabcd"); 311 /// 312 /// let res = vec![CompleteByteSlice(b"abcd"), CompleteByteSlice(b"abcd")]; 313 /// assert_eq!(multi_complete(c), Ok((CompleteByteSlice(b""), res))); 314 /// # } 315 /// ``` 316 #[cfg(feature = "alloc")] 317 #[macro_export(local_inner_macros)] 318 macro_rules! many1( 319 ($i:expr, $submac:ident!( $($args:tt)* )) => ( 320 { 321 use $crate::lib::std::result::Result::*; 322 use $crate::Err; 323 324 use $crate::InputLength; 325 let i_ = $i.clone(); 326 match $submac!(i_, $($args)*) { 327 Err(Err::Error(_)) => Err(Err::Error( 328 error_position!(i_, $crate::ErrorKind::Many1) 329 )), 330 Err(Err::Failure(_)) => Err(Err::Failure( 331 error_position!(i_, $crate::ErrorKind::Many1) 332 )), 333 Err(i) => Err(i), 334 Ok((i1,o1)) => { 335 let mut res = $crate::lib::std::vec::Vec::with_capacity(4); 336 res.push(o1); 337 let mut input = i1; 338 let mut error = $crate::lib::std::option::Option::None; 339 loop { 340 let input_ = input.clone(); 341 match $submac!(input_, $($args)*) { 342 Err(Err::Error(_)) => { 343 break; 344 }, 345 Err(e) => { 346 error = $crate::lib::std::option::Option::Some(e); 347 break; 348 }, 349 Ok((i, o)) => { 350 if i.input_len() == input.input_len() { 351 break; 352 } 353 res.push(o); 354 input = i; 355 } 356 } 357 } 358 359 match error { 360 $crate::lib::std::option::Option::Some(e) => Err(e), 361 $crate::lib::std::option::Option::None => Ok((input, res)) 362 } 363 } 364 } 365 } 366 ); 367 ($i:expr, $f:expr) => ( 368 many1!($i, call!($f)); 369 ); 370 ); 371 372 /// `many_till!(I -> IResult<I,O>, I -> IResult<I,P>) => I -> IResult<I, (Vec<O>, P)>` 373 /// Applies the first parser until the second applies. Returns a tuple containing the list 374 /// of results from the first in a Vec and the result of the second. 375 /// 376 /// The first embedded parser may return Incomplete 377 /// 378 /// ``` 379 /// # #[macro_use] extern crate nom; 380 /// # use nom::Err; 381 /// # use nom::ErrorKind; 382 /// # fn main() { 383 /// named!(multi<&[u8], (Vec<&[u8]>, &[u8]) >, many_till!( tag!( "abcd" ), tag!( "efgh" ) ) ); 384 /// 385 /// let a = b"abcdabcdefghabcd"; 386 /// let b = b"efghabcd"; 387 /// let c = b"azerty"; 388 /// 389 /// let res_a = (vec![&b"abcd"[..], &b"abcd"[..]], &b"efgh"[..]); 390 /// let res_b: (Vec<&[u8]>, &[u8]) = (Vec::new(), &b"efgh"[..]); 391 /// assert_eq!(multi(&a[..]),Ok((&b"abcd"[..], res_a))); 392 /// assert_eq!(multi(&b[..]),Ok((&b"abcd"[..], res_b))); 393 /// assert_eq!(multi(&c[..]), Err(Err::Error(error_node_position!(&c[..], ErrorKind::ManyTill, 394 /// error_position!(&c[..], ErrorKind::Tag))))); 395 /// # } 396 /// ``` 397 #[cfg(feature = "alloc")] 398 #[macro_export(local_inner_macros)] 399 macro_rules! many_till( 400 (__impl $i:expr, $submac1:ident!( $($args1:tt)* ), $submac2:ident!( $($args2:tt)* )) => ( 401 { 402 use $crate::lib::std::result::Result::*; 403 use $crate::{Err,ErrorKind}; 404 405 let ret; 406 let mut res = $crate::lib::std::vec::Vec::new(); 407 let mut input = $i.clone(); 408 409 loop { 410 match $submac2!(input, $($args2)*) { 411 Ok((i, o)) => { 412 ret = Ok((i, (res, o))); 413 break; 414 }, 415 Err(e1) => { 416 match $submac1!(input, $($args1)*) { 417 Err(Err::Error(err)) => { 418 fn unify_types<T>(_: &T, _: &T) {} 419 let e = Err::Error(error_node_position!(input, ErrorKind::ManyTill, err)); 420 unify_types(&e1, &e); 421 422 ret = Err(e); 423 break; 424 }, 425 Err(e) => { 426 ret = Err(e); 427 break; 428 }, 429 Ok((i, o)) => { 430 // loop trip must always consume (otherwise infinite loops) 431 if i == input { 432 ret = Err(Err::Error(error_position!(input, $crate::ErrorKind::ManyTill))); 433 break; 434 } 435 436 res.push(o); 437 input = i; 438 }, 439 } 440 }, 441 } 442 } 443 444 ret 445 } 446 ); 447 ($i:expr, $submac1:ident!( $($args1:tt)* ), $submac2:ident!( $($args2:tt)* )) => ( 448 many_till!(__impl $i, $submac1!($($args1)*), $submac2!($($args2)*)); 449 ); 450 ($i:expr, $submac1:ident!( $($args1:tt)* ), $g:expr) => ( 451 many_till!(__impl $i, $submac1!($($args1)*), call!($g)); 452 ); 453 ($i:expr, $f:expr, $submac2:ident!( $($args2:tt)* )) => ( 454 many_till!(__impl $i, call!($f), $submac2!($($args2)*)); 455 ); 456 ($i:expr, $f:expr, $g: expr) => ( 457 many_till!(__impl $i, call!($f), call!($g)); 458 ); 459 ); 460 461 /// `many_m_n!(usize, usize, I -> IResult<I,O>) => I -> IResult<I, Vec<O>>` 462 /// Applies the parser between m and n times (n included) and returns the list of 463 /// results in a Vec 464 /// 465 /// the embedded parser may return Incomplete 466 /// 467 /// ``` 468 /// # #[macro_use] extern crate nom; 469 /// # use nom::Err; 470 /// # use nom::ErrorKind; 471 /// # fn main() { 472 /// named!(multi<&[u8], Vec<&[u8]> >, many_m_n!(2, 4, tag!( "abcd" ) ) ); 473 /// 474 /// let a = b"abcdefgh"; 475 /// let b = b"abcdabcdefgh"; 476 /// let c = b"abcdabcdabcdabcdabcdefgh"; 477 /// 478 /// assert_eq!(multi(&a[..]), Err(Err::Error(error_position!(&a[..], ErrorKind::ManyMN)))); 479 /// let res = vec![&b"abcd"[..], &b"abcd"[..]]; 480 /// assert_eq!(multi(&b[..]),Ok((&b"efgh"[..], res))); 481 /// let res2 = vec![&b"abcd"[..], &b"abcd"[..], &b"abcd"[..], &b"abcd"[..]]; 482 /// assert_eq!(multi(&c[..]),Ok((&b"abcdefgh"[..], res2))); 483 /// # } 484 /// ``` 485 #[cfg(feature = "alloc")] 486 #[macro_export(local_inner_macros)] 487 macro_rules! many_m_n( 488 ($i:expr, $m:expr, $n: expr, $submac:ident!( $($args:tt)* )) => ( 489 { 490 use $crate::lib::std::result::Result::*; 491 use $crate::{Context,Err,Needed}; 492 493 use $crate::InputLength; 494 let mut res = $crate::lib::std::vec::Vec::with_capacity($m); 495 let mut input = $i.clone(); 496 let mut count: usize = 0; 497 let mut err = false; 498 let mut incomplete: $crate::lib::std::option::Option<Needed> = $crate::lib::std::option::Option::None; 499 let mut failure: $crate::lib::std::option::Option<Context<_,_>> = $crate::lib::std::option::Option::None; 500 loop { 501 if count == $n { break } 502 let i_ = input.clone(); 503 match $submac!(i_, $($args)*) { 504 Ok((i, o)) => { 505 // do not allow parsers that do not consume input (causes infinite loops) 506 if i.input_len() == input.input_len() { 507 break; 508 } 509 res.push(o); 510 input = i; 511 count += 1; 512 } 513 Err(Err::Error(_)) => { 514 err = true; 515 break; 516 }, 517 Err(Err::Incomplete(i)) => { 518 incomplete = $crate::lib::std::option::Option::Some(i); 519 break; 520 }, 521 Err(Err::Failure(e)) => { 522 failure = $crate::lib::std::option::Option::Some(e); 523 break; 524 }, 525 } 526 } 527 528 if count < $m { 529 if err { 530 Err(Err::Error(error_position!($i, $crate::ErrorKind::ManyMN))) 531 } else { 532 match failure { 533 $crate::lib::std::option::Option::Some(i) => Err(Err::Failure(i)), 534 $crate::lib::std::option::Option::None => match incomplete { 535 $crate::lib::std::option::Option::Some(i) => $crate::need_more($i, i), 536 $crate::lib::std::option::Option::None => $crate::need_more($i, Needed::Unknown) 537 } 538 } 539 } 540 } else { 541 match failure { 542 $crate::lib::std::option::Option::Some(i) => Err(Err::Failure(i)), 543 $crate::lib::std::option::Option::None => match incomplete { 544 $crate::lib::std::option::Option::Some(i) => $crate::need_more($i, i), 545 $crate::lib::std::option::Option::None => Ok((input, res)) 546 } 547 } 548 } 549 } 550 ); 551 ($i:expr, $m:expr, $n: expr, $f:expr) => ( 552 many_m_n!($i, $m, $n, call!($f)); 553 ); 554 ); 555 556 /// `many0_count!(I -> IResult<I,O>) => I -> IResult<I, usize>` 557 /// Applies the parser 0 or more times and returns the number of times the parser was applied. 558 /// 559 /// `many0_count` will only return `Error` if the embedded parser does not consume any input 560 /// (to avoid infinite loops). 561 /// 562 /// ``` 563 /// #[macro_use] extern crate nom; 564 /// use nom::digit; 565 /// 566 /// named!(number<&[u8], usize>, many0_count!(pair!(digit, tag!(",")))); 567 /// 568 /// fn main() { 569 /// assert_eq!(number(&b"123,45,abc"[..]), Ok((&b"abc"[..], 2))); 570 /// } 571 /// ``` 572 /// 573 #[macro_export] 574 macro_rules! many0_count { 575 ($i:expr, $submac:ident!( $($args:tt)* )) => ( 576 { 577 use $crate::lib::std::result::Result::*; 578 use $crate::{Err, AtEof}; 579 580 let ret; 581 let mut count: usize = 0; 582 let mut input = $i.clone(); 583 584 loop { 585 let input_ = input.clone(); 586 match $submac!(input_, $($args)*) { 587 Ok((i, _)) => { 588 // loop trip must always consume (otherwise infinite loops) 589 if i == input { 590 if i.at_eof() { 591 ret = Ok((input, count)); 592 } 593 else { 594 ret = Err(Err::Error(error_position!(input, $crate::ErrorKind::Many0Count))); 595 } 596 break; 597 } 598 count += 1; 599 input = i; 600 }, 601 602 Err(Err::Error(_)) => { 603 ret = Ok((input, count)); 604 break; 605 }, 606 607 Err(e) => { 608 ret = Err(e); 609 break; 610 }, 611 } 612 } 613 614 ret 615 } 616 ); 617 618 ($i:expr, $f:expr) => ( 619 many0_count!($i, call!($f)); 620 ); 621 } 622 623 /// `many1_count!(I -> IResult<I,O>) => I -> IResult<I, usize>` 624 /// Applies the parser 1 or more times and returns the number of times the parser was applied. 625 /// 626 /// ``` 627 /// #[macro_use] extern crate nom; 628 /// use nom::digit; 629 /// 630 /// named!(number<&[u8], usize>, many1_count!(pair!(digit, tag!(",")))); 631 /// 632 /// fn main() { 633 /// assert_eq!(number(&b"123,45,abc"[..]), Ok((&b"abc"[..], 2))); 634 /// } 635 /// ``` 636 /// 637 #[macro_export] 638 macro_rules! many1_count { 639 ($i:expr, $submac:ident!( $($args:tt)* )) => ( 640 { 641 use $crate::lib::std::result::Result::*; 642 use $crate::Err; 643 644 use $crate::InputLength; 645 let i_ = $i.clone(); 646 match $submac!(i_, $($args)*) { 647 Err(Err::Error(_)) => Err(Err::Error( 648 error_position!(i_, $crate::ErrorKind::Many1Count) 649 )), 650 651 Err(Err::Failure(_)) => Err(Err::Failure( 652 error_position!(i_, $crate::ErrorKind::Many1Count) 653 )), 654 655 Err(i) => Err(i), 656 657 Ok((i1, _)) => { 658 let mut count: usize = 1; 659 let mut input = i1; 660 let mut error = $crate::lib::std::option::Option::None; 661 662 loop { 663 let input_ = input.clone(); 664 match $submac!(input_, $($args)*) { 665 Err(Err::Error(_)) => { 666 break; 667 }, 668 669 Err(e) => { 670 error = $crate::lib::std::option::Option::Some(e); 671 break; 672 }, 673 674 Ok((i, _)) => { 675 if i.input_len() == input.input_len() { 676 break; 677 } 678 count += 1; 679 input = i; 680 }, 681 } 682 } 683 684 match error { 685 $crate::lib::std::option::Option::Some(e) => Err(e), 686 $crate::lib::std::option::Option::None => Ok((input, count)), 687 } 688 }, 689 } 690 } 691 ); 692 693 ($i:expr, $f:expr) => ( 694 many1_count!($i, call!($f)); 695 ); 696 } 697 698 /// `count!(I -> IResult<I,O>, nb) => I -> IResult<I, Vec<O>>` 699 /// Applies the child parser a specified number of times 700 /// 701 /// ``` 702 /// # #[macro_use] extern crate nom; 703 /// # use nom::Err; 704 /// # use nom::ErrorKind; 705 /// # fn main() { 706 /// named!(counter< Vec<&[u8]> >, count!( tag!( "abcd" ), 2 ) ); 707 /// 708 /// let a = b"abcdabcdabcdef"; 709 /// let b = b"abcdefgh"; 710 /// let res = vec![&b"abcd"[..], &b"abcd"[..]]; 711 /// 712 /// assert_eq!(counter(&a[..]),Ok((&b"abcdef"[..], res))); 713 /// assert_eq!(counter(&b[..]), Err(Err::Error(error_position!(&b[..], ErrorKind::Count)))); 714 /// # } 715 /// ``` 716 /// 717 #[cfg(feature = "alloc")] 718 #[macro_export(local_inner_macros)] 719 macro_rules! count( 720 ($i:expr, $submac:ident!( $($args:tt)* ), $count: expr) => ( 721 { 722 use $crate::lib::std::result::Result::*; 723 use $crate::Err; 724 725 let ret; 726 let mut input = $i.clone(); 727 let mut res = $crate::lib::std::vec::Vec::new(); 728 729 loop { 730 if res.len() == $count { 731 ret = Ok((input, res)); 732 break; 733 } 734 735 let input_ = input.clone(); 736 match $submac!(input_, $($args)*) { 737 Ok((i,o)) => { 738 res.push(o); 739 input = i; 740 }, 741 Err(Err::Error(e)) => { 742 fn unify_types<T>(_: &T, _: &T) {} 743 let e2 = error_position!($i, $crate::ErrorKind::Count); 744 unify_types(&e, &e2); 745 746 ret = Err(Err::Error(e2)); 747 break; 748 }, 749 Err(e) => { 750 ret = Err(e); 751 break; 752 }, 753 } 754 } 755 756 ret 757 } 758 ); 759 ($i:expr, $f:expr, $count: expr) => ( 760 count!($i, call!($f), $count); 761 ); 762 ); 763 764 /// `count_fixed!(O, I -> IResult<I,O>, nb) => I -> IResult<I, [O; nb]>` 765 /// Applies the child parser a fixed number of times and returns a fixed size array 766 /// The type must be specified and it must be `Copy` 767 /// 768 /// ``` 769 /// # #[macro_use] extern crate nom; 770 /// # use nom::Err; 771 /// # use nom::ErrorKind; 772 /// # fn main() { 773 /// named!(counter< [&[u8]; 2] >, count_fixed!( &[u8], tag!( "abcd" ), 2 ) ); 774 /// // can omit the type specifier if returning slices 775 /// // named!(counter< [&[u8]; 2] >, count_fixed!( tag!( "abcd" ), 2 ) ); 776 /// 777 /// let a = b"abcdabcdabcdef"; 778 /// let b = b"abcdefgh"; 779 /// let res = [&b"abcd"[..], &b"abcd"[..]]; 780 /// 781 /// assert_eq!(counter(&a[..]),Ok((&b"abcdef"[..], res))); 782 /// assert_eq!(counter(&b[..]), Err(Err::Error(error_position!(&b[..], ErrorKind::Count)))); 783 /// # } 784 /// ``` 785 /// 786 #[macro_export(local_inner_macros)] 787 macro_rules! count_fixed ( 788 ($i:expr, $typ:ty, $submac:ident!( $($args:tt)* ), $count: expr) => ( 789 { 790 use $crate::lib::std::result::Result::*; 791 use $crate::Err; 792 793 let ret; 794 let mut input = $i.clone(); 795 // `$typ` must be Copy, and thus having no destructor, this is panic safe 796 let mut res: [$typ; $count] = unsafe{[$crate::lib::std::mem::uninitialized(); $count as usize]}; 797 let mut cnt: usize = 0; 798 799 loop { 800 if cnt == $count { 801 ret = Ok((input, res)); break; 802 } 803 804 match $submac!(input, $($args)*) { 805 Ok((i,o)) => { 806 res[cnt] = o; 807 cnt += 1; 808 input = i; 809 }, 810 Err(Err::Error(e)) => { 811 fn unify_types<T>(_: &T, _: &T) {} 812 let e2 = error_position!($i, $crate::ErrorKind::Count); 813 unify_types(&e, &e2); 814 ret = Err(Err::Error(e2)); 815 break; 816 }, 817 Err(e) => { 818 ret = Err(e); 819 break; 820 }, 821 } 822 } 823 824 ret 825 } 826 ); 827 ($i:expr, $typ: ty, $f:expr, $count: expr) => ( 828 count_fixed!($i, $typ, call!($f), $count); 829 ); 830 ); 831 832 /// `length_count!(I -> IResult<I, nb>, I -> IResult<I,O>) => I -> IResult<I, Vec<O>>` 833 /// gets a number from the first parser, then applies the second parser that many times 834 #[macro_export(local_inner_macros)] 835 macro_rules! length_count( 836 ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => ( 837 { 838 use $crate::lib::std::result::Result::*; 839 use $crate::{Err,Convert}; 840 841 match $submac!($i, $($args)*) { 842 Err(e) => Err(Err::convert(e)), 843 Ok((i, o)) => { 844 match count!(i, $submac2!($($args2)*), o as usize) { 845 Err(e) => Err(Err::convert(e)), 846 Ok((i2, o2)) => Ok((i2, o2)) 847 } 848 } 849 } 850 } 851 ); 852 853 ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => ( 854 length_count!($i, $submac!($($args)*), call!($g)); 855 ); 856 857 ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => ( 858 length_count!($i, call!($f), $submac!($($args)*)); 859 ); 860 861 ($i:expr, $f:expr, $g:expr) => ( 862 length_count!($i, call!($f), call!($g)); 863 ); 864 ); 865 866 /// `length_data!(I -> IResult<I, nb>) => O` 867 /// 868 /// `length_data` gets a number from the first parser, than takes a subslice of the input 869 /// of that size, and returns that subslice 870 #[macro_export(local_inner_macros)] 871 macro_rules! length_data( 872 ($i:expr, $submac:ident!( $($args:tt)* )) => ({ 873 use $crate::lib::std::result::Result::*; 874 use $crate::{Convert,Err}; 875 876 match $submac!($i, $($args)*) { 877 Err(e) => Err(e), 878 Ok((i, o)) => { 879 match take!(i, o as usize) { 880 Err(e) => Err(Err::convert(e)), 881 Ok((i2, o2)) => Ok((i2, o2)) 882 } 883 } 884 } 885 }); 886 887 ($i:expr, $f:expr) => ( 888 length_data!($i, call!($f)); 889 ); 890 ); 891 892 /// `length_value!(I -> IResult<I, nb>, I -> IResult<I,O>) => I -> IResult<I, O>` 893 /// 894 /// Gets a number from the first parser, takes a subslice of the input of that size, 895 /// then applies the second parser on that subslice. If the second parser returns 896 /// `Incomplete`, `length_value` will return an error 897 #[macro_export(local_inner_macros)] 898 macro_rules! length_value( 899 ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => ( 900 { 901 use $crate::lib::std::result::Result::*; 902 use $crate::{Err,Convert}; 903 904 match $submac!($i, $($args)*) { 905 Err(e) => Err(e), 906 Ok((i, o)) => { 907 match take!(i, o as usize) { 908 Err(e) => Err(Err::convert(e)), 909 Ok((i2, o2)) => { 910 match complete!(o2, $submac2!($($args2)*)) { 911 Err(e) => Err(Err::convert(e)), 912 Ok((_, o3)) => Ok((i2, o3)) 913 } 914 } 915 } 916 } 917 } 918 } 919 ); 920 921 ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => ( 922 length_value!($i, $submac!($($args)*), call!($g)); 923 ); 924 925 ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => ( 926 length_value!($i, call!($f), $submac!($($args)*)); 927 ); 928 929 ($i:expr, $f:expr, $g:expr) => ( 930 length_value!($i, call!($f), call!($g)); 931 ); 932 ); 933 934 /// `fold_many0!(I -> IResult<I,O>, R, Fn(R, O) -> R) => I -> IResult<I, R>` 935 /// Applies the parser 0 or more times and folds the list of return values 936 /// 937 /// the embedded parser may return Incomplete 938 /// 939 /// ``` 940 /// # #[macro_use] extern crate nom; 941 /// # fn main() { 942 /// named!(multi<&[u8], Vec<&[u8]> >, 943 /// fold_many0!( tag!( "abcd" ), Vec::new(), |mut acc: Vec<_>, item| { 944 /// acc.push(item); 945 /// acc 946 /// })); 947 /// 948 /// let a = b"abcdabcdefgh"; 949 /// let b = b"azerty"; 950 /// 951 /// let res = vec![&b"abcd"[..], &b"abcd"[..]]; 952 /// assert_eq!(multi(&a[..]),Ok((&b"efgh"[..], res))); 953 /// assert_eq!(multi(&b[..]),Ok((&b"azerty"[..], Vec::new()))); 954 /// # } 955 /// ``` 956 /// 0 or more 957 #[macro_export(local_inner_macros)] 958 macro_rules! fold_many0( 959 ($i:expr, $submac:ident!( $($args:tt)* ), $init:expr, $f:expr) => ( 960 { 961 use $crate::lib::std::result::Result::*; 962 use $crate::{Err,AtEof}; 963 964 let ret; 965 let f = $f; 966 let mut res = $init; 967 let mut input = $i.clone(); 968 969 loop { 970 match $submac!(input, $($args)*) { 971 Ok((i, o)) => { 972 // loop trip must always consume (otherwise infinite loops) 973 if i == input { 974 if i.at_eof() { 975 ret = Ok((input, res)); 976 } else { 977 ret = Err(Err::Error(error_position!(input, $crate::ErrorKind::Many0))); 978 } 979 break; 980 } 981 982 res = f(res, o); 983 input = i; 984 }, 985 Err(Err::Error(_)) => { 986 ret = Ok((input, res)); 987 break; 988 }, 989 Err(e) => { 990 ret = Err(e); 991 break; 992 }, 993 } 994 } 995 996 ret 997 } 998 ); 999 ($i:expr, $f:expr, $init:expr, $fold_f:expr) => ( 1000 fold_many0!($i, call!($f), $init, $fold_f); 1001 ); 1002 ); 1003 1004 /// `fold_many1!(I -> IResult<I,O>, R, Fn(R, O) -> R) => I -> IResult<I, R>` 1005 /// Applies the parser 1 or more times and folds the list of return values 1006 /// 1007 /// the embedded parser may return Incomplete 1008 /// 1009 /// ``` 1010 /// # #[macro_use] extern crate nom; 1011 /// # use nom::Err; 1012 /// # use nom::ErrorKind; 1013 /// # fn main() { 1014 /// named!(multi<&[u8], Vec<&[u8]> >, 1015 /// fold_many1!( tag!( "abcd" ), Vec::new(), |mut acc: Vec<_>, item| { 1016 /// acc.push(item); 1017 /// acc 1018 /// })); 1019 /// 1020 /// let a = b"abcdabcdefgh"; 1021 /// let b = b"azerty"; 1022 /// 1023 /// let res = vec![&b"abcd"[..], &b"abcd"[..]]; 1024 /// assert_eq!(multi(&a[..]),Ok((&b"efgh"[..], res))); 1025 /// assert_eq!(multi(&b[..]), Err(Err::Error(error_position!(&b[..], ErrorKind::Many1)))); 1026 /// # } 1027 /// ``` 1028 #[macro_export(local_inner_macros)] 1029 macro_rules! fold_many1( 1030 ($i:expr, $submac:ident!( $($args:tt)* ), $init:expr, $f:expr) => ( 1031 { 1032 use $crate::lib::std::result::Result::*; 1033 use $crate::{Err,Needed,InputLength,Context,AtEof}; 1034 1035 match $submac!($i, $($args)*) { 1036 Err(Err::Error(_)) => Err(Err::Error( 1037 error_position!($i, $crate::ErrorKind::Many1) 1038 )), 1039 Err(Err::Failure(_)) => Err(Err::Failure( 1040 error_position!($i, $crate::ErrorKind::Many1) 1041 )), 1042 Err(Err::Incomplete(i)) => Err(Err::Incomplete(i)), 1043 Ok((i1,o1)) => { 1044 let f = $f; 1045 let mut acc = f($init, o1); 1046 let mut input = i1; 1047 let mut incomplete: $crate::lib::std::option::Option<Needed> = 1048 $crate::lib::std::option::Option::None; 1049 let mut failure: $crate::lib::std::option::Option<Context<_,_>> = 1050 $crate::lib::std::option::Option::None; 1051 loop { 1052 match $submac!(input, $($args)*) { 1053 Err(Err::Error(_)) => { 1054 break; 1055 }, 1056 Err(Err::Incomplete(i)) => { 1057 incomplete = $crate::lib::std::option::Option::Some(i); 1058 break; 1059 }, 1060 Err(Err::Failure(e)) => { 1061 failure = $crate::lib::std::option::Option::Some(e); 1062 break; 1063 }, 1064 Ok((i, o)) => { 1065 if i.input_len() == input.input_len() { 1066 if !i.at_eof() { 1067 failure = $crate::lib::std::option::Option::Some(error_position!(i, $crate::ErrorKind::Many1)); 1068 } 1069 break; 1070 } 1071 acc = f(acc, o); 1072 input = i; 1073 } 1074 } 1075 } 1076 1077 match failure { 1078 $crate::lib::std::option::Option::Some(e) => Err(Err::Failure(e)), 1079 $crate::lib::std::option::Option::None => match incomplete { 1080 $crate::lib::std::option::Option::Some(i) => $crate::need_more($i, i), 1081 $crate::lib::std::option::Option::None => Ok((input, acc)) 1082 } 1083 } 1084 } 1085 } 1086 } 1087 ); 1088 ($i:expr, $f:expr, $init:expr, $fold_f:expr) => ( 1089 fold_many1!($i, call!($f), $init, $fold_f); 1090 ); 1091 ); 1092 1093 /// `fold_many_m_n!(usize, usize, I -> IResult<I,O>, R, Fn(R, O) -> R) => I -> IResult<I, R>` 1094 /// Applies the parser between m and n times (n included) and folds the list of return value 1095 /// 1096 /// the embedded parser may return Incomplete 1097 /// 1098 /// ``` 1099 /// # #[macro_use] extern crate nom; 1100 /// # use nom::Err; 1101 /// # use nom::ErrorKind; 1102 /// # fn main() { 1103 /// named!(multi<&[u8], Vec<&[u8]> >, 1104 /// fold_many_m_n!(2, 4, tag!( "abcd" ), Vec::new(), |mut acc: Vec<_>, item| { 1105 /// acc.push(item); 1106 /// acc 1107 /// })); 1108 /// 1109 /// let a = b"abcdefgh"; 1110 /// let b = b"abcdabcdefgh"; 1111 /// let c = b"abcdabcdabcdabcdabcdefgh"; 1112 /// 1113 /// assert_eq!(multi(&a[..]), Err(Err::Error(error_position!(&a[..], ErrorKind::ManyMN)))); 1114 /// let res = vec![&b"abcd"[..], &b"abcd"[..]]; 1115 /// assert_eq!(multi(&b[..]),Ok((&b"efgh"[..], res))); 1116 /// let res2 = vec![&b"abcd"[..], &b"abcd"[..], &b"abcd"[..], &b"abcd"[..]]; 1117 /// assert_eq!(multi(&c[..]),Ok((&b"abcdefgh"[..], res2))); 1118 /// # } 1119 /// ``` 1120 #[macro_export(local_inner_macros)] 1121 macro_rules! fold_many_m_n( 1122 ($i:expr, $m:expr, $n: expr, $submac:ident!( $($args:tt)* ), $init:expr, $f:expr) => ( 1123 { 1124 use $crate::lib::std::result::Result::*; 1125 use $crate::{Err,Needed}; 1126 1127 use $crate::InputLength; 1128 let mut acc = $init; 1129 let f = $f; 1130 let mut input = $i.clone(); 1131 let mut count: usize = 0; 1132 let mut err = false; 1133 let mut incomplete: $crate::lib::std::option::Option<Needed> = $crate::lib::std::option::Option::None; 1134 loop { 1135 if count == $n { break } 1136 match $submac!(input, $($args)*) { 1137 Ok((i, o)) => { 1138 // do not allow parsers that do not consume input (causes infinite loops) 1139 if i.input_len() == input.input_len() { 1140 break; 1141 } 1142 acc = f(acc, o); 1143 input = i; 1144 count += 1; 1145 } 1146 //FIXME: handle failure properly 1147 Err(Err::Error(_)) | Err(Err::Failure(_)) => { 1148 err = true; 1149 break; 1150 }, 1151 Err(Err::Incomplete(i)) => { 1152 incomplete = $crate::lib::std::option::Option::Some(i); 1153 break; 1154 }, 1155 } 1156 } 1157 1158 if count < $m { 1159 if err { 1160 Err(Err::Error(error_position!($i, $crate::ErrorKind::ManyMN))) 1161 } else { 1162 match incomplete { 1163 $crate::lib::std::option::Option::Some(i) => Err(Err::Incomplete(i)), 1164 $crate::lib::std::option::Option::None => Err(Err::Incomplete(Needed::Unknown)) 1165 } 1166 } 1167 } else { 1168 match incomplete { 1169 $crate::lib::std::option::Option::Some(i) => Err(Err::Incomplete(i)), 1170 $crate::lib::std::option::Option::None => Ok((input, acc)) 1171 } 1172 } 1173 } 1174 ); 1175 ($i:expr, $m:expr, $n: expr, $f:expr, $init:expr, $fold_f:expr) => ( 1176 fold_many_m_n!($i, $m, $n, call!($f), $init, $fold_f); 1177 ); 1178 ); 1179 1180 #[cfg(test)] 1181 mod tests { 1182 use internal::{Err, IResult, Needed}; 1183 use nom::{digit, be_u16, be_u8, le_u16}; 1184 use lib::std::str::{self, FromStr}; 1185 #[cfg(feature = "alloc")] 1186 use lib::std::vec::Vec; 1187 use util::ErrorKind; 1188 1189 // reproduce the tag and take macros, because of module import order 1190 macro_rules! tag ( 1191 ($i:expr, $inp: expr) => ( 1192 { 1193 #[inline(always)] 1194 fn as_bytes<T: $crate::AsBytes>(b: &T) -> &[u8] { 1195 b.as_bytes() 1196 } 1197 1198 let expected = $inp; 1199 let bytes = as_bytes(&expected); 1200 1201 tag_bytes!($i,bytes) 1202 } 1203 ); 1204 ); 1205 1206 macro_rules! tag_bytes ( 1207 ($i:expr, $bytes: expr) => ( 1208 { 1209 use $crate::lib::std::cmp::min; 1210 let len = $i.len(); 1211 let blen = $bytes.len(); 1212 let m = min(len, blen); 1213 let reduced = &$i[..m]; 1214 let b = &$bytes[..m]; 1215 1216 let res: IResult<_,_,u32> = if reduced != b { 1217 Err($crate::Err::Error($crate::Context::Code($i, $crate::ErrorKind::Tag::<u32>))) 1218 } else if m < blen { 1219 Err($crate::Err::Incomplete(Needed::Size(blen))) 1220 } else { 1221 Ok((&$i[blen..], reduced)) 1222 }; 1223 res 1224 } 1225 ); 1226 ); 1227 1228 macro_rules! take ( 1229 ($i:expr, $count:expr) => ( 1230 { 1231 let cnt = $count as usize; 1232 let res:IResult<&[u8],&[u8],u32> = if $i.len() < cnt { 1233 Err($crate::Err::Incomplete(Needed::Size(cnt))) 1234 } else { 1235 Ok((&$i[cnt..],&$i[0..cnt])) 1236 }; 1237 res 1238 } 1239 ) 1240 ); 1241 1242 #[test] 1243 #[cfg(feature = "alloc")] separated_list()1244 fn separated_list() { 1245 named!(multi<&[u8],Vec<&[u8]> >, separated_list!(tag!(","), tag!("abcd"))); 1246 named!(multi_empty<&[u8],Vec<&[u8]> >, separated_list!(tag!(","), tag!(""))); 1247 named!(multi_longsep<&[u8],Vec<&[u8]> >, separated_list!(tag!(".."), tag!("abcd"))); 1248 1249 let a = &b"abcdef"[..]; 1250 let b = &b"abcd,abcdef"[..]; 1251 let c = &b"azerty"[..]; 1252 let d = &b",,abc"[..]; 1253 let e = &b"abcd,abcd,ef"[..]; 1254 let f = &b"abc"[..]; 1255 let g = &b"abcd."[..]; 1256 let h = &b"abcd,abc"[..]; 1257 1258 let res1 = vec![&b"abcd"[..]]; 1259 assert_eq!(multi(a), Ok((&b"ef"[..], res1))); 1260 let res2 = vec![&b"abcd"[..], &b"abcd"[..]]; 1261 assert_eq!(multi(b), Ok((&b"ef"[..], res2))); 1262 assert_eq!(multi(c), Ok((&b"azerty"[..], Vec::new()))); 1263 assert_eq!( 1264 multi_empty(d), 1265 Err(Err::Error(error_position!(d, ErrorKind::SeparatedList))) 1266 ); 1267 //let res3 = vec![&b""[..], &b""[..], &b""[..]]; 1268 //assert_eq!(multi_empty(d),Ok((&b"abc"[..], res3))); 1269 let res4 = vec![&b"abcd"[..], &b"abcd"[..]]; 1270 assert_eq!(multi(e), Ok((&b",ef"[..], res4))); 1271 1272 assert_eq!(multi(f), Err(Err::Incomplete(Needed::Size(4)))); 1273 assert_eq!(multi_longsep(g), Err(Err::Incomplete(Needed::Size(2)))); 1274 assert_eq!(multi(h), Err(Err::Incomplete(Needed::Size(4)))); 1275 } 1276 1277 #[test] 1278 #[cfg(feature = "alloc")] separated_list_complete()1279 fn separated_list_complete() { 1280 use nom::alpha; 1281 1282 named!(multi<&[u8],Vec<&[u8]> >, separated_list_complete!(tag!(","), alpha)); 1283 let a = &b"abcdef;"[..]; 1284 let b = &b"abcd,abcdef;"[..]; 1285 let c = &b"abcd,abcd,ef;"[..]; 1286 let d = &b"abc."[..]; 1287 let e = &b"abcd,ef."[..]; 1288 let f = &b"123"[..]; 1289 1290 assert_eq!(multi(a), Ok((&b";"[..], vec![&a[..a.len() - 1]]))); 1291 assert_eq!( 1292 multi(b), 1293 Ok((&b";"[..], vec![&b"abcd"[..], &b"abcdef"[..]])) 1294 ); 1295 assert_eq!( 1296 multi(c), 1297 Ok((&b";"[..], vec![&b"abcd"[..], &b"abcd"[..], &b"ef"[..]])) 1298 ); 1299 assert_eq!(multi(d), Ok((&b"."[..], vec![&b"abc"[..]]))); 1300 assert_eq!(multi(e), Ok((&b"."[..], vec![&b"abcd"[..], &b"ef"[..]]))); 1301 assert_eq!(multi(f), Ok((&b"123"[..], Vec::new()))); 1302 } 1303 1304 #[test] 1305 #[cfg(feature = "alloc")] separated_nonempty_list()1306 fn separated_nonempty_list() { 1307 named!(multi<&[u8],Vec<&[u8]> >, separated_nonempty_list!(tag!(","), tag!("abcd"))); 1308 named!(multi_longsep<&[u8],Vec<&[u8]> >, separated_nonempty_list!(tag!(".."), tag!("abcd"))); 1309 1310 let a = &b"abcdef"[..]; 1311 let b = &b"abcd,abcdef"[..]; 1312 let c = &b"azerty"[..]; 1313 let d = &b"abcd,abcd,ef"[..]; 1314 1315 let f = &b"abc"[..]; 1316 let g = &b"abcd."[..]; 1317 let h = &b"abcd,abc"[..]; 1318 1319 let res1 = vec![&b"abcd"[..]]; 1320 assert_eq!(multi(a), Ok((&b"ef"[..], res1))); 1321 let res2 = vec![&b"abcd"[..], &b"abcd"[..]]; 1322 assert_eq!(multi(b), Ok((&b"ef"[..], res2))); 1323 assert_eq!( 1324 multi(c), 1325 Err(Err::Error(error_position!(c, ErrorKind::Tag))) 1326 ); 1327 let res3 = vec![&b"abcd"[..], &b"abcd"[..]]; 1328 assert_eq!(multi(d), Ok((&b",ef"[..], res3))); 1329 1330 assert_eq!(multi(f), Err(Err::Incomplete(Needed::Size(4)))); 1331 assert_eq!(multi_longsep(g), Err(Err::Incomplete(Needed::Size(2)))); 1332 assert_eq!(multi(h), Err(Err::Incomplete(Needed::Size(4)))); 1333 } 1334 1335 #[test] 1336 #[cfg(feature = "alloc")] separated_nonempty_list_complete()1337 fn separated_nonempty_list_complete() { 1338 use nom::alpha; 1339 1340 named!(multi<&[u8],Vec<&[u8]> >, separated_nonempty_list_complete!(tag!(","), alpha)); 1341 let a = &b"abcdef;"[..]; 1342 let b = &b"abcd,abcdef;"[..]; 1343 let c = &b"abcd,abcd,ef;"[..]; 1344 let d = &b"abc."[..]; 1345 let e = &b"abcd,ef."[..]; 1346 let f = &b"123"[..]; 1347 1348 assert_eq!(multi(a), Ok((&b";"[..], vec![&a[..a.len() - 1]]))); 1349 assert_eq!( 1350 multi(b), 1351 Ok((&b";"[..], vec![&b"abcd"[..], &b"abcdef"[..]])) 1352 ); 1353 assert_eq!( 1354 multi(c), 1355 Ok((&b";"[..], vec![&b"abcd"[..], &b"abcd"[..], &b"ef"[..]])) 1356 ); 1357 assert_eq!(multi(d), Ok((&b"."[..], vec![&b"abc"[..]]))); 1358 assert_eq!(multi(e), Ok((&b"."[..], vec![&b"abcd"[..], &b"ef"[..]]))); 1359 assert_eq!( 1360 multi(f), 1361 Err(Err::Error(error_position!(&b"123"[..], ErrorKind::Alpha))) 1362 ); 1363 } 1364 1365 #[test] 1366 #[cfg(feature = "alloc")] many0()1367 fn many0() { 1368 named!(tag_abcd, tag!("abcd")); 1369 named!(tag_empty, tag!("")); 1370 named!( multi<&[u8],Vec<&[u8]> >, many0!(tag_abcd) ); 1371 named!( multi_empty<&[u8],Vec<&[u8]> >, many0!(tag_empty) ); 1372 1373 assert_eq!(multi(&b"abcdef"[..]), Ok((&b"ef"[..], vec![&b"abcd"[..]]))); 1374 assert_eq!( 1375 multi(&b"abcdabcdefgh"[..]), 1376 Ok((&b"efgh"[..], vec![&b"abcd"[..], &b"abcd"[..]])) 1377 ); 1378 assert_eq!(multi(&b"azerty"[..]), Ok((&b"azerty"[..], Vec::new()))); 1379 assert_eq!(multi(&b"abcdab"[..]), Err(Err::Incomplete(Needed::Size(4)))); 1380 assert_eq!(multi(&b"abcd"[..]), Err(Err::Incomplete(Needed::Size(4)))); 1381 assert_eq!(multi(&b""[..]), Err(Err::Incomplete(Needed::Size(4)))); 1382 assert_eq!( 1383 multi_empty(&b"abcdef"[..]), 1384 Err(Err::Error(error_position!( 1385 &b"abcdef"[..], 1386 ErrorKind::Many0 1387 ))) 1388 ); 1389 } 1390 1391 #[cfg(nightly)] 1392 use test::Bencher; 1393 1394 #[cfg(nightly)] 1395 #[bench] many0_bench(b: &mut Bencher)1396 fn many0_bench(b: &mut Bencher) { 1397 named!(multi<&[u8],Vec<&[u8]> >, many0!(tag!("abcd"))); 1398 b.iter(|| multi(&b"abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd"[..])); 1399 } 1400 1401 #[test] 1402 #[cfg(feature = "alloc")] many1()1403 fn many1() { 1404 named!(multi<&[u8],Vec<&[u8]> >, many1!(tag!("abcd"))); 1405 1406 let a = &b"abcdef"[..]; 1407 let b = &b"abcdabcdefgh"[..]; 1408 let c = &b"azerty"[..]; 1409 let d = &b"abcdab"[..]; 1410 1411 let res1 = vec![&b"abcd"[..]]; 1412 assert_eq!(multi(a), Ok((&b"ef"[..], res1))); 1413 let res2 = vec![&b"abcd"[..], &b"abcd"[..]]; 1414 assert_eq!(multi(b), Ok((&b"efgh"[..], res2))); 1415 assert_eq!( 1416 multi(c), 1417 Err(Err::Error(error_position!(c, ErrorKind::Many1))) 1418 ); 1419 assert_eq!(multi(d), Err(Err::Incomplete(Needed::Size(4)))); 1420 } 1421 1422 #[test] 1423 #[cfg(feature = "alloc")] many_till()1424 fn many_till() { 1425 named!(multi<&[u8], (Vec<&[u8]>, &[u8]) >, many_till!( tag!( "abcd" ), tag!( "efgh" ) ) ); 1426 1427 let a = b"abcdabcdefghabcd"; 1428 let b = b"efghabcd"; 1429 let c = b"azerty"; 1430 1431 let res_a = (vec![&b"abcd"[..], &b"abcd"[..]], &b"efgh"[..]); 1432 let res_b: (Vec<&[u8]>, &[u8]) = (Vec::new(), &b"efgh"[..]); 1433 assert_eq!(multi(&a[..]), Ok((&b"abcd"[..], res_a))); 1434 assert_eq!(multi(&b[..]), Ok((&b"abcd"[..], res_b))); 1435 assert_eq!( 1436 multi(&c[..]), 1437 Err(Err::Error(error_node_position!( 1438 &c[..], 1439 ErrorKind::ManyTill, 1440 error_position!(&c[..], ErrorKind::Tag) 1441 ))) 1442 ); 1443 } 1444 1445 #[test] 1446 #[cfg(feature = "std")] infinite_many()1447 fn infinite_many() { 1448 fn tst(input: &[u8]) -> IResult<&[u8], &[u8]> { 1449 println!("input: {:?}", input); 1450 Err(Err::Error(error_position!(input, ErrorKind::Custom(0u32)))) 1451 } 1452 1453 // should not go into an infinite loop 1454 named!(multi0<&[u8],Vec<&[u8]> >, many0!(tst)); 1455 let a = &b"abcdef"[..]; 1456 assert_eq!(multi0(a), Ok((a, Vec::new()))); 1457 1458 named!(multi1<&[u8],Vec<&[u8]> >, many1!(tst)); 1459 let a = &b"abcdef"[..]; 1460 assert_eq!( 1461 multi1(a), 1462 Err(Err::Error(error_position!(a, ErrorKind::Many1))) 1463 ); 1464 } 1465 1466 #[test] 1467 #[cfg(feature = "alloc")] many_m_n()1468 fn many_m_n() { 1469 named!(multi<&[u8],Vec<&[u8]> >, many_m_n!(2, 4, tag!("Abcd"))); 1470 1471 let a = &b"Abcdef"[..]; 1472 let b = &b"AbcdAbcdefgh"[..]; 1473 let c = &b"AbcdAbcdAbcdAbcdefgh"[..]; 1474 let d = &b"AbcdAbcdAbcdAbcdAbcdefgh"[..]; 1475 let e = &b"AbcdAb"[..]; 1476 1477 assert_eq!( 1478 multi(a), 1479 Err(Err::Error(error_position!(a, ErrorKind::ManyMN))) 1480 ); 1481 let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]]; 1482 assert_eq!(multi(b), Ok((&b"efgh"[..], res1))); 1483 let res2 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]]; 1484 assert_eq!(multi(c), Ok((&b"efgh"[..], res2))); 1485 let res3 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]]; 1486 assert_eq!(multi(d), Ok((&b"Abcdefgh"[..], res3))); 1487 assert_eq!(multi(e), Err(Err::Incomplete(Needed::Size(4)))); 1488 } 1489 1490 #[test] 1491 #[cfg(feature = "alloc")] count()1492 fn count() { 1493 const TIMES: usize = 2; 1494 named!(tag_abc, tag!("abc")); 1495 named!( cnt_2<&[u8], Vec<&[u8]> >, count!(tag_abc, TIMES ) ); 1496 1497 assert_eq!( 1498 cnt_2(&b"abcabcabcdef"[..]), 1499 Ok((&b"abcdef"[..], vec![&b"abc"[..], &b"abc"[..]])) 1500 ); 1501 assert_eq!(cnt_2(&b"ab"[..]), Err(Err::Incomplete(Needed::Size(3)))); 1502 assert_eq!(cnt_2(&b"abcab"[..]), Err(Err::Incomplete(Needed::Size(3)))); 1503 assert_eq!( 1504 cnt_2(&b"xxx"[..]), 1505 Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Count))) 1506 ); 1507 assert_eq!( 1508 cnt_2(&b"xxxabcabcdef"[..]), 1509 Err(Err::Error(error_position!( 1510 &b"xxxabcabcdef"[..], 1511 ErrorKind::Count 1512 ))) 1513 ); 1514 assert_eq!( 1515 cnt_2(&b"abcxxxabcdef"[..]), 1516 Err(Err::Error(error_position!( 1517 &b"abcxxxabcdef"[..], 1518 ErrorKind::Count 1519 ))) 1520 ); 1521 } 1522 1523 #[test] 1524 #[cfg(feature = "alloc")] count_zero()1525 fn count_zero() { 1526 const TIMES: usize = 0; 1527 named!(tag_abc, tag!("abc")); 1528 named!( counter_2<&[u8], Vec<&[u8]> >, count!(tag_abc, TIMES ) ); 1529 1530 let done = &b"abcabcabcdef"[..]; 1531 let parsed_done = Vec::new(); 1532 let rest = done; 1533 let incomplete_1 = &b"ab"[..]; 1534 let parsed_incompl_1 = Vec::new(); 1535 let incomplete_2 = &b"abcab"[..]; 1536 let parsed_incompl_2 = Vec::new(); 1537 let error = &b"xxx"[..]; 1538 let error_remain = &b"xxx"[..]; 1539 let parsed_err = Vec::new(); 1540 let error_1 = &b"xxxabcabcdef"[..]; 1541 let parsed_err_1 = Vec::new(); 1542 let error_1_remain = &b"xxxabcabcdef"[..]; 1543 let error_2 = &b"abcxxxabcdef"[..]; 1544 let parsed_err_2 = Vec::new(); 1545 let error_2_remain = &b"abcxxxabcdef"[..]; 1546 1547 assert_eq!(counter_2(done), Ok((rest, parsed_done))); 1548 assert_eq!( 1549 counter_2(incomplete_1), 1550 Ok((incomplete_1, parsed_incompl_1)) 1551 ); 1552 assert_eq!( 1553 counter_2(incomplete_2), 1554 Ok((incomplete_2, parsed_incompl_2)) 1555 ); 1556 assert_eq!(counter_2(error), Ok((error_remain, parsed_err))); 1557 assert_eq!(counter_2(error_1), Ok((error_1_remain, parsed_err_1))); 1558 assert_eq!(counter_2(error_2), Ok((error_2_remain, parsed_err_2))); 1559 } 1560 1561 #[test] count_fixed()1562 fn count_fixed() { 1563 const TIMES: usize = 2; 1564 named!(tag_abc, tag!("abc")); 1565 named!( cnt_2<&[u8], [&[u8]; TIMES] >, count_fixed!(&[u8], tag_abc, TIMES ) ); 1566 1567 assert_eq!( 1568 cnt_2(&b"abcabcabcdef"[..]), 1569 Ok((&b"abcdef"[..], [&b"abc"[..], &b"abc"[..]])) 1570 ); 1571 assert_eq!(cnt_2(&b"ab"[..]), Err(Err::Incomplete(Needed::Size(3)))); 1572 assert_eq!(cnt_2(&b"abcab"[..]), Err(Err::Incomplete(Needed::Size(3)))); 1573 assert_eq!( 1574 cnt_2(&b"xxx"[..]), 1575 Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Count))) 1576 ); 1577 assert_eq!( 1578 cnt_2(&b"xxxabcabcdef"[..]), 1579 Err(Err::Error(error_position!( 1580 &b"xxxabcabcdef"[..], 1581 ErrorKind::Count 1582 ))) 1583 ); 1584 assert_eq!( 1585 cnt_2(&b"abcxxxabcdef"[..]), 1586 Err(Err::Error(error_position!( 1587 &b"abcxxxabcdef"[..], 1588 ErrorKind::Count 1589 ))) 1590 ); 1591 } 1592 1593 #[allow(dead_code)] compile_count_fixed(input: &[u8]) -> IResult<&[u8], ()>1594 pub fn compile_count_fixed(input: &[u8]) -> IResult<&[u8], ()> { 1595 do_parse!( 1596 input, 1597 tag!("abcd") >> count_fixed!(u16, le_u16, 4) >> eof!() >> () 1598 ) 1599 } 1600 1601 #[derive(Debug, Clone, PartialEq)] 1602 pub struct NilError; 1603 1604 impl From<u32> for NilError { from(_: u32) -> Self1605 fn from(_: u32) -> Self { 1606 NilError 1607 } 1608 } 1609 1610 #[allow(unused_variables)] 1611 #[test] count_fixed_no_type()1612 fn count_fixed_no_type() { 1613 const TIMES: usize = 2; 1614 named!(tag_abc, tag!("abc")); 1615 named!( counter_2<&[u8], [&[u8]; TIMES], NilError >, count_fixed!(&[u8], fix_error!(NilError, tag_abc), TIMES ) ); 1616 1617 let done = &b"abcabcabcdef"[..]; 1618 let parsed_main = [&b"abc"[..], &b"abc"[..]]; 1619 let rest = &b"abcdef"[..]; 1620 let incomplete_1 = &b"ab"[..]; 1621 let incomplete_2 = &b"abcab"[..]; 1622 let error = &b"xxx"[..]; 1623 let error_1 = &b"xxxabcabcdef"[..]; 1624 let error_1_remain = &b"xxxabcabcdef"[..]; 1625 let error_2 = &b"abcxxxabcdef"[..]; 1626 let error_2_remain = &b"abcxxxabcdef"[..]; 1627 1628 assert_eq!(counter_2(done), Ok((rest, parsed_main))); 1629 assert_eq!( 1630 counter_2(incomplete_1), 1631 Err(Err::Incomplete(Needed::Size(3))) 1632 ); 1633 assert_eq!( 1634 counter_2(incomplete_2), 1635 Err(Err::Incomplete(Needed::Size(3))) 1636 ); 1637 assert_eq!( 1638 counter_2(error), 1639 Err(Err::Error(error_position!(error, ErrorKind::Count))) 1640 ); 1641 assert_eq!( 1642 counter_2(error_1), 1643 Err(Err::Error(error_position!( 1644 error_1_remain, 1645 ErrorKind::Count 1646 ))) 1647 ); 1648 assert_eq!( 1649 counter_2(error_2), 1650 Err(Err::Error(error_position!( 1651 error_2_remain, 1652 ErrorKind::Count 1653 ))) 1654 ); 1655 } 1656 1657 named!(pub number<u32>, map_res!( 1658 map_res!( 1659 digit, 1660 str::from_utf8 1661 ), 1662 FromStr::from_str 1663 )); 1664 1665 #[test] 1666 #[cfg(feature = "alloc")] length_count()1667 fn length_count() { 1668 named!(tag_abc, tag!(&b"abc"[..])); 1669 named!( cnt<&[u8], Vec<&[u8]> >, length_count!(number, tag_abc) ); 1670 1671 assert_eq!( 1672 cnt(&b"2abcabcabcdef"[..]), 1673 Ok((&b"abcdef"[..], vec![&b"abc"[..], &b"abc"[..]])) 1674 ); 1675 assert_eq!(cnt(&b"2ab"[..]), Err(Err::Incomplete(Needed::Size(3)))); 1676 assert_eq!(cnt(&b"3abcab"[..]), Err(Err::Incomplete(Needed::Size(3)))); 1677 assert_eq!( 1678 cnt(&b"xxx"[..]), 1679 Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Digit))) 1680 ); 1681 assert_eq!( 1682 cnt(&b"2abcxxx"[..]), 1683 Err(Err::Error(error_position!( 1684 &b"abcxxx"[..], 1685 ErrorKind::Count 1686 ))) 1687 ); 1688 } 1689 1690 #[test] length_data()1691 fn length_data() { 1692 named!( take<&[u8], &[u8]>, length_data!(number) ); 1693 1694 assert_eq!( 1695 take(&b"6abcabcabcdef"[..]), 1696 Ok((&b"abcdef"[..], &b"abcabc"[..])) 1697 ); 1698 assert_eq!(take(&b"3ab"[..]), Err(Err::Incomplete(Needed::Size(3)))); 1699 assert_eq!( 1700 take(&b"xxx"[..]), 1701 Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Digit))) 1702 ); 1703 assert_eq!(take(&b"2abcxxx"[..]), Ok((&b"cxxx"[..], &b"ab"[..]))); 1704 } 1705 1706 #[test] length_value_test()1707 fn length_value_test() { 1708 named!(length_value_1<&[u8], u16 >, length_value!(be_u8, be_u16)); 1709 named!(length_value_2<&[u8], (u8, u8) >, length_value!(be_u8, tuple!(be_u8, be_u8))); 1710 1711 let i1 = [0, 5, 6]; 1712 assert_eq!( 1713 length_value_1(&i1), 1714 Err(Err::Error(error_position!(&b""[..], ErrorKind::Complete))) 1715 ); 1716 assert_eq!( 1717 length_value_2(&i1), 1718 Err(Err::Error(error_position!(&b""[..], ErrorKind::Complete))) 1719 ); 1720 1721 let i2 = [1, 5, 6, 3]; 1722 assert_eq!( 1723 length_value_1(&i2), 1724 Err(Err::Error(error_position!(&i2[1..2], ErrorKind::Complete))) 1725 ); 1726 assert_eq!( 1727 length_value_2(&i2), 1728 Err(Err::Error(error_position!(&i2[1..2], ErrorKind::Complete))) 1729 ); 1730 1731 let i3 = [2, 5, 6, 3, 4, 5, 7]; 1732 assert_eq!(length_value_1(&i3), Ok((&i3[3..], 1286))); 1733 assert_eq!(length_value_2(&i3), Ok((&i3[3..], (5, 6)))); 1734 1735 let i4 = [3, 5, 6, 3, 4, 5]; 1736 assert_eq!(length_value_1(&i4), Ok((&i4[4..], 1286))); 1737 assert_eq!(length_value_2(&i4), Ok((&i4[4..], (5, 6)))); 1738 } 1739 1740 #[test] 1741 #[cfg(feature = "alloc")] fold_many0()1742 fn fold_many0() { 1743 fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> { 1744 acc.push(item); 1745 acc 1746 }; 1747 named!(tag_abcd, tag!("abcd")); 1748 named!(tag_empty, tag!("")); 1749 named!( multi<&[u8],Vec<&[u8]> >, fold_many0!(tag_abcd, Vec::new(), fold_into_vec) ); 1750 named!( multi_empty<&[u8],Vec<&[u8]> >, fold_many0!(tag_empty, Vec::new(), fold_into_vec) ); 1751 1752 assert_eq!(multi(&b"abcdef"[..]), Ok((&b"ef"[..], vec![&b"abcd"[..]]))); 1753 assert_eq!( 1754 multi(&b"abcdabcdefgh"[..]), 1755 Ok((&b"efgh"[..], vec![&b"abcd"[..], &b"abcd"[..]])) 1756 ); 1757 assert_eq!(multi(&b"azerty"[..]), Ok((&b"azerty"[..], Vec::new()))); 1758 assert_eq!(multi(&b"abcdab"[..]), Err(Err::Incomplete(Needed::Size(4)))); 1759 assert_eq!(multi(&b"abcd"[..]), Err(Err::Incomplete(Needed::Size(4)))); 1760 assert_eq!(multi(&b""[..]), Err(Err::Incomplete(Needed::Size(4)))); 1761 assert_eq!( 1762 multi_empty(&b"abcdef"[..]), 1763 Err(Err::Error(error_position!( 1764 &b"abcdef"[..], 1765 ErrorKind::Many0 1766 ))) 1767 ); 1768 } 1769 1770 #[test] 1771 #[cfg(feature = "alloc")] fold_many1()1772 fn fold_many1() { 1773 fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> { 1774 acc.push(item); 1775 acc 1776 }; 1777 named!(multi<&[u8],Vec<&[u8]> >, fold_many1!(tag!("abcd"), Vec::new(), fold_into_vec)); 1778 1779 let a = &b"abcdef"[..]; 1780 let b = &b"abcdabcdefgh"[..]; 1781 let c = &b"azerty"[..]; 1782 let d = &b"abcdab"[..]; 1783 1784 let res1 = vec![&b"abcd"[..]]; 1785 assert_eq!(multi(a), Ok((&b"ef"[..], res1))); 1786 let res2 = vec![&b"abcd"[..], &b"abcd"[..]]; 1787 assert_eq!(multi(b), Ok((&b"efgh"[..], res2))); 1788 assert_eq!( 1789 multi(c), 1790 Err(Err::Error(error_position!(c, ErrorKind::Many1))) 1791 ); 1792 assert_eq!(multi(d), Err(Err::Incomplete(Needed::Size(4)))); 1793 } 1794 1795 #[test] 1796 #[cfg(feature = "alloc")] fold_many_m_n()1797 fn fold_many_m_n() { 1798 fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> { 1799 acc.push(item); 1800 acc 1801 }; 1802 named!(multi<&[u8],Vec<&[u8]> >, fold_many_m_n!(2, 4, tag!("Abcd"), Vec::new(), fold_into_vec)); 1803 1804 let a = &b"Abcdef"[..]; 1805 let b = &b"AbcdAbcdefgh"[..]; 1806 let c = &b"AbcdAbcdAbcdAbcdefgh"[..]; 1807 let d = &b"AbcdAbcdAbcdAbcdAbcdefgh"[..]; 1808 let e = &b"AbcdAb"[..]; 1809 1810 assert_eq!( 1811 multi(a), 1812 Err(Err::Error(error_position!(a, ErrorKind::ManyMN))) 1813 ); 1814 let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]]; 1815 assert_eq!(multi(b), Ok((&b"efgh"[..], res1))); 1816 let res2 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]]; 1817 assert_eq!(multi(c), Ok((&b"efgh"[..], res2))); 1818 let res3 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]]; 1819 assert_eq!(multi(d), Ok((&b"Abcdefgh"[..], res3))); 1820 assert_eq!(multi(e), Err(Err::Incomplete(Needed::Size(4)))); 1821 } 1822 1823 #[test] many0_count()1824 fn many0_count() { 1825 named!( 1826 count0_nums(&[u8]) -> usize, 1827 many0_count!(pair!(digit, tag!(","))) 1828 ); 1829 1830 assert_eq!( 1831 count0_nums(&b"123,junk"[..]), 1832 Ok((&b"junk"[..], 1)) 1833 ); 1834 1835 assert_eq!( 1836 count0_nums(&b"123,45,junk"[..]), 1837 Ok((&b"junk"[..], 2)) 1838 ); 1839 1840 assert_eq!( 1841 count0_nums(&b"1,2,3,4,5,6,7,8,9,0,junk"[..]), 1842 Ok((&b"junk"[..], 10)) 1843 ); 1844 1845 assert_eq!( 1846 count0_nums(&b"hello"[..]), 1847 Ok((&b"hello"[..], 0)) 1848 ); 1849 } 1850 1851 #[test] many1_count()1852 fn many1_count() { 1853 named!( 1854 count1_nums(&[u8]) -> usize, 1855 many1_count!(pair!(digit, tag!(","))) 1856 ); 1857 1858 assert_eq!( 1859 count1_nums(&b"123,45,junk"[..]), 1860 Ok((&b"junk"[..], 2)) 1861 ); 1862 1863 assert_eq!( 1864 count1_nums(&b"1,2,3,4,5,6,7,8,9,0,junk"[..]), 1865 Ok((&b"junk"[..], 10)) 1866 ); 1867 1868 assert_eq!( 1869 count1_nums(&b"hello"[..]), 1870 Err(Err::Error(error_position!( 1871 &b"hello"[..], 1872 ErrorKind::Many1Count 1873 ))) 1874 ); 1875 } 1876 1877 } 1878