/src/semver-parser/src/generated.rs

Source (jump to first uncovered line)
//! This is @generated code, do not edit by hand.
//! See `semver.pest` and `genpest.rs`.
#![allow(unused_attributes)]
use super::SemverParser;

#[allow(non_upper_case_globals)]
const _PEST_GRAMMAR_SemverParser: [&'static str; 0usize] = [];
#[allow(dead_code, non_camel_case_types, clippy::upper_case_acronyms)]
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum Rule {
  #[doc = "End-of-input"]
  EOI,
  r#range_set,
  r#logical_or,
  r#range,
  r#empty,
  r#hyphen,
  r#simple,
  r#primitive,
  r#primitive_op,
  r#partial,
  r#xr,
  r#xr_op,
  r#nr,
  r#tilde,
  r#caret,
  r#qualifier,
  r#parts,
  r#part,
  r#space,
}
impl Rule {
  pub fn all_rules() -> &'static [Rule] {
    &[
      Rule::r#range_set,
      Rule::r#logical_or,
      Rule::r#range,
      Rule::r#empty,
      Rule::r#hyphen,
      Rule::r#simple,
      Rule::r#primitive,
      Rule::r#primitive_op,
      Rule::r#partial,
      Rule::r#xr,
      Rule::r#xr_op,
      Rule::r#nr,
      Rule::r#tilde,
      Rule::r#caret,
      Rule::r#qualifier,
      Rule::r#parts,
      Rule::r#part,
      Rule::r#space,
    ]
  }
}
#[allow(clippy::all)]
impl ::pest::Parser<Rule> for SemverParser {
  fn parse<'i>(
    rule: Rule,
    input: &'i str,
  ) -> ::std::result::Result<::pest::iterators::Pairs<'i, Rule>, ::pest::error::Error<Rule>> {
    mod rules {
      #![allow(clippy::upper_case_acronyms)]
      pub mod hidden {
        use super::super::Rule;
        #[inline]
        #[allow(dead_code, non_snake_case, unused_variables)]
        pub fn skip(
          state: ::std::boxed::Box<::pest::ParserState<'_, Rule>>,
        ) -> ::pest::ParseResult<::std::boxed::Box<::pest::ParserState<'_, Rule>>> {
          Ok(state)
        }
      }
      pub mod visible {
        use super::super::Rule;
        #[inline]
        #[allow(non_snake_case, unused_variables)]
        pub fn r#range_set(
          state: ::std::boxed::Box<::pest::ParserState<'_, Rule>>,
        ) -> ::pest::ParseResult<::std::boxed::Box<::pest::ParserState<'_, Rule>>> {
          state.rule(Rule::r#range_set, |state| {
            state.sequence(|state| {
              self::r#SOI(state)
                .and_then(|state| super::hidden::skip(state))
                .and_then(|state| {
                  state.sequence(|state| {
                    state.optional(|state| {
                      self::r#space(state).and_then(|state| {
                        state.repeat(|state| {
                          state.sequence(|state| {
                            super::hidden::skip(state).and_then(|state| self::r#space(state))
                          })
                        })
                      })
                    })
                  })
                })
                .and_then(|state| super::hidden::skip(state))
                .and_then(|state| self::r#range(state))
                .and_then(|state| super::hidden::skip(state))
                .and_then(|state| {
                  state.sequence(|state| {
                    state.optional(|state| {
                      state
                        .sequence(|state| {
                          self::r#logical_or(state)
                            .and_then(|state| super::hidden::skip(state))
                            .and_then(|state| self::r#range(state))
                        })
                        .and_then(|state| {
                          state.repeat(|state| {
                            state.sequence(|state| {
                              super::hidden::skip(state).and_then(|state| {
                                state.sequence(|state| {
                                  self::r#logical_or(state)
                                    .and_then(|state| super::hidden::skip(state))
                                    .and_then(|state| self::r#range(state))
                                })
                              })
                            })
                          })
                        })
                    })
                  })
                })
                .and_then(|state| super::hidden::skip(state))
                .and_then(|state| {
                  state.sequence(|state| {
                    state.optional(|state| {
                      self::r#space(state).and_then(|state| {
                        state.repeat(|state| {
                          state.sequence(|state| {
                            super::hidden::skip(state).and_then(|state| self::r#space(state))
                          })
                        })
                      })
                    })
                  })
                })
                .and_then(|state| super::hidden::skip(state))
                .and_then(|state| self::r#EOI(state))
            })
          })
        }
        #[inline]
        #[allow(non_snake_case, unused_variables)]
        pub fn r#logical_or(
          state: ::std::boxed::Box<::pest::ParserState<'_, Rule>>,
        ) -> ::pest::ParseResult<::std::boxed::Box<::pest::ParserState<'_, Rule>>> {
          state.rule(Rule::r#logical_or, |state| {
            state.sequence(|state| {
              state
                .sequence(|state| {
                  state.optional(|state| {
                    self::r#space(state).and_then(|state| {
                      state.repeat(|state| {
                        state.sequence(|state| {
                          super::hidden::skip(state).and_then(|state| self::r#space(state))
                        })
                      })
                    })
                  })
                })
                .and_then(|state| super::hidden::skip(state))
                .and_then(|state| state.match_string("||"))
                .and_then(|state| super::hidden::skip(state))
                .and_then(|state| {
                  state.sequence(|state| {
                    state.optional(|state| {
                      self::r#space(state).and_then(|state| {
                        state.repeat(|state| {
                          state.sequence(|state| {
                            super::hidden::skip(state).and_then(|state| self::r#space(state))
                          })
                        })
                      })
                    })
                  })
                })
            })
          })
        }
        #[inline]
        #[allow(non_snake_case, unused_variables)]
        pub fn r#range(
          state: ::std::boxed::Box<::pest::ParserState<'_, Rule>>,
        ) -> ::pest::ParseResult<::std::boxed::Box<::pest::ParserState<'_, Rule>>> {
          state.rule(Rule::r#range, |state| {
            self::r#hyphen(state)
              .or_else(|state| {
                state.sequence(|state| {
                  self::r#simple(state)
                    .and_then(|state| super::hidden::skip(state))
                    .and_then(|state| {
                      state.sequence(|state| {
                        state.optional(|state| {
                          state
                            .sequence(|state| {
                              state
                                .optional(|state| state.match_string(","))
                                .and_then(|state| super::hidden::skip(state))
                                .and_then(|state| {
                                  state.sequence(|state| {
                                    self::r#space(state)
                                      .and_then(|state| super::hidden::skip(state))
                                      .and_then(|state| {
                                        state.sequence(|state| {
                                          state.optional(|state| {
                                            self::r#space(state).and_then(|state| {
                                              state.repeat(|state| {
                                                state.sequence(|state| {
                                                  super::hidden::skip(state)
                                                    .and_then(|state| self::r#space(state))
                                                })
                                              })
                                            })
                                          })
                                        })
                                      })
                                  })
                                })
                                .and_then(|state| super::hidden::skip(state))
                                .and_then(|state| self::r#simple(state))
                            })
                            .and_then(|state| {
                              state.repeat(|state| {
                                state.sequence(|state| {
                                  super::hidden::skip(state).and_then(|state| {
                                    state.sequence(|state| {
                                      state
                                        .optional(|state| state.match_string(","))
                                        .and_then(|state| super::hidden::skip(state))
                                        .and_then(|state| {
                                          state.sequence(|state| {
                                            self::r#space(state)
                                              .and_then(|state| super::hidden::skip(state))
                                              .and_then(|state| {
                                                state.sequence(|state| {
                                                  state.optional(|state| {
                                                    self::r#space(state).and_then(|state| {
                                                      state.repeat(|state| {
                                                        state.sequence(|state| {
                                                          super::hidden::skip(state)
                                                            .and_then(|state| self::r#space(state))
                                                        })
                                                      })
                                                    })
                                                  })
                                                })
                                              })
                                          })
                                        })
                                        .and_then(|state| super::hidden::skip(state))
                                        .and_then(|state| self::r#simple(state))
                                    })
                                  })
                                })
                              })
                            })
                        })
                      })
                    })
                })
              })
              .or_else(|state| self::r#empty(state))
          })
        }
        #[inline]
        #[allow(non_snake_case, unused_variables)]
        pub fn r#empty(
          state: ::std::boxed::Box<::pest::ParserState<'_, Rule>>,
        ) -> ::pest::ParseResult<::std::boxed::Box<::pest::ParserState<'_, Rule>>> {
          state.rule(Rule::r#empty, |state| state.match_string(""))
        }
        #[inline]
        #[allow(non_snake_case, unused_variables)]
        pub fn r#hyphen(
          state: ::std::boxed::Box<::pest::ParserState<'_, Rule>>,
        ) -> ::pest::ParseResult<::std::boxed::Box<::pest::ParserState<'_, Rule>>> {
          state.rule(Rule::r#hyphen, |state| {
            state.sequence(|state| {
              self::r#partial(state)
                .and_then(|state| super::hidden::skip(state))
                .and_then(|state| {
                  state.sequence(|state| {
                    self::r#space(state)
                      .and_then(|state| super::hidden::skip(state))
                      .and_then(|state| {
                        state.sequence(|state| {
                          state.optional(|state| {
                            self::r#space(state).and_then(|state| {
                              state.repeat(|state| {
                                state.sequence(|state| {
                                  super::hidden::skip(state).and_then(|state| self::r#space(state))
                                })
                              })
                            })
                          })
                        })
                      })
                  })
                })
                .and_then(|state| super::hidden::skip(state))
                .and_then(|state| state.match_string("-"))
                .and_then(|state| super::hidden::skip(state))
                .and_then(|state| {
                  state.sequence(|state| {
                    self::r#space(state)
                      .and_then(|state| super::hidden::skip(state))
                      .and_then(|state| {
                        state.sequence(|state| {
                          state.optional(|state| {
                            self::r#space(state).and_then(|state| {
                              state.repeat(|state| {
                                state.sequence(|state| {
                                  super::hidden::skip(state).and_then(|state| self::r#space(state))
                                })
                              })
                            })
                          })
                        })
                      })
                  })
                })
                .and_then(|state| super::hidden::skip(state))
                .and_then(|state| self::r#partial(state))
            })
          })
        }
        #[inline]
        #[allow(non_snake_case, unused_variables)]
        pub fn r#simple(
          state: ::std::boxed::Box<::pest::ParserState<'_, Rule>>,
        ) -> ::pest::ParseResult<::std::boxed::Box<::pest::ParserState<'_, Rule>>> {
          state.rule(Rule::r#simple, |state| {
            self::r#primitive(state)
              .or_else(|state| self::r#partial(state))
              .or_else(|state| self::r#tilde(state))
              .or_else(|state| self::r#caret(state))
          })
        }
        #[inline]
        #[allow(non_snake_case, unused_variables)]
        pub fn r#primitive(
          state: ::std::boxed::Box<::pest::ParserState<'_, Rule>>,
        ) -> ::pest::ParseResult<::std::boxed::Box<::pest::ParserState<'_, Rule>>> {
          state.rule(Rule::r#primitive, |state| {
            state.sequence(|state| {
              self::r#primitive_op(state)
                .and_then(|state| super::hidden::skip(state))
                .and_then(|state| {
                  state.sequence(|state| {
                    state.optional(|state| {
                      self::r#space(state).and_then(|state| {
                        state.repeat(|state| {
                          state.sequence(|state| {
                            super::hidden::skip(state).and_then(|state| self::r#space(state))
                          })
                        })
                      })
                    })
                  })
                })
                .and_then(|state| super::hidden::skip(state))
                .and_then(|state| self::r#partial(state))
            })
          })
        }
        #[inline]
        #[allow(non_snake_case, unused_variables)]
        pub fn r#primitive_op(
          state: ::std::boxed::Box<::pest::ParserState<'_, Rule>>,
        ) -> ::pest::ParseResult<::std::boxed::Box<::pest::ParserState<'_, Rule>>> {
          state.rule(Rule::r#primitive_op, |state| {
            state
              .match_string("<=")
              .or_else(|state| state.match_string(">="))
              .or_else(|state| state.match_string(">"))
              .or_else(|state| state.match_string("<"))
              .or_else(|state| state.match_string("="))
          })
        }
        #[inline]
        #[allow(non_snake_case, unused_variables)]
        pub fn r#partial(
          state: ::std::boxed::Box<::pest::ParserState<'_, Rule>>,
        ) -> ::pest::ParseResult<::std::boxed::Box<::pest::ParserState<'_, Rule>>> {
          state.rule(Rule::r#partial, |state| {
            state.sequence(|state| {
              self::r#xr(state)
                .and_then(|state| super::hidden::skip(state))
                .and_then(|state| {
                  state.optional(|state| {
                    state.sequence(|state| {
                      state
                        .match_string(".")
                        .and_then(|state| super::hidden::skip(state))
                        .and_then(|state| self::r#xr(state))
                        .and_then(|state| super::hidden::skip(state))
                        .and_then(|state| {
                          state.optional(|state| {
                            state.sequence(|state| {
                              state
                                .match_string(".")
                                .and_then(|state| super::hidden::skip(state))
                                .and_then(|state| self::r#xr(state))
                                .and_then(|state| super::hidden::skip(state))
                                .and_then(|state| state.optional(|state| self::r#qualifier(state)))
                            })
                          })
                        })
                    })
                  })
                })
            })
          })
        }
        #[inline]
        #[allow(non_snake_case, unused_variables)]
        pub fn r#xr(
          state: ::std::boxed::Box<::pest::ParserState<'_, Rule>>,
        ) -> ::pest::ParseResult<::std::boxed::Box<::pest::ParserState<'_, Rule>>> {
          state.rule(Rule::r#xr, |state| {
            self::r#xr_op(state).or_else(|state| self::r#nr(state))
          })
        }
        #[inline]
        #[allow(non_snake_case, unused_variables)]
        pub fn r#xr_op(
          state: ::std::boxed::Box<::pest::ParserState<'_, Rule>>,
        ) -> ::pest::ParseResult<::std::boxed::Box<::pest::ParserState<'_, Rule>>> {
          state.rule(Rule::r#xr_op, |state| {
            state
              .match_string("x")
              .or_else(|state| state.match_string("X"))
              .or_else(|state| state.match_string("*"))
          })
        }
        #[inline]
        #[allow(non_snake_case, unused_variables)]
        pub fn r#nr(
          state: ::std::boxed::Box<::pest::ParserState<'_, Rule>>,
        ) -> ::pest::ParseResult<::std::boxed::Box<::pest::ParserState<'_, Rule>>> {
          state.rule(Rule::r#nr, |state| {
            state.match_string("0").or_else(|state| {
              state.sequence(|state| {
                state
                  .match_range('1'..'9')
                  .and_then(|state| super::hidden::skip(state))
                  .and_then(|state| {
                    state.sequence(|state| {
                      state.optional(|state| {
                        state.match_range('0'..'9').and_then(|state| {
                          state.repeat(|state| {
                            state.sequence(|state| {
                              super::hidden::skip(state)
                                .and_then(|state| state.match_range('0'..'9'))
                            })
                          })
                        })
                      })
                    })
                  })
              })
            })
          })
        }
        #[inline]
        #[allow(non_snake_case, unused_variables)]
        pub fn r#tilde(
          state: ::std::boxed::Box<::pest::ParserState<'_, Rule>>,
        ) -> ::pest::ParseResult<::std::boxed::Box<::pest::ParserState<'_, Rule>>> {
          state.rule(Rule::r#tilde, |state| {
            state.sequence(|state| {
              state
                .match_string("~>")
                .or_else(|state| state.match_string("~"))
                .and_then(|state| super::hidden::skip(state))
                .and_then(|state| {
                  state.sequence(|state| {
                    state.optional(|state| {
                      self::r#space(state).and_then(|state| {
                        state.repeat(|state| {
                          state.sequence(|state| {
                            super::hidden::skip(state).and_then(|state| self::r#space(state))
                          })
                        })
                      })
                    })
                  })
                })
                .and_then(|state| super::hidden::skip(state))
                .and_then(|state| self::r#partial(state))
            })
          })
        }
        #[inline]
        #[allow(non_snake_case, unused_variables)]
        pub fn r#caret(
          state: ::std::boxed::Box<::pest::ParserState<'_, Rule>>,
        ) -> ::pest::ParseResult<::std::boxed::Box<::pest::ParserState<'_, Rule>>> {
          state.rule(Rule::r#caret, |state| {
            state.sequence(|state| {
              state
                .match_string("^")
                .and_then(|state| super::hidden::skip(state))
                .and_then(|state| {
                  state.sequence(|state| {
                    state.optional(|state| {
                      self::r#space(state).and_then(|state| {
                        state.repeat(|state| {
                          state.sequence(|state| {
                            super::hidden::skip(state).and_then(|state| self::r#space(state))
                          })
                        })
                      })
                    })
                  })
                })
                .and_then(|state| super::hidden::skip(state))
                .and_then(|state| self::r#partial(state))
            })
          })
        }
        #[inline]
        #[allow(non_snake_case, unused_variables)]
        pub fn r#qualifier(
          state: ::std::boxed::Box<::pest::ParserState<'_, Rule>>,
        ) -> ::pest::ParseResult<::std::boxed::Box<::pest::ParserState<'_, Rule>>> {
          state.rule(Rule::r#qualifier, |state| {
            state.sequence(|state| {
              state
                .match_string("-")
                .or_else(|state| state.match_string("+"))
                .and_then(|state| super::hidden::skip(state))
                .and_then(|state| self::r#parts(state))
            })
          })
        }
        #[inline]
        #[allow(non_snake_case, unused_variables)]
        pub fn r#parts(
          state: ::std::boxed::Box<::pest::ParserState<'_, Rule>>,
        ) -> ::pest::ParseResult<::std::boxed::Box<::pest::ParserState<'_, Rule>>> {
          state.rule(Rule::r#parts, |state| {
            state.sequence(|state| {
              self::r#part(state)
                .and_then(|state| super::hidden::skip(state))
                .and_then(|state| {
                  state.sequence(|state| {
                    state.optional(|state| {
                      state
                        .sequence(|state| {
                          state
                            .match_string(".")
                            .and_then(|state| super::hidden::skip(state))
                            .and_then(|state| self::r#part(state))
                        })
                        .and_then(|state| {
                          state.repeat(|state| {
                            state.sequence(|state| {
                              super::hidden::skip(state).and_then(|state| {
                                state.sequence(|state| {
                                  state
                                    .match_string(".")
                                    .and_then(|state| super::hidden::skip(state))
                                    .and_then(|state| self::r#part(state))
                                })
                              })
                            })
                          })
                        })
                    })
                  })
                })
            })
          })
        }
        #[inline]
        #[allow(non_snake_case, unused_variables)]
        pub fn r#part(
          state: ::std::boxed::Box<::pest::ParserState<'_, Rule>>,
        ) -> ::pest::ParseResult<::std::boxed::Box<::pest::ParserState<'_, Rule>>> {
          state.rule(Rule::r#part, |state| {
            self::r#nr(state).or_else(|state| {
              state.sequence(|state| {
                state
                  .match_string("-")
                  .or_else(|state| state.match_range('0'..'9'))
                  .or_else(|state| state.match_range('A'..'Z'))
                  .or_else(|state| state.match_range('a'..'z'))
                  .and_then(|state| super::hidden::skip(state))
                  .and_then(|state| {
                    state.sequence(|state| {
                      state.optional(|state| {
                        state
                          .match_string("-")
                          .or_else(|state| state.match_range('0'..'9'))
                          .or_else(|state| state.match_range('A'..'Z'))
                          .or_else(|state| state.match_range('a'..'z'))
                          .and_then(|state| {
                            state.repeat(|state| {
                              state.sequence(|state| {
                                super::hidden::skip(state).and_then(|state| {
                                  state
                                    .match_string("-")
                                    .or_else(|state| state.match_range('0'..'9'))
                                    .or_else(|state| state.match_range('A'..'Z'))
                                    .or_else(|state| state.match_range('a'..'z'))
                                })
                              })
                            })
                          })
                      })
                    })
                  })
              })
            })
          })
        }
        #[inline]
        #[allow(non_snake_case, unused_variables)]
        pub fn r#space(
          state: ::std::boxed::Box<::pest::ParserState<'_, Rule>>,
        ) -> ::pest::ParseResult<::std::boxed::Box<::pest::ParserState<'_, Rule>>> {
          state
            .match_string(" ")
            .or_else(|state| state.match_string("\t"))
        }
        #[inline]
        #[allow(dead_code, non_snake_case, unused_variables)]
        pub fn EOI(
          state: ::std::boxed::Box<::pest::ParserState<'_, Rule>>,
        ) -> ::pest::ParseResult<::std::boxed::Box<::pest::ParserState<'_, Rule>>> {
          state.rule(Rule::EOI, |state| state.end_of_input())
        }
        #[inline]
        #[allow(dead_code, non_snake_case, unused_variables)]
        pub fn SOI(
          state: ::std::boxed::Box<::pest::ParserState<'_, Rule>>,
        ) -> ::pest::ParseResult<::std::boxed::Box<::pest::ParserState<'_, Rule>>> {
          state.start_of_input()
        }
      }
      pub use self::visible::*;
    }
    ::pest::state(input, |state| match rule {
      Rule::r#range_set => rules::r#range_set(state),
      Rule::r#logical_or => rules::r#logical_or(state),
      Rule::r#range => rules::r#range(state),
      Rule::r#empty => rules::r#empty(state),
      Rule::r#hyphen => rules::r#hyphen(state),
      Rule::r#simple => rules::r#simple(state),
      Rule::r#primitive => rules::r#primitive(state),
      Rule::r#primitive_op => rules::r#primitive_op(state),
      Rule::r#partial => rules::r#partial(state),
      Rule::r#xr => rules::r#xr(state),
      Rule::r#xr_op => rules::r#xr_op(state),
      Rule::r#nr => rules::r#nr(state),
      Rule::r#tilde => rules::r#tilde(state),
      Rule::r#caret => rules::r#caret(state),
      Rule::r#qualifier => rules::r#qualifier(state),
      Rule::r#parts => rules::r#parts(state),
      Rule::r#part => rules::r#part(state),
      Rule::r#space => rules::r#space(state),
      Rule::EOI => rules::EOI(state),
    })
  }
}

Coverage Report

Created: 2025-08-29 06:54

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