Revert "Memoize format_expr"
This reverts commit a37d3ab0e1c7c05f1a6410fb7ddf5539f0d030f8.
This commit is contained in:
Caleb Cartwright
parent
f43c96688d
commit
778e1b1a76
51
src/expr.rs
51
src/expr.rs
@ -1,6 +1,5 @@
|
||||
use std::borrow::Cow;
|
||||
use std::cmp::min;
|
||||
use std::collections::HashMap;
|
||||
|
||||
use itertools::Itertools;
|
||||
use rustc_ast::token::{Delimiter, LitKind};
|
||||
@ -23,7 +22,7 @@ use crate::macros::{rewrite_macro, MacroPosition};
|
||||
use crate::matches::rewrite_match;
|
||||
use crate::overflow::{self, IntoOverflowableItem, OverflowableItem};
|
||||
use crate::pairs::{rewrite_all_pairs, rewrite_pair, PairParts};
|
||||
use crate::rewrite::{QueryId, Rewrite, RewriteContext};
|
||||
use crate::rewrite::{Rewrite, RewriteContext};
|
||||
use crate::shape::{Indent, Shape};
|
||||
use crate::source_map::{LineRangeUtils, SpanUtils};
|
||||
use crate::spanned::Spanned;
|
||||
@ -54,54 +53,6 @@ pub(crate) fn format_expr(
|
||||
expr_type: ExprType,
|
||||
context: &RewriteContext<'_>,
|
||||
shape: Shape,
|
||||
) -> Option<String> {
|
||||
// when max_width is tight, we should check all possible formattings, in order to find
|
||||
// if we can fit expression in the limit. Doing it recursively takes exponential time
|
||||
// relative to input size, and people hit it with rustfmt takes minutes in #4476 #4867 #5128
|
||||
// By memoization of format_expr function, we format each pair of expression and shape
|
||||
// only once, so worst case execution time becomes O(n*max_width^3).
|
||||
if context.inside_macro() || context.is_macro_def {
|
||||
// span ids are not unique in macros, so we don't memoize result of them.
|
||||
return format_expr_inner(expr, expr_type, context, shape);
|
||||
}
|
||||
let clean;
|
||||
let query_id = QueryId {
|
||||
shape,
|
||||
span: expr.span,
|
||||
};
|
||||
if let Some(map) = context.memoize.take() {
|
||||
if let Some(r) = map.get(&query_id) {
|
||||
let r = r.clone();
|
||||
context.memoize.set(Some(map)); // restore map in the memoize cell for other users
|
||||
return r;
|
||||
}
|
||||
context.memoize.set(Some(map));
|
||||
clean = false;
|
||||
} else {
|
||||
context.memoize.set(Some(HashMap::default()));
|
||||
clean = true; // We got None, so we are the top level called function. When
|
||||
// this function finishes, no one is interested in what is in the map, because
|
||||
// all of them are sub expressions of this top level expression, and this is
|
||||
// done. So we should clean up memoize map to save some memory.
|
||||
}
|
||||
|
||||
let r = format_expr_inner(expr, expr_type, context, shape);
|
||||
if clean {
|
||||
context.memoize.set(None);
|
||||
} else {
|
||||
if let Some(mut map) = context.memoize.take() {
|
||||
map.insert(query_id, r.clone()); // insert the result in the memoize map
|
||||
context.memoize.set(Some(map)); // so it won't be computed again
|
||||
}
|
||||
}
|
||||
r
|
||||
}
|
||||
|
||||
fn format_expr_inner(
|
||||
expr: &ast::Expr,
|
||||
expr_type: ExprType,
|
||||
context: &RewriteContext<'_>,
|
||||
shape: Shape,
|
||||
) -> Option<String> {
|
||||
skip_out_of_file_lines_range!(context, expr.span);
|
||||
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::io::{self, Write};
|
||||
use std::rc::Rc;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use rustc_ast::ast;
|
||||
@ -203,7 +202,6 @@ impl<'a, T: FormatHandler + 'a> FormatContext<'a, T> {
|
||||
self.config,
|
||||
&snippet_provider,
|
||||
self.report.clone(),
|
||||
Rc::default(),
|
||||
);
|
||||
visitor.skip_context.update_with_attrs(&self.krate.attrs);
|
||||
visitor.is_macro_def = is_macro_def;
|
||||
|
||||
@ -12,7 +12,6 @@ use crate::shape::Shape;
|
||||
use crate::skip::SkipContext;
|
||||
use crate::visitor::SnippetProvider;
|
||||
use crate::FormatReport;
|
||||
use rustc_data_structures::stable_map::FxHashMap;
|
||||
|
||||
pub(crate) trait Rewrite {
|
||||
/// Rewrite self into shape.
|
||||
@ -25,22 +24,10 @@ impl<T: Rewrite> Rewrite for ptr::P<T> {
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, PartialEq, Eq, Hash)]
|
||||
pub(crate) struct QueryId {
|
||||
pub(crate) shape: Shape,
|
||||
pub(crate) span: Span,
|
||||
}
|
||||
|
||||
// We use Option<HashMap> instead of HashMap, because in case of `None`
|
||||
// the function clean the memoize map, but it doesn't clean when
|
||||
// there is `Some(empty)`, so they are different.
|
||||
pub(crate) type Memoize = Rc<Cell<Option<FxHashMap<QueryId, Option<String>>>>>;
|
||||
|
||||
#[derive(Clone)]
|
||||
pub(crate) struct RewriteContext<'a> {
|
||||
pub(crate) parse_sess: &'a ParseSess,
|
||||
pub(crate) config: &'a Config,
|
||||
pub(crate) memoize: Memoize,
|
||||
pub(crate) inside_macro: Rc<Cell<bool>>,
|
||||
// Force block indent style even if we are using visual indent style.
|
||||
pub(crate) use_block: Cell<bool>,
|
||||
|
||||
@ -4,7 +4,7 @@ use std::ops::{Add, Sub};
|
||||
|
||||
use crate::Config;
|
||||
|
||||
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
|
||||
#[derive(Copy, Clone, Debug)]
|
||||
pub(crate) struct Indent {
|
||||
// Width of the block indent, in characters. Must be a multiple of
|
||||
// Config::tab_spaces.
|
||||
@ -139,7 +139,7 @@ impl Sub<usize> for Indent {
|
||||
// 8096 is close enough to infinite for rustfmt.
|
||||
const INFINITE_SHAPE_WIDTH: usize = 8096;
|
||||
|
||||
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
|
||||
#[derive(Copy, Clone, Debug)]
|
||||
pub(crate) struct Shape {
|
||||
pub(crate) width: usize,
|
||||
// The current indentation of code.
|
||||
|
||||
@ -17,7 +17,7 @@ use crate::items::{
|
||||
use crate::macros::{macro_style, rewrite_macro, rewrite_macro_def, MacroPosition};
|
||||
use crate::modules::Module;
|
||||
use crate::parse::session::ParseSess;
|
||||
use crate::rewrite::{Memoize, Rewrite, RewriteContext};
|
||||
use crate::rewrite::{Rewrite, RewriteContext};
|
||||
use crate::shape::{Indent, Shape};
|
||||
use crate::skip::{is_skip_attr, SkipContext};
|
||||
use crate::source_map::{LineRangeUtils, SpanUtils};
|
||||
@ -71,7 +71,6 @@ impl SnippetProvider {
|
||||
|
||||
pub(crate) struct FmtVisitor<'a> {
|
||||
parent_context: Option<&'a RewriteContext<'a>>,
|
||||
pub(crate) memoize: Memoize,
|
||||
pub(crate) parse_sess: &'a ParseSess,
|
||||
pub(crate) buffer: String,
|
||||
pub(crate) last_pos: BytePos,
|
||||
@ -759,7 +758,6 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
|
||||
ctx.config,
|
||||
ctx.snippet_provider,
|
||||
ctx.report.clone(),
|
||||
ctx.memoize.clone(),
|
||||
);
|
||||
visitor.skip_context.update(ctx.skip_context.clone());
|
||||
visitor.set_parent_context(ctx);
|
||||
@ -771,12 +769,10 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
|
||||
config: &'a Config,
|
||||
snippet_provider: &'a SnippetProvider,
|
||||
report: FormatReport,
|
||||
memoize: Memoize,
|
||||
) -> FmtVisitor<'a> {
|
||||
FmtVisitor {
|
||||
parent_context: None,
|
||||
parse_sess: parse_session,
|
||||
memoize,
|
||||
buffer: String::with_capacity(snippet_provider.big_snippet.len() * 2),
|
||||
last_pos: BytePos(0),
|
||||
block_indent: Indent::empty(),
|
||||
@ -999,7 +995,6 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
|
||||
RewriteContext {
|
||||
parse_sess: self.parse_sess,
|
||||
config: self.config,
|
||||
memoize: self.memoize.clone(),
|
||||
inside_macro: Rc::new(Cell::new(false)),
|
||||
use_block: Cell::new(false),
|
||||
is_if_else_block: Cell::new(false),
|
||||
|
||||
@ -1,638 +0,0 @@
|
||||
use super::SemverParser;
|
||||
|
||||
#[allow(dead_code, non_camel_case_types)]
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
|
||||
pub enum Rule {
|
||||
EOI,
|
||||
range_set,
|
||||
logical_or,
|
||||
range,
|
||||
empty,
|
||||
hyphen,
|
||||
simple,
|
||||
primitive,
|
||||
primitive_op,
|
||||
partial,
|
||||
xr,
|
||||
xr_op,
|
||||
nr,
|
||||
tilde,
|
||||
caret,
|
||||
qualifier,
|
||||
parts,
|
||||
part,
|
||||
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 {
|
||||
pub mod hidden {
|
||||
use super::super::Rule;
|
||||
#[inline]
|
||||
#[allow(dead_code, non_snake_case, unused_variables)]
|
||||
pub fn skip(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
Ok(state)
|
||||
}
|
||||
}
|
||||
pub mod visible {
|
||||
use super::super::Rule;
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn range_set(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::range_set, |state| {
|
||||
state.sequence(|state| {
|
||||
self::SOI(state)
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| {
|
||||
state.sequence(|state| {
|
||||
state.optional(|state| {
|
||||
self::space(state).and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state).and_then(|state| self::space(state))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| self::range(state))
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| {
|
||||
state.sequence(|state| {
|
||||
state.optional(|state| {
|
||||
state
|
||||
.sequence(|state| {
|
||||
self::logical_or(state)
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| self::range(state))
|
||||
})
|
||||
.and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state).and_then(|state| {
|
||||
state.sequence(|state| {
|
||||
self::logical_or(state)
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| self::range(state))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| {
|
||||
state.sequence(|state| {
|
||||
state.optional(|state| {
|
||||
self::space(state).and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state).and_then(|state| self::space(state))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| self::EOI(state))
|
||||
})
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn logical_or(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::logical_or, |state| {
|
||||
state.sequence(|state| {
|
||||
state
|
||||
.sequence(|state| {
|
||||
state.optional(|state| {
|
||||
self::space(state).and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state).and_then(|state| self::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::space(state).and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state).and_then(|state| self::space(state))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn range(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::range, |state| {
|
||||
self::hyphen(state)
|
||||
.or_else(|state| {
|
||||
state.sequence(|state| {
|
||||
self::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::space(state)
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| {
|
||||
state.sequence(|state| {
|
||||
state.optional(|state| {
|
||||
self::space(state).and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state)
|
||||
.and_then(|state| self::space(state))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| self::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::space(state)
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| {
|
||||
state.sequence(|state| {
|
||||
state.optional(|state| {
|
||||
self::space(state).and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state)
|
||||
.and_then(|state| self::space(state))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| self::simple(state))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
.or_else(|state| self::empty(state))
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn empty(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::empty, |state| state.match_string(""))
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn hyphen(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::hyphen, |state| {
|
||||
state.sequence(|state| {
|
||||
self::partial(state)
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| {
|
||||
state.sequence(|state| {
|
||||
self::space(state)
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| {
|
||||
state.sequence(|state| {
|
||||
state.optional(|state| {
|
||||
self::space(state).and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state).and_then(|state| self::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::space(state)
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| {
|
||||
state.sequence(|state| {
|
||||
state.optional(|state| {
|
||||
self::space(state).and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state).and_then(|state| self::space(state))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| self::partial(state))
|
||||
})
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn simple(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::simple, |state| {
|
||||
self::primitive(state)
|
||||
.or_else(|state| self::partial(state))
|
||||
.or_else(|state| self::tilde(state))
|
||||
.or_else(|state| self::caret(state))
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn primitive(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::primitive, |state| {
|
||||
state.sequence(|state| {
|
||||
self::primitive_op(state)
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| {
|
||||
state.sequence(|state| {
|
||||
state.optional(|state| {
|
||||
self::space(state).and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state).and_then(|state| self::space(state))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| self::partial(state))
|
||||
})
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn primitive_op(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::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 partial(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::partial, |state| {
|
||||
state.sequence(|state| {
|
||||
self::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::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::xr(state))
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| state.optional(|state| self::qualifier(state)))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn xr(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::xr, |state| {
|
||||
self::xr_op(state).or_else(|state| self::nr(state))
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn xr_op(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::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 nr(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::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 tilde(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::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::space(state).and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state).and_then(|state| self::space(state))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| self::partial(state))
|
||||
})
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn caret(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::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::space(state).and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state).and_then(|state| self::space(state))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| self::partial(state))
|
||||
})
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn qualifier(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::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::parts(state))
|
||||
})
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn parts(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::parts, |state| {
|
||||
state.sequence(|state| {
|
||||
self::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::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::part(state))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn part(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::part, |state| {
|
||||
self::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 space(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<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: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<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: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.start_of_input()
|
||||
}
|
||||
}
|
||||
pub use self::visible::*;
|
||||
}
|
||||
::pest::state(input, |state| match rule {
|
||||
Rule::range_set => rules::range_set(state),
|
||||
Rule::logical_or => rules::logical_or(state),
|
||||
Rule::range => rules::range(state),
|
||||
Rule::empty => rules::empty(state),
|
||||
Rule::hyphen => rules::hyphen(state),
|
||||
Rule::simple => rules::simple(state),
|
||||
Rule::primitive => rules::primitive(state),
|
||||
Rule::primitive_op => rules::primitive_op(state),
|
||||
Rule::partial => rules::partial(state),
|
||||
Rule::xr => rules::xr(state),
|
||||
Rule::xr_op => rules::xr_op(state),
|
||||
Rule::nr => rules::nr(state),
|
||||
Rule::tilde => rules::tilde(state),
|
||||
Rule::caret => rules::caret(state),
|
||||
Rule::qualifier => rules::qualifier(state),
|
||||
Rule::parts => rules::parts(state),
|
||||
Rule::part => rules::part(state),
|
||||
Rule::space => rules::space(state),
|
||||
Rule::EOI => rules::EOI(state),
|
||||
})
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,705 +0,0 @@
|
||||
use super::SemverParser;
|
||||
|
||||
#[allow(dead_code, non_camel_case_types)]
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
|
||||
pub enum Rule {
|
||||
EOI,
|
||||
range_set,
|
||||
logical_or,
|
||||
range,
|
||||
empty,
|
||||
hyphen,
|
||||
simple,
|
||||
primitive,
|
||||
primitive_op,
|
||||
partial,
|
||||
xr,
|
||||
xr_op,
|
||||
nr,
|
||||
tilde,
|
||||
caret,
|
||||
qualifier,
|
||||
parts,
|
||||
part,
|
||||
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 {
|
||||
pub mod hidden {
|
||||
use super::super::Rule;
|
||||
#[inline]
|
||||
#[allow(dead_code, non_snake_case, unused_variables)]
|
||||
pub fn skip(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
Ok(state)
|
||||
}
|
||||
}
|
||||
pub mod visible {
|
||||
use super::super::Rule;
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn range_set(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::range_set, |state| {
|
||||
state.sequence(|state| {
|
||||
self::SOI(state)
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| {
|
||||
state.sequence(|state| {
|
||||
state.optional(|state| {
|
||||
self::space(state).and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state)
|
||||
.and_then(|state| self::space(state))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| self::range(state))
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| {
|
||||
state.sequence(|state| {
|
||||
state.optional(|state| {
|
||||
state
|
||||
.sequence(|state| {
|
||||
self::logical_or(state)
|
||||
.and_then(|state| {
|
||||
super::hidden::skip(state)
|
||||
})
|
||||
.and_then(|state| self::range(state))
|
||||
})
|
||||
.and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state).and_then(
|
||||
|state| {
|
||||
state.sequence(|state| {
|
||||
self::logical_or(state)
|
||||
.and_then(|state| {
|
||||
super::hidden::skip(
|
||||
state,
|
||||
)
|
||||
})
|
||||
.and_then(|state| {
|
||||
self::range(state)
|
||||
})
|
||||
})
|
||||
},
|
||||
)
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| {
|
||||
state.sequence(|state| {
|
||||
state.optional(|state| {
|
||||
self::space(state).and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state)
|
||||
.and_then(|state| self::space(state))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| self::EOI(state))
|
||||
})
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn logical_or(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::logical_or, |state| {
|
||||
state.sequence(|state| {
|
||||
state
|
||||
.sequence(|state| {
|
||||
state.optional(|state| {
|
||||
self::space(state).and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state)
|
||||
.and_then(|state| self::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::space(state).and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state)
|
||||
.and_then(|state| self::space(state))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn range(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::range, |state| {
|
||||
self::hyphen(state)
|
||||
.or_else(|state| {
|
||||
state.sequence(|state| {
|
||||
self::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::space(state)
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| {
|
||||
state.sequence(|state| {
|
||||
state.optional(|state| {
|
||||
self::space(state).and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state)
|
||||
.and_then(|state| self::space(state))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
.and_then(|state| {
|
||||
super::hidden::skip(state)
|
||||
})
|
||||
.and_then(|state| {
|
||||
self::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::space(state)
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| {
|
||||
state.sequence(|state| {
|
||||
state.optional(|state| {
|
||||
self::space(state).and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state)
|
||||
.and_then(|state| self::space(state))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| self::simple(state))
|
||||
},
|
||||
)
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
.or_else(|state| self::empty(state))
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn empty(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::empty, |state| state.match_string(""))
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn hyphen(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::hyphen, |state| {
|
||||
state.sequence(|state| {
|
||||
self::partial(state)
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| {
|
||||
state.sequence(|state| {
|
||||
self::space(state)
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| {
|
||||
state.sequence(|state| {
|
||||
state.optional(|state| {
|
||||
self::space(state).and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state)
|
||||
.and_then(|state| {
|
||||
self::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::space(state)
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| {
|
||||
state.sequence(|state| {
|
||||
state.optional(|state| {
|
||||
self::space(state).and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state)
|
||||
.and_then(|state| {
|
||||
self::space(state)
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| self::partial(state))
|
||||
})
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn simple(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::simple, |state| {
|
||||
self::primitive(state)
|
||||
.or_else(|state| self::partial(state))
|
||||
.or_else(|state| self::tilde(state))
|
||||
.or_else(|state| self::caret(state))
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn primitive(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::primitive, |state| {
|
||||
state.sequence(|state| {
|
||||
self::primitive_op(state)
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| {
|
||||
state.sequence(|state| {
|
||||
state.optional(|state| {
|
||||
self::space(state).and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state)
|
||||
.and_then(|state| self::space(state))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| self::partial(state))
|
||||
})
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn primitive_op(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::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 partial(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::partial, |state| {
|
||||
state.sequence(|state| {
|
||||
self::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::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::xr(state))
|
||||
.and_then(|state| {
|
||||
super::hidden::skip(state)
|
||||
})
|
||||
.and_then(|state| {
|
||||
state.optional(|state| {
|
||||
self::qualifier(state)
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn xr(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::xr, |state| {
|
||||
self::xr_op(state).or_else(|state| self::nr(state))
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn xr_op(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::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 nr(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::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 tilde(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::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::space(state).and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state)
|
||||
.and_then(|state| self::space(state))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| self::partial(state))
|
||||
})
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn caret(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::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::space(state).and_then(|state| {
|
||||
state.repeat(|state| {
|
||||
state.sequence(|state| {
|
||||
super::hidden::skip(state)
|
||||
.and_then(|state| self::space(state))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
.and_then(|state| super::hidden::skip(state))
|
||||
.and_then(|state| self::partial(state))
|
||||
})
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn qualifier(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::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::parts(state))
|
||||
})
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn parts(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::parts, |state| {
|
||||
state.sequence(|state| {
|
||||
self::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::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::part(state)
|
||||
})
|
||||
})
|
||||
},
|
||||
)
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case, unused_variables)]
|
||||
pub fn part(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.rule(Rule::part, |state| {
|
||||
self::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 space(
|
||||
state: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<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: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<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: Box<::pest::ParserState<Rule>>,
|
||||
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|
||||
state.start_of_input()
|
||||
}
|
||||
}
|
||||
pub use self::visible::*;
|
||||
}
|
||||
::pest::state(input, |state| match rule {
|
||||
Rule::range_set => rules::range_set(state),
|
||||
Rule::logical_or => rules::logical_or(state),
|
||||
Rule::range => rules::range(state),
|
||||
Rule::empty => rules::empty(state),
|
||||
Rule::hyphen => rules::hyphen(state),
|
||||
Rule::simple => rules::simple(state),
|
||||
Rule::primitive => rules::primitive(state),
|
||||
Rule::primitive_op => rules::primitive_op(state),
|
||||
Rule::partial => rules::partial(state),
|
||||
Rule::xr => rules::xr(state),
|
||||
Rule::xr_op => rules::xr_op(state),
|
||||
Rule::nr => rules::nr(state),
|
||||
Rule::tilde => rules::tilde(state),
|
||||
Rule::caret => rules::caret(state),
|
||||
Rule::qualifier => rules::qualifier(state),
|
||||
Rule::parts => rules::parts(state),
|
||||
Rule::part => rules::part(state),
|
||||
Rule::space => rules::space(state),
|
||||
Rule::EOI => rules::EOI(state),
|
||||
})
|
||||
}
|
||||
}
|
||||
@ -1,13 +0,0 @@
|
||||
mod modA {
|
||||
mod modB {
|
||||
mod modC {
|
||||
mod modD {
|
||||
mod modE {
|
||||
fn func() {
|
||||
state . rule (Rule :: myrule , | state | { state . sequence (| state | { state . sequence (| state | { state . match_string ("abc") . and_then (| state | { super :: hidden :: skip (state) }) . and_then (| state | { state . match_string ("def") }) }) . and_then (| state | { super :: hidden :: skip (state) }) . and_then (| state | { state . sequence (| state | { state . optional (| state | { state . sequence (| state | { state . match_string ("abc") . and_then (| state | { super :: hidden :: skip (state) }) . and_then (| state | { state . match_string ("def") }) }) . and_then (| state | { state . repeat (| state | { state . sequence (| state | { super :: hidden :: skip (state) . and_then (| state | { state . sequence (| state | { state . match_string ("abc") . and_then (| state | { super :: hidden :: skip (state) }) . and_then (| state | { state . match_string ("def") }) }) }) }) }) }) }) }) }) }) });
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
Loading…
x
Reference in New Issue
Block a user