Method parse_expr

core/src/parser.rs:785–1009

Parses an expression. Returns `None` if no expression was found. This is necessary to treat the case of empty arguments to statements, as is the case in `PRINT a , , b`. If the caller has already processed a parenthesized term of an expression like `(first) + second`, then that term must be provided in `first`. This is an implementation of the Shunting Yard Algorithm by Edgar Dijkstra.

(&mut self, first: Option<Expr>)

    ///
    /// This is an implementation of the Shunting Yard Algorithm by Edgar Dijkstra.
    fn parse_expr(&mut self, first: Option<Expr>) -> Result<Option<Expr>> {
        let mut exprs: Vec<Expr> = vec![];
        let mut op_spans: Vec<ExprOpSpan> = vec![];

        let mut need_operand = true; // Also tracks whether an upcoming minus is unary.
        if let Some(e) = first {
            exprs.push(e);
            need_operand = false;
        }

        loop {
            let mut handle_operand = |e, pos| {
                if !need_operand {
                    return Err(Error::Bad(pos, "Unexpected value in expression".to_owned()));
                }
                need_operand = false;
                exprs.push(e);
                Ok(())
            };

            // Stop processing if we encounter an expression separator, but don't consume it because
            // the caller needs to have access to it.
            match self.lexer.peek()?.token {
                Token::Eof
                | Token::Eol
                | Token::As
                | Token::Comma
                | Token::Else
                | Token::Semicolon
                | Token::Then
                | Token::To
                | Token::Step => break,
                Token::RightParen if !op_spans.iter().any(|eos| eos.op == ExprOp::LeftParen) => {
                    // We encountered an unbalanced parenthesis but we don't know if this is
                    // because we were called from within an argument list (in which case the
                    // caller consumed the opening parenthesis and is expecting to consume the
                    // closing parenthesis) or because we really found an invalid expression.
                    // Only the caller can know, so avoid consuming the token and exit.
                    break;
                }
                _ => (),
            };

            let ts = self.lexer.consume_peeked();
            match ts.token {
                Token::Boolean(value) => {
                    handle_operand(Expr::Boolean(BooleanSpan { value, pos: ts.pos }), ts.pos)?
                }
                Token::Double(value) => {
                    handle_operand(Expr::Double(DoubleSpan { value, pos: ts.pos }), ts.pos)?
                }
                Token::Integer(value) => {
                    handle_operand(Expr::Integer(IntegerSpan { value, pos: ts.pos }), ts.pos)?
                }
                Token::Text(value) => {
                    handle_operand(Expr::Text(TextSpan { value, pos: ts.pos }), ts.pos)?
                }
                Token::Symbol(vref) => {