1935623963

Build # 1935623963

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/Geal/nom/commit/<a class=hub.com/Geal/nom/commit/<a class="double-link" href="https://git"><a class=hub.com/Geal/nom/commit/<a class="double-link" href="https://git"><a class=hub.com/Geal/nom/commit/<a class="double-link" href="https://git"><a class=hub.com/Geal/nom/commit/2ea80b1e4331c345da12d5e57ca5cde5a632e81a">2ea80b1e4">&lt;a href=&quot;https://github.com/Geal/nom/commit/</a><a class="double-link" href="https://github.com/Geal/nom/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Geal/nom/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Geal/nom/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Geal/nom/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Geal/nom/commit/2ea80b1e4331c345da12d5e57ca5cde5a632e81a">2ea80b1e4</a><a href="https://github.com/Geal/nom/commit/2ea80b1e4331c345da12d5e57ca5cde5a632e81a">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/Geal/nom/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/Geal/nom/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Geal/nom/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Geal/nom/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Geal/nom/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Geal/nom/commit/2ea80b1e4331c345da12d5e57ca5cde5a632e81a&quot;&gt;2ea80b1e4&lt;/a&gt;&lt;a href=&quot;https://github.com/Geal/nom/commit/2ea80b1e4331c345da12d5e57ca5cde5a632e81a&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/Geal/nom/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/Geal/nom/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://git&amp;quot;&amp;gt;&amp;amp;lt;a class=&amp;lt;/a&amp;gt;hub.com/Geal/nom/comm... (continued)

Pull Request Pull Request #1362: Precedence parsing

Run Details

161 of 161 new or added lines in 4 files covered. (100.0%)

4481 of 5654 relevant lines covered (79.25%)

2.55 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

62.99

/src/precedence/mod.rs

//! Combinators to parse expressions with operator precedence.
#![cfg(feature="alloc")]
#![cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]

#[cfg(test)]
mod tests;

use crate::error::{ErrorKind, FromExternalError, ParseError};
use crate::lib::std::vec::Vec;
use crate::{Err, IResult, Parser};

/// An unary operator.
pub struct Unary<V, Q: Ord + Copy> {
  value: V,
  precedence: Q,
}

/// A binary operator.
pub struct Binary<V, Q: Ord + Copy> {
  value: V,
  precedence: Q,
  assoc: Assoc,
}

/// A single evaluation step.
pub enum Operation<P1, P2, P3, O> {
  /// A prefix operation.
  Prefix(P1, O),
  /// A postfix operation.
  Postfix(O, P2),
  /// A binary operation.
  Binary(O, P3, O),
}

/// Associativity for binary operators.
#[derive(Copy, Clone, PartialEq, Eq)]
pub enum Assoc {
  /// Left associative.
  Left,
  /// Right associative.
  Right,
}

/// Element for operator stack.
enum Operator<P1, P2, P3, Q: Ord + Copy> {
  Prefix(P1, Q),
  Postfix(P2, Q),
  Binary(P3, Q, Assoc),
}

impl<P1, P2, P3, Q> Operator<P1, P2, P3, Q>
where
  Q: Ord + Copy,
{
  fn precedence(&self) -> Q {
    match self {
      Operator::Prefix(_, p) => *p,
      Operator::Postfix(_, p) => *p,
      Operator::Binary(_, p, _) => *p,
    }
  }

  fn is_postfix(&self) -> bool {
    match self {
      Operator::Postfix(_, _) => true,
      _ => false,
    }
  }
}

/// Runs the inner parser and transforms the result into an unary operator with the given precedence.
///
/// Intended for use with [precedence].
/// # Arguments
/// * `precedence` The precedence of the operator.
/// * `parser` The parser to apply.
pub fn unary_op<I, O, E, P, Q>(
  precedence: Q,
  mut parser: P,
) -> impl FnMut(I) -> IResult<I, Unary<O, Q>, E>
where
  P: Parser<I, O, E>,
  Q: Ord + Copy,
{
  move |input| match parser.parse(input) {
    Ok((i, value)) => Ok((
      i,
      Unary {
        value,
        precedence,
      },
    )),
    Err(e) => Err(e),
  }
}

/// Runs the inner parser and transforms the result into a binary operator with the given precedence and associativity.
///
/// Intended for use with [precedence].
/// # Arguments
/// * `precedence` The precedence of the operator.
/// * `assoc` The associativity of the operator.
/// * `parser` The parser to apply.
pub fn binary_op<I, O, E, P, Q>(
  precedence: Q,
  assoc: Assoc,
  mut parser: P,
) -> impl FnMut(I) -> IResult<I, Binary<O, Q>, E>
where
  P: Parser<I, O, E>,
  Q: Ord + Copy,
{
  move |input| match parser.parse(input) {
    Ok((i, value)) => Ok((
      i,
      Binary {
        value,
        precedence,
        assoc,
      },
    )),
    Err(e) => Err(e),
  }
}

/// Parses an expression with operator precedence.
/// 
/// Supports prefix, postfix and binary operators. Operators are applied in ascending precedence.
///
/// The parser will track its current position inside the expression and call the respective
/// operand/operator parsers. The prefix and postfix parsers are called repeatedly until they fail before
/// execution moves on to the operand or binary parser.
///
/// Expressions are folded as soon as possible. The result will be reused as another operand. After the
/// expression has been read completely any remaining operations are folded and the resulting, single
/// operand is returned as the result.
///
/// It will return `Err(Err:Error((_, ErrorKind::Precedence)))` if:
/// * the `fold` function returns an `Err`.
/// * more than one or no operands remain after the expression has been evaluated completely.
/// * the input does not match the pattern: `prefix* operand postfix* (binary prefix* operand postfix*)*`
///
/// # Arguments
/// * `prefix` Parser for prefix unary operators.
/// * `postfix` Parser for postfix unary operators.
/// * `binary` Parser for binary operators.
/// * `operand` Parser for operands.
/// * `fold` Function that evaluates a single operation and returns the result.
/// 
/// # Example
/// ```rust
/// # use nom::{Err, error::{Error, ErrorKind}, IResult};
/// use nom::precedence::{precedence, unary_op, binary_op, Assoc, Operation};
/// use nom::character::complete::digit1;
/// use nom::combinator::{map_res, fail};
/// use nom::sequence::delimited;
/// use nom::bytes::complete::tag;
/// use nom::branch::alt;
/// 
/// fn parser(i: &str) -> IResult<&str, i64> {
///   precedence(
///     unary_op(1, tag("-")),
///     fail,
///     alt((
///       binary_op(2, Assoc::Left, tag("*")),
///       binary_op(2, Assoc::Left, tag("/")),
///       binary_op(3, Assoc::Left, tag("+")),
///       binary_op(3, Assoc::Left, tag("-")),
///     )),
///     alt((
///       map_res(digit1, |s: &str| s.parse::<i64>()),
///       delimited(tag("("), parser, tag(")")),
///     )),
///     |op: Operation<&str, &str, &str, i64>| {
///       use nom::precedence::Operation::*;
///       match op {
///         Prefix("-", o) => Ok(-o),
///         Binary(lhs, "*", rhs) => Ok(lhs * rhs),
///         Binary(lhs, "/", rhs) => Ok(lhs / rhs),
///         Binary(lhs, "+", rhs) => Ok(lhs + rhs),
///         Binary(lhs, "-", rhs) => Ok(lhs - rhs),
///         _ => Err("Invalid combination"),
///       }
///     }
///   )(i)
/// }
///
/// assert_eq!(parser("8-2*2"), Ok(("", 4)));
/// assert_eq!(parser("4-(2+2)"), Ok(("", 0)));
/// assert_eq!(parser("3-(2*3)+7+2*2-(2*(2+4))"), Ok(("", -4)));
/// ```
/// 
/// # Evaluation order
/// This parser reads expressions from left to right and folds operations as soon as possible. This
/// behaviour is only important when using an operator grammar that allows for ambigious expressions.
/// 
/// For example, the expression `-a++**b` is ambigious with the following precedence.
/// 
/// | Operator | Position | Precedence | Associativity |
/// |----------|----------|------------|---------------|
/// | **       | Binary   | 1          | Right         |
/// | -        | Prefix   | 2          | N/A           |
/// | ++       | Postfix  | 3          | N/A           |
/// 
/// The expression can be parsed in two ways: `-((a++)**b)` or `((-a)++)**b`. This parser will always
/// parse it as the latter because of how it evaluates expressions:
/// * It reads, left-to-right, the first two operators `-a++`.
/// * Because the minus takes precedence over the increment it is evaluated immediately `(-a)++`.
/// * It then reads the remaining input and evaluates the increment next in order to preserve its
/// position in the expression \
/// `((-a)++)**b`.
#[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
pub fn precedence<I, O, E, E2, F, G, H1, H3, H2, P1, P2, P3, Q>(
  mut prefix: H1,
  mut postfix: H2,
  mut binary: H3,
  mut operand: F,
  mut fold: G,
) -> impl FnMut(I) -> IResult<I, O, E>
where
  I: Clone + PartialEq,
  E: ParseError<I> + FromExternalError<I, E2>,
  F: Parser<I, O, E>,
  G: FnMut(Operation<P1, P2, P3, O>) -> Result<O, E2>,
  H1: Parser<I, Unary<P1, Q>, E>,
  H2: Parser<I, Unary<P2, Q>, E>,
  H3: Parser<I, Binary<P3, Q>, E>,
  Q: Ord + Copy,
{
  move |mut i| {
    let mut operands = Vec::new();
    let mut operators = Vec::new();
    let mut i1 = i.clone();

    'main: loop {
      'prefix: loop {
        match prefix.parse(i1.clone()) {
          Err(Err::Error(_)) => break 'prefix,
          Err(e) => return Err(e),
          Ok((i2, o)) => {
            // infinite loop check: the parser must always consume
            if i2 == i1 {
              return Err(Err::Error(E::from_error_kind(i1, ErrorKind::Precedence)));
            }
            i1 = i2;
            operators.push(Operator::Prefix(o.value, o.precedence));
          }
        }
      }

      let (i2, o) = match operand.parse(i1.clone()) {
        Ok((i, o)) => (i, o),
        Err(Err::Error(e)) => return Err(Err::Error(E::append(i, ErrorKind::Precedence, e))),
        Err(e) => return Err(e),
      };
      i1 = i2;
      operands.push(o);

      'postfix: loop {
        match postfix.parse(i1.clone()) {
          Err(Err::Error(_)) => break 'postfix,
          Err(e) => return Err(e),
          Ok((i2, o)) => {
            // infinite loop check: the parser must always consume
            if i2 == i1 {
              return Err(Err::Error(E::from_error_kind(i1, ErrorKind::Precedence)));
            }

            while operators
              .last()
              .map(|op| op.precedence() <= o.precedence)
              .unwrap_or(false)
            {
              let value = operands.pop().unwrap();
              let operation = match operators.pop().unwrap() {
                Operator::Prefix(op, _) => Operation::Prefix(op, value),
                Operator::Postfix(op, _) => Operation::Postfix(value, op),
                Operator::Binary(op, _, _) => match operands.pop() {
                  Some(lhs) => Operation::Binary(lhs, op, value),
                  None => return Err(Err::Error(E::from_error_kind(i1, ErrorKind::Precedence))),
                },
              };
              let result = match fold(operation) {
                Err(e) => {
                  return Err(Err::Error(E::from_external_error(
                    i,
                    ErrorKind::Precedence,
                    e,
                  )))
                }
                Ok(r) => r,
              };
              operands.push(result);
            }
            i1 = i2;
            operators.push(Operator::Postfix(o.value, o.precedence));
          }
        }
      }

      match binary.parse(i1.clone()) {
        Err(Err::Error(_)) => break 'main,
        Err(e) => return Err(e),
        Ok((i2, o)) => {
          while operators
            .last()
            .map(|op| {
              op.precedence() < o.precedence
                || (o.assoc == Assoc::Left && op.precedence() == o.precedence)
                || (op.is_postfix())
            })
            .unwrap_or(false)
          {
            let value = operands.pop().unwrap();
            let operation = match operators.pop().unwrap() {
              Operator::Prefix(op, _) => Operation::Prefix(op, value),
              Operator::Postfix(op, _) => Operation::Postfix(value, op),
              Operator::Binary(op, _, _) => match operands.pop() {
                Some(lhs) => Operation::Binary(lhs, op, value),
                None => return Err(Err::Error(E::from_error_kind(i1, ErrorKind::Precedence))),
              },
            };
            let result = match fold(operation) {
              Err(e) => {
                return Err(Err::Error(E::from_external_error(
                  i,
                  ErrorKind::Precedence,
                  e,
                )))
              }
              Ok(r) => r,
            };
            operands.push(result);
          }
          operators.push(Operator::Binary(o.value, o.precedence, o.assoc));
          i1 = i2;
        }
      }

      // infinite loop check: either operand or operator must consume input
      if i == i1 {
        return Err(Err::Error(E::from_error_kind(i, ErrorKind::Precedence)));
      }
      i = i1.clone();
    }

    while operators.len() > 0 {
      let value = match operands.pop() {
        Some(o) => o,
        None => return Err(Err::Error(E::from_error_kind(i, ErrorKind::Precedence))),
      };
      let operation = match operators.pop().unwrap() {
        Operator::Prefix(op, _) => Operation::Prefix(op, value),
        Operator::Postfix(op, _) => Operation::Postfix(value, op),
        Operator::Binary(op, _, _) => match operands.pop() {
          Some(lhs) => Operation::Binary(lhs, op, value),
          None => return Err(Err::Error(E::from_error_kind(i, ErrorKind::Precedence))),
        },
      };
      let result = match fold(operation) {
        Ok(r) => r,
        Err(e) => {
          return Err(Err::Error(E::from_external_error(
            i,
            ErrorKind::Precedence,
            e,
          )))
        }
      };
      operands.push(result);
    }

    if operands.len() == 1 {
      return Ok((i1, operands.pop().unwrap()));
    } else {
      return Err(Err::Error(E::from_error_kind(i, ErrorKind::Precedence)));
    }
  }
}

1	//! Combinators to parse expressions with operator precedence.
2	#![cfg(feature="alloc")]
3	#![cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
4
5	#[cfg(test)]
6	mod tests;
7
8	use crate::error::{ErrorKind, FromExternalError, ParseError};
9	use crate::lib::std::vec::Vec;
10	use crate::{Err, IResult, Parser};
11
12	/// An unary operator.
13	pub struct Unary<V, Q: Ord + Copy> {
14	value: V,
15	precedence: Q,
16	}
17
18	/// A binary operator.
19	pub struct Binary<V, Q: Ord + Copy> {
20	value: V,
21	precedence: Q,
22	assoc: Assoc,
23	}
24
25	/// A single evaluation step.
26	pub enum Operation<P1, P2, P3, O> {
27	/// A prefix operation.
28	Prefix(P1, O),
29	/// A postfix operation.
30	Postfix(O, P2),
31	/// A binary operation.
32	Binary(O, P3, O),
33	}
34
35	/// Associativity for binary operators.
36	#[derive(Copy, Clone, PartialEq, Eq)]
37	pub enum Assoc {
38	/// Left associative.
39	Left,
40	/// Right associative.
41	Right,
42	}
43
44	/// Element for operator stack.
45	enum Operator<P1, P2, P3, Q: Ord + Copy> {
46	Prefix(P1, Q),
47	Postfix(P2, Q),
48	Binary(P3, Q, Assoc),
49	}
50
51	impl<P1, P2, P3, Q> Operator<P1, P2, P3, Q>
52	where
53	Q: Ord + Copy,
54	{
55	fn precedence(&self) -> Q {	2✔
56	match self {	2✔
57	Operator::Prefix(_, p) => *p,	1✔
58	Operator::Postfix(_, p) => *p,	1✔
59	Operator::Binary(_, p, _) => *p,	2✔
60	}
61	}
62
63	fn is_postfix(&self) -> bool {	2✔
64	match self {	2✔
65	Operator::Postfix(_, _) => true,	×
66	_ => false,	2✔
67	}
68	}
69	}
70
71	/// Runs the inner parser and transforms the result into an unary operator with the given precedence.
72	///
73	/// Intended for use with [precedence].
74	/// # Arguments
75	/// * `precedence` The precedence of the operator.
76	/// * `parser` The parser to apply.
77	pub fn unary_op<I, O, E, P, Q>(	4✔
78	precedence: Q,
79	mut parser: P,
80	) -> impl FnMut(I) -> IResult<I, Unary<O, Q>, E>
81	where
82	P: Parser<I, O, E>,
83	Q: Ord + Copy,
84	{
85	move \|input\| match parser.parse(input) {	12✔
86	Ok((i, value)) => Ok((	6✔
87	i,	×
88	Unary {	3✔
89	value,	1✔
90	precedence,	3✔
91	},
92	)),
93	Err(e) => Err(e),	4✔
94	}
95	}
96
97	/// Runs the inner parser and transforms the result into a binary operator with the given precedence and associativity.
98	///
99	/// Intended for use with [precedence].
100	/// # Arguments
101	/// * `precedence` The precedence of the operator.
102	/// * `assoc` The associativity of the operator.
103	/// * `parser` The parser to apply.
104	pub fn binary_op<I, O, E, P, Q>(	4✔
105	precedence: Q,
106	assoc: Assoc,
107	mut parser: P,
108	) -> impl FnMut(I) -> IResult<I, Binary<O, Q>, E>
109	where
110	P: Parser<I, O, E>,
111	Q: Ord + Copy,
112	{
113	move \|input\| match parser.parse(input) {	12✔
114	Ok((i, value)) => Ok((	8✔
115	i,	×
116	Binary {	4✔
117	value,	3✔
118	precedence,	4✔
119	assoc,	4✔
120	},
121	)),
122	Err(e) => Err(e),	4✔
123	}
124	}
125
126	/// Parses an expression with operator precedence.
127	///
128	/// Supports prefix, postfix and binary operators. Operators are applied in ascending precedence.
129	///
130	/// The parser will track its current position inside the expression and call the respective
131	/// operand/operator parsers. The prefix and postfix parsers are called repeatedly until they fail before
132	/// execution moves on to the operand or binary parser.
133	///
134	/// Expressions are folded as soon as possible. The result will be reused as another operand. After the
135	/// expression has been read completely any remaining operations are folded and the resulting, single
136	/// operand is returned as the result.
137	///
138	/// It will return `Err(Err:Error((_, ErrorKind::Precedence)))` if:
139	/// * the `fold` function returns an `Err`.
140	/// * more than one or no operands remain after the expression has been evaluated completely.
141	/// * the input does not match the pattern: `prefix* operand postfix* (binary prefix* operand postfix)`
142	///
143	/// # Arguments
144	/// * `prefix` Parser for prefix unary operators.
145	/// * `postfix` Parser for postfix unary operators.
146	/// * `binary` Parser for binary operators.
147	/// * `operand` Parser for operands.
148	/// * `fold` Function that evaluates a single operation and returns the result.
149	///
150	/// # Example
151	/// ```rust
152	/// # use nom::{Err, error::{Error, ErrorKind}, IResult};
153	/// use nom::precedence::{precedence, unary_op, binary_op, Assoc, Operation};
154	/// use nom::character::complete::digit1;
155	/// use nom::combinator::{map_res, fail};
156	/// use nom::sequence::delimited;
157	/// use nom::bytes::complete::tag;
158	/// use nom::branch::alt;
159	///
160	/// fn parser(i: &str) -> IResult<&str, i64> {
161	/// precedence(
162	/// unary_op(1, tag("-")),
163	/// fail,
164	/// alt((
165	/// binary_op(2, Assoc::Left, tag("*")),
166	/// binary_op(2, Assoc::Left, tag("/")),
167	/// binary_op(3, Assoc::Left, tag("+")),
168	/// binary_op(3, Assoc::Left, tag("-")),
169	/// )),
170	/// alt((
171	/// map_res(digit1, \|s: &str\| s.parse::<i64>()),
172	/// delimited(tag("("), parser, tag(")")),
173	/// )),
174	/// \|op: Operation<&str, &str, &str, i64>\| {
175	/// use nom::precedence::Operation::*;
176	/// match op {
177	/// Prefix("-", o) => Ok(-o),
178	/// Binary(lhs, "", rhs) => Ok(lhs rhs),
179	/// Binary(lhs, "/", rhs) => Ok(lhs / rhs),
180	/// Binary(lhs, "+", rhs) => Ok(lhs + rhs),
181	/// Binary(lhs, "-", rhs) => Ok(lhs - rhs),
182	/// _ => Err("Invalid combination"),
183	/// }
184	/// }
185	/// )(i)
186	/// }
187	///
188	/// assert_eq!(parser("8-2*2"), Ok(("", 4)));
189	/// assert_eq!(parser("4-(2+2)"), Ok(("", 0)));
190	/// assert_eq!(parser("3-(23)+7+22-(2*(2+4))"), Ok(("", -4)));
191	/// ```
192	///
193	/// # Evaluation order
194	/// This parser reads expressions from left to right and folds operations as soon as possible. This
195	/// behaviour is only important when using an operator grammar that allows for ambigious expressions.
196	///
197	/// For example, the expression `-a++**b` is ambigious with the following precedence.
198	///
199	/// \| Operator \| Position \| Precedence \| Associativity \|
200	/// \|----------\|----------\|------------\|---------------\|
201	/// \| ** \| Binary \| 1 \| Right \|
202	/// \| - \| Prefix \| 2 \| N/A \|
203	/// \| ++ \| Postfix \| 3 \| N/A \|
204	///
205	/// The expression can be parsed in two ways: `-((a++)b)` or `((-a)++)b`. This parser will always
206	/// parse it as the latter because of how it evaluates expressions:
207	/// * It reads, left-to-right, the first two operators `-a++`.
208	/// * Because the minus takes precedence over the increment it is evaluated immediately `(-a)++`.
209	/// * It then reads the remaining input and evaluates the increment next in order to preserve its
210	/// position in the expression \
211	/// `((-a)++)**b`.
212	#[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
213	pub fn precedence<I, O, E, E2, F, G, H1, H3, H2, P1, P2, P3, Q>(	2✔
214	mut prefix: H1,
215	mut postfix: H2,
216	mut binary: H3,
217	mut operand: F,
218	mut fold: G,
219	) -> impl FnMut(I) -> IResult<I, O, E>
220	where
221	I: Clone + PartialEq,
222	E: ParseError<I> + FromExternalError<I, E2>,
223	F: Parser<I, O, E>,
224	G: FnMut(Operation<P1, P2, P3, O>) -> Result<O, E2>,
225	H1: Parser<I, Unary<P1, Q>, E>,
226	H2: Parser<I, Unary<P2, Q>, E>,
227	H3: Parser<I, Binary<P3, Q>, E>,
228	Q: Ord + Copy,
229	{
230	move \|mut i\| {	4✔
231	let mut operands = Vec::new();	2✔
232	let mut operators = Vec::new();	2✔
233	let mut i1 = i.clone();	4✔
234
235	'main: loop {	4✔
236	'prefix: loop {	2✔
237	match prefix.parse(i1.clone()) {	6✔
238	Err(Err::Error(_)) => break 'prefix,	×
239	Err(e) => return Err(e),	×
240	Ok((i2, o)) => {	2✔
241	// infinite loop check: the parser must always consume
242	if i2 == i1 {	4✔
243	return Err(Err::Error(E::from_error_kind(i1, ErrorKind::Precedence)));	×
244	}
245	i1 = i2;	4✔
246	operators.push(Operator::Prefix(o.value, o.precedence));	2✔
247	}
248	}
249	}
250
251	let (i2, o) = match operand.parse(i1.clone()) {	7✔
252	Ok((i, o)) => (i, o),	2✔
253	Err(Err::Error(e)) => return Err(Err::Error(E::append(i, ErrorKind::Precedence, e))),	2✔
254	Err(e) => return Err(e),	×
255	};
256	i1 = i2;	4✔
257	operands.push(o);	4✔
258
259	'postfix: loop {	1✔
260	match postfix.parse(i1.clone()) {	4✔
261	Err(Err::Error(_)) => break 'postfix,	×
262	Err(e) => return Err(e),	×
263	Ok((i2, o)) => {	1✔
264	// infinite loop check: the parser must always consume
265	if i2 == i1 {	2✔
266	return Err(Err::Error(E::from_error_kind(i1, ErrorKind::Precedence)));	×
267	}
268
269	while operators	3✔
270	.last()	×
271	.map(\|op\| op.precedence() <= o.precedence)	3✔
272	.unwrap_or(false)	×
273	{
274	let value = operands.pop().unwrap();	×
275	let operation = match operators.pop().unwrap() {	×
276	Operator::Prefix(op, _) => Operation::Prefix(op, value),	×
277	Operator::Postfix(op, _) => Operation::Postfix(value, op),	×
278	Operator::Binary(op, _, _) => match operands.pop() {	×
279	Some(lhs) => Operation::Binary(lhs, op, value),	×
280	None => return Err(Err::Error(E::from_error_kind(i1, ErrorKind::Precedence))),	×
281	},
282	};
283	let result = match fold(operation) {	×
284	Err(e) => {	×
285	return Err(Err::Error(E::from_external_error(	×
286	i,	×
287	ErrorKind::Precedence,	×
288	e,	×
289	)))
290	}
291	Ok(r) => r,	×
292	};
293	operands.push(result);	×
294	}
295	i1 = i2;	2✔
296	operators.push(Operator::Postfix(o.value, o.precedence));	1✔
297	}
298	}
299	}
300
301	match binary.parse(i1.clone()) {	6✔
302	Err(Err::Error(_)) => break 'main,	×
303	Err(e) => return Err(e),	×
304	Ok((i2, o)) => {	2✔
305	while operators	8✔
306	.last()	×
307	.map(\|op\| {	4✔
308	op.precedence() < o.precedence	9✔
309	\|\| (o.assoc == Assoc::Left && op.precedence() == o.precedence)	4✔
310	\|\| (op.is_postfix())	2✔
311	})
312	.unwrap_or(false)	×
313	{
314	let value = operands.pop().unwrap();	2✔
315	let operation = match operators.pop().unwrap() {	4✔
316	Operator::Prefix(op, _) => Operation::Prefix(op, value),	1✔
317	Operator::Postfix(op, _) => Operation::Postfix(value, op),	1✔
318	Operator::Binary(op, _, _) => match operands.pop() {	2✔
319	Some(lhs) => Operation::Binary(lhs, op, value),	2✔
320	None => return Err(Err::Error(E::from_error_kind(i1, ErrorKind::Precedence))),	×
321	},
322	};
323	let result = match fold(operation) {	4✔
324	Err(e) => {	×
325	return Err(Err::Error(E::from_external_error(	×
326	i,	×
327	ErrorKind::Precedence,	×
328	e,	×
329	)))
330	}
331	Ok(r) => r,	2✔
332	};
333	operands.push(result);	2✔
334	}
335	operators.push(Operator::Binary(o.value, o.precedence, o.assoc));	2✔
336	i1 = i2;	2✔
337	}
338	}
339
340	// infinite loop check: either operand or operator must consume input
341	if i == i1 {	2✔
342	return Err(Err::Error(E::from_error_kind(i, ErrorKind::Precedence)));	×
343	}
344	i = i1.clone();	4✔
345	}
346
347	while operators.len() > 0 {	6✔
348	let value = match operands.pop() {	2✔
349	Some(o) => o,	2✔
350	None => return Err(Err::Error(E::from_error_kind(i, ErrorKind::Precedence))),	×
351	};
352	let operation = match operators.pop().unwrap() {	4✔
353	Operator::Prefix(op, _) => Operation::Prefix(op, value),	1✔
354	Operator::Postfix(op, _) => Operation::Postfix(value, op),	×
355	Operator::Binary(op, _, _) => match operands.pop() {	2✔
356	Some(lhs) => Operation::Binary(lhs, op, value),	2✔
357	None => return Err(Err::Error(E::from_error_kind(i, ErrorKind::Precedence))),	×
358	},
359	};
360	let result = match fold(operation) {	4✔
361	Ok(r) => r,	2✔
362	Err(e) => {	×
363	return Err(Err::Error(E::from_external_error(	×
364	i,	×
365	ErrorKind::Precedence,	×
366	e,	×
367	)))
368	}
369	};
370	operands.push(result);	2✔
371	}
372
373	if operands.len() == 1 {	4✔
374	return Ok((i1, operands.pop().unwrap()));	4✔
375	} else {
376	return Err(Err::Error(E::from_error_kind(i, ErrorKind::Precedence)));	×
377	}
378	}
379	}

Geal / nom / 1935623963

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous