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