1 //! This is @generated code, do not edit by hand. 2 //! See `semver.pest` and `genpest.rs`. 3 #![allow(unused_attributes)] 4 use super::SemverParser; 5 6 #[allow(dead_code, non_camel_case_types)] 7 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] 8 pub enum Rule { 9 EOI, 10 range_set, 11 logical_or, 12 range, 13 empty, 14 hyphen, 15 simple, 16 primitive, 17 primitive_op, 18 partial, 19 xr, 20 xr_op, 21 nr, 22 tilde, 23 caret, 24 qualifier, 25 parts, 26 part, 27 space, 28 } 29 #[allow(clippy::all)] 30 impl ::pest::Parser<Rule> for SemverParser { parse<'i>( rule: Rule, input: &'i str, ) -> ::std::result::Result<::pest::iterators::Pairs<'i, Rule>, ::pest::error::Error<Rule>>31 fn parse<'i>( 32 rule: Rule, 33 input: &'i str, 34 ) -> ::std::result::Result<::pest::iterators::Pairs<'i, Rule>, ::pest::error::Error<Rule>> { 35 mod rules { 36 pub mod hidden { 37 use super::super::Rule; 38 #[inline] 39 #[allow(dead_code, non_snake_case, unused_variables)] 40 pub fn skip( 41 state: Box<::pest::ParserState<Rule>>, 42 ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { 43 Ok(state) 44 } 45 } 46 pub mod visible { 47 use super::super::Rule; 48 #[inline] 49 #[allow(non_snake_case, unused_variables)] 50 pub fn range_set( 51 state: Box<::pest::ParserState<Rule>>, 52 ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { 53 state.rule(Rule::range_set, |state| { 54 state.sequence(|state| { 55 self::SOI(state) 56 .and_then(|state| super::hidden::skip(state)) 57 .and_then(|state| { 58 state.sequence(|state| { 59 state.optional(|state| { 60 self::space(state).and_then(|state| { 61 state.repeat(|state| { 62 state.sequence(|state| { 63 super::hidden::skip(state).and_then(|state| self::space(state)) 64 }) 65 }) 66 }) 67 }) 68 }) 69 }) 70 .and_then(|state| super::hidden::skip(state)) 71 .and_then(|state| self::range(state)) 72 .and_then(|state| super::hidden::skip(state)) 73 .and_then(|state| { 74 state.sequence(|state| { 75 state.optional(|state| { 76 state 77 .sequence(|state| { 78 self::logical_or(state) 79 .and_then(|state| super::hidden::skip(state)) 80 .and_then(|state| self::range(state)) 81 }) 82 .and_then(|state| { 83 state.repeat(|state| { 84 state.sequence(|state| { 85 super::hidden::skip(state).and_then(|state| { 86 state.sequence(|state| { 87 self::logical_or(state) 88 .and_then(|state| super::hidden::skip(state)) 89 .and_then(|state| self::range(state)) 90 }) 91 }) 92 }) 93 }) 94 }) 95 }) 96 }) 97 }) 98 .and_then(|state| super::hidden::skip(state)) 99 .and_then(|state| { 100 state.sequence(|state| { 101 state.optional(|state| { 102 self::space(state).and_then(|state| { 103 state.repeat(|state| { 104 state.sequence(|state| { 105 super::hidden::skip(state).and_then(|state| self::space(state)) 106 }) 107 }) 108 }) 109 }) 110 }) 111 }) 112 .and_then(|state| super::hidden::skip(state)) 113 .and_then(|state| self::EOI(state)) 114 }) 115 }) 116 } 117 #[inline] 118 #[allow(non_snake_case, unused_variables)] 119 pub fn logical_or( 120 state: Box<::pest::ParserState<Rule>>, 121 ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { 122 state.rule(Rule::logical_or, |state| { 123 state.sequence(|state| { 124 state 125 .sequence(|state| { 126 state.optional(|state| { 127 self::space(state).and_then(|state| { 128 state.repeat(|state| { 129 state.sequence(|state| { 130 super::hidden::skip(state).and_then(|state| self::space(state)) 131 }) 132 }) 133 }) 134 }) 135 }) 136 .and_then(|state| super::hidden::skip(state)) 137 .and_then(|state| state.match_string("||")) 138 .and_then(|state| super::hidden::skip(state)) 139 .and_then(|state| { 140 state.sequence(|state| { 141 state.optional(|state| { 142 self::space(state).and_then(|state| { 143 state.repeat(|state| { 144 state.sequence(|state| { 145 super::hidden::skip(state).and_then(|state| self::space(state)) 146 }) 147 }) 148 }) 149 }) 150 }) 151 }) 152 }) 153 }) 154 } 155 #[inline] 156 #[allow(non_snake_case, unused_variables)] 157 pub fn range( 158 state: Box<::pest::ParserState<Rule>>, 159 ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { 160 state.rule(Rule::range, |state| { 161 self::hyphen(state) 162 .or_else(|state| { 163 state.sequence(|state| { 164 self::simple(state) 165 .and_then(|state| super::hidden::skip(state)) 166 .and_then(|state| { 167 state.sequence(|state| { 168 state.optional(|state| { 169 state 170 .sequence(|state| { 171 state 172 .optional(|state| state.match_string(",")) 173 .and_then(|state| super::hidden::skip(state)) 174 .and_then(|state| { 175 state.sequence(|state| { 176 self::space(state) 177 .and_then(|state| super::hidden::skip(state)) 178 .and_then(|state| { 179 state.sequence(|state| { 180 state.optional(|state| { 181 self::space(state).and_then(|state| { 182 state.repeat(|state| { 183 state.sequence(|state| { 184 super::hidden::skip(state) 185 .and_then(|state| self::space(state)) 186 }) 187 }) 188 }) 189 }) 190 }) 191 }) 192 }) 193 }) 194 .and_then(|state| super::hidden::skip(state)) 195 .and_then(|state| self::simple(state)) 196 }) 197 .and_then(|state| { 198 state.repeat(|state| { 199 state.sequence(|state| { 200 super::hidden::skip(state).and_then(|state| { 201 state.sequence(|state| { 202 state 203 .optional(|state| state.match_string(",")) 204 .and_then(|state| super::hidden::skip(state)) 205 .and_then(|state| { 206 state.sequence(|state| { 207 self::space(state) 208 .and_then(|state| super::hidden::skip(state)) 209 .and_then(|state| { 210 state.sequence(|state| { 211 state.optional(|state| { 212 self::space(state).and_then(|state| { 213 state.repeat(|state| { 214 state.sequence(|state| { 215 super::hidden::skip(state) 216 .and_then(|state| self::space(state)) 217 }) 218 }) 219 }) 220 }) 221 }) 222 }) 223 }) 224 }) 225 .and_then(|state| super::hidden::skip(state)) 226 .and_then(|state| self::simple(state)) 227 }) 228 }) 229 }) 230 }) 231 }) 232 }) 233 }) 234 }) 235 }) 236 }) 237 .or_else(|state| self::empty(state)) 238 }) 239 } 240 #[inline] 241 #[allow(non_snake_case, unused_variables)] 242 pub fn empty( 243 state: Box<::pest::ParserState<Rule>>, 244 ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { 245 state.rule(Rule::empty, |state| state.match_string("")) 246 } 247 #[inline] 248 #[allow(non_snake_case, unused_variables)] 249 pub fn hyphen( 250 state: Box<::pest::ParserState<Rule>>, 251 ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { 252 state.rule(Rule::hyphen, |state| { 253 state.sequence(|state| { 254 self::partial(state) 255 .and_then(|state| super::hidden::skip(state)) 256 .and_then(|state| { 257 state.sequence(|state| { 258 self::space(state) 259 .and_then(|state| super::hidden::skip(state)) 260 .and_then(|state| { 261 state.sequence(|state| { 262 state.optional(|state| { 263 self::space(state).and_then(|state| { 264 state.repeat(|state| { 265 state.sequence(|state| { 266 super::hidden::skip(state).and_then(|state| self::space(state)) 267 }) 268 }) 269 }) 270 }) 271 }) 272 }) 273 }) 274 }) 275 .and_then(|state| super::hidden::skip(state)) 276 .and_then(|state| state.match_string("-")) 277 .and_then(|state| super::hidden::skip(state)) 278 .and_then(|state| { 279 state.sequence(|state| { 280 self::space(state) 281 .and_then(|state| super::hidden::skip(state)) 282 .and_then(|state| { 283 state.sequence(|state| { 284 state.optional(|state| { 285 self::space(state).and_then(|state| { 286 state.repeat(|state| { 287 state.sequence(|state| { 288 super::hidden::skip(state).and_then(|state| self::space(state)) 289 }) 290 }) 291 }) 292 }) 293 }) 294 }) 295 }) 296 }) 297 .and_then(|state| super::hidden::skip(state)) 298 .and_then(|state| self::partial(state)) 299 }) 300 }) 301 } 302 #[inline] 303 #[allow(non_snake_case, unused_variables)] 304 pub fn simple( 305 state: Box<::pest::ParserState<Rule>>, 306 ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { 307 state.rule(Rule::simple, |state| { 308 self::primitive(state) 309 .or_else(|state| self::partial(state)) 310 .or_else(|state| self::tilde(state)) 311 .or_else(|state| self::caret(state)) 312 }) 313 } 314 #[inline] 315 #[allow(non_snake_case, unused_variables)] 316 pub fn primitive( 317 state: Box<::pest::ParserState<Rule>>, 318 ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { 319 state.rule(Rule::primitive, |state| { 320 state.sequence(|state| { 321 self::primitive_op(state) 322 .and_then(|state| super::hidden::skip(state)) 323 .and_then(|state| { 324 state.sequence(|state| { 325 state.optional(|state| { 326 self::space(state).and_then(|state| { 327 state.repeat(|state| { 328 state.sequence(|state| { 329 super::hidden::skip(state).and_then(|state| self::space(state)) 330 }) 331 }) 332 }) 333 }) 334 }) 335 }) 336 .and_then(|state| super::hidden::skip(state)) 337 .and_then(|state| self::partial(state)) 338 }) 339 }) 340 } 341 #[inline] 342 #[allow(non_snake_case, unused_variables)] 343 pub fn primitive_op( 344 state: Box<::pest::ParserState<Rule>>, 345 ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { 346 state.rule(Rule::primitive_op, |state| { 347 state 348 .match_string("<=") 349 .or_else(|state| state.match_string(">=")) 350 .or_else(|state| state.match_string(">")) 351 .or_else(|state| state.match_string("<")) 352 .or_else(|state| state.match_string("=")) 353 }) 354 } 355 #[inline] 356 #[allow(non_snake_case, unused_variables)] 357 pub fn partial( 358 state: Box<::pest::ParserState<Rule>>, 359 ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { 360 state.rule(Rule::partial, |state| { 361 state.sequence(|state| { 362 self::xr(state) 363 .and_then(|state| super::hidden::skip(state)) 364 .and_then(|state| { 365 state.optional(|state| { 366 state.sequence(|state| { 367 state 368 .match_string(".") 369 .and_then(|state| super::hidden::skip(state)) 370 .and_then(|state| self::xr(state)) 371 .and_then(|state| super::hidden::skip(state)) 372 .and_then(|state| { 373 state.optional(|state| { 374 state.sequence(|state| { 375 state 376 .match_string(".") 377 .and_then(|state| super::hidden::skip(state)) 378 .and_then(|state| self::xr(state)) 379 .and_then(|state| super::hidden::skip(state)) 380 .and_then(|state| state.optional(|state| self::qualifier(state))) 381 }) 382 }) 383 }) 384 }) 385 }) 386 }) 387 }) 388 }) 389 } 390 #[inline] 391 #[allow(non_snake_case, unused_variables)] 392 pub fn xr( 393 state: Box<::pest::ParserState<Rule>>, 394 ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { 395 state.rule(Rule::xr, |state| { 396 self::xr_op(state).or_else(|state| self::nr(state)) 397 }) 398 } 399 #[inline] 400 #[allow(non_snake_case, unused_variables)] 401 pub fn xr_op( 402 state: Box<::pest::ParserState<Rule>>, 403 ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { 404 state.rule(Rule::xr_op, |state| { 405 state 406 .match_string("x") 407 .or_else(|state| state.match_string("X")) 408 .or_else(|state| state.match_string("*")) 409 }) 410 } 411 #[inline] 412 #[allow(non_snake_case, unused_variables)] 413 pub fn nr( 414 state: Box<::pest::ParserState<Rule>>, 415 ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { 416 state.rule(Rule::nr, |state| { 417 state.match_string("0").or_else(|state| { 418 state.sequence(|state| { 419 state 420 .match_range('1'..'9') 421 .and_then(|state| super::hidden::skip(state)) 422 .and_then(|state| { 423 state.sequence(|state| { 424 state.optional(|state| { 425 state.match_range('0'..'9').and_then(|state| { 426 state.repeat(|state| { 427 state.sequence(|state| { 428 super::hidden::skip(state) 429 .and_then(|state| state.match_range('0'..'9')) 430 }) 431 }) 432 }) 433 }) 434 }) 435 }) 436 }) 437 }) 438 }) 439 } 440 #[inline] 441 #[allow(non_snake_case, unused_variables)] 442 pub fn tilde( 443 state: Box<::pest::ParserState<Rule>>, 444 ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { 445 state.rule(Rule::tilde, |state| { 446 state.sequence(|state| { 447 state 448 .match_string("~>") 449 .or_else(|state| state.match_string("~")) 450 .and_then(|state| super::hidden::skip(state)) 451 .and_then(|state| { 452 state.sequence(|state| { 453 state.optional(|state| { 454 self::space(state).and_then(|state| { 455 state.repeat(|state| { 456 state.sequence(|state| { 457 super::hidden::skip(state).and_then(|state| self::space(state)) 458 }) 459 }) 460 }) 461 }) 462 }) 463 }) 464 .and_then(|state| super::hidden::skip(state)) 465 .and_then(|state| self::partial(state)) 466 }) 467 }) 468 } 469 #[inline] 470 #[allow(non_snake_case, unused_variables)] 471 pub fn caret( 472 state: Box<::pest::ParserState<Rule>>, 473 ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { 474 state.rule(Rule::caret, |state| { 475 state.sequence(|state| { 476 state 477 .match_string("^") 478 .and_then(|state| super::hidden::skip(state)) 479 .and_then(|state| { 480 state.sequence(|state| { 481 state.optional(|state| { 482 self::space(state).and_then(|state| { 483 state.repeat(|state| { 484 state.sequence(|state| { 485 super::hidden::skip(state).and_then(|state| self::space(state)) 486 }) 487 }) 488 }) 489 }) 490 }) 491 }) 492 .and_then(|state| super::hidden::skip(state)) 493 .and_then(|state| self::partial(state)) 494 }) 495 }) 496 } 497 #[inline] 498 #[allow(non_snake_case, unused_variables)] 499 pub fn qualifier( 500 state: Box<::pest::ParserState<Rule>>, 501 ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { 502 state.rule(Rule::qualifier, |state| { 503 state.sequence(|state| { 504 state 505 .match_string("-") 506 .or_else(|state| state.match_string("+")) 507 .and_then(|state| super::hidden::skip(state)) 508 .and_then(|state| self::parts(state)) 509 }) 510 }) 511 } 512 #[inline] 513 #[allow(non_snake_case, unused_variables)] 514 pub fn parts( 515 state: Box<::pest::ParserState<Rule>>, 516 ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { 517 state.rule(Rule::parts, |state| { 518 state.sequence(|state| { 519 self::part(state) 520 .and_then(|state| super::hidden::skip(state)) 521 .and_then(|state| { 522 state.sequence(|state| { 523 state.optional(|state| { 524 state 525 .sequence(|state| { 526 state 527 .match_string(".") 528 .and_then(|state| super::hidden::skip(state)) 529 .and_then(|state| self::part(state)) 530 }) 531 .and_then(|state| { 532 state.repeat(|state| { 533 state.sequence(|state| { 534 super::hidden::skip(state).and_then(|state| { 535 state.sequence(|state| { 536 state 537 .match_string(".") 538 .and_then(|state| super::hidden::skip(state)) 539 .and_then(|state| self::part(state)) 540 }) 541 }) 542 }) 543 }) 544 }) 545 }) 546 }) 547 }) 548 }) 549 }) 550 } 551 #[inline] 552 #[allow(non_snake_case, unused_variables)] 553 pub fn part( 554 state: Box<::pest::ParserState<Rule>>, 555 ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { 556 state.rule(Rule::part, |state| { 557 self::nr(state).or_else(|state| { 558 state.sequence(|state| { 559 state 560 .match_string("-") 561 .or_else(|state| state.match_range('0'..'9')) 562 .or_else(|state| state.match_range('A'..'Z')) 563 .or_else(|state| state.match_range('a'..'z')) 564 .and_then(|state| super::hidden::skip(state)) 565 .and_then(|state| { 566 state.sequence(|state| { 567 state.optional(|state| { 568 state 569 .match_string("-") 570 .or_else(|state| state.match_range('0'..'9')) 571 .or_else(|state| state.match_range('A'..'Z')) 572 .or_else(|state| state.match_range('a'..'z')) 573 .and_then(|state| { 574 state.repeat(|state| { 575 state.sequence(|state| { 576 super::hidden::skip(state).and_then(|state| { 577 state 578 .match_string("-") 579 .or_else(|state| state.match_range('0'..'9')) 580 .or_else(|state| state.match_range('A'..'Z')) 581 .or_else(|state| state.match_range('a'..'z')) 582 }) 583 }) 584 }) 585 }) 586 }) 587 }) 588 }) 589 }) 590 }) 591 }) 592 } 593 #[inline] 594 #[allow(non_snake_case, unused_variables)] 595 pub fn space( 596 state: Box<::pest::ParserState<Rule>>, 597 ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { 598 state 599 .match_string(" ") 600 .or_else(|state| state.match_string("\t")) 601 } 602 #[inline] 603 #[allow(dead_code, non_snake_case, unused_variables)] 604 pub fn EOI( 605 state: Box<::pest::ParserState<Rule>>, 606 ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { 607 state.rule(Rule::EOI, |state| state.end_of_input()) 608 } 609 #[inline] 610 #[allow(dead_code, non_snake_case, unused_variables)] 611 pub fn SOI( 612 state: Box<::pest::ParserState<Rule>>, 613 ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { 614 state.start_of_input() 615 } 616 } 617 pub use self::visible::*; 618 } 619 ::pest::state(input, |state| match rule { 620 Rule::range_set => rules::range_set(state), 621 Rule::logical_or => rules::logical_or(state), 622 Rule::range => rules::range(state), 623 Rule::empty => rules::empty(state), 624 Rule::hyphen => rules::hyphen(state), 625 Rule::simple => rules::simple(state), 626 Rule::primitive => rules::primitive(state), 627 Rule::primitive_op => rules::primitive_op(state), 628 Rule::partial => rules::partial(state), 629 Rule::xr => rules::xr(state), 630 Rule::xr_op => rules::xr_op(state), 631 Rule::nr => rules::nr(state), 632 Rule::tilde => rules::tilde(state), 633 Rule::caret => rules::caret(state), 634 Rule::qualifier => rules::qualifier(state), 635 Rule::parts => rules::parts(state), 636 Rule::part => rules::part(state), 637 Rule::space => rules::space(state), 638 Rule::EOI => rules::EOI(state), 639 }) 640 } 641 } 642