Method parse_data

core/src/parser.rs:447–530

Parses a `DATA` statement.

(&mut self)

    /// Parses a `DATA` statement.
    fn parse_data(&mut self) -> Result<Statement> {
        let mut values = vec![];
        loop {
            let peeked = self.lexer.peek()?;
            match peeked.token {
                Token::Eof | Token::Eol | Token::Else => {
                    values.push(None);
                    break;
                }
                _ => (),
            }

            let token_span = self.lexer.read()?;
            match token_span.token {
                Token::Boolean(b) => {
                    values.push(Some(Expr::Boolean(BooleanSpan { value: b, pos: token_span.pos })))
                }
                Token::Double(d) => {
                    values.push(Some(Expr::Double(DoubleSpan { value: d, pos: token_span.pos })))
                }
                Token::Integer(i) => {
                    values.push(Some(Expr::Integer(IntegerSpan { value: i, pos: token_span.pos })))
                }
                Token::Text(t) => {
                    values.push(Some(Expr::Text(TextSpan { value: t, pos: token_span.pos })))
                }

                Token::Minus => {
                    let token_span2 = self.lexer.read()?;
                    match token_span2.token {
                        Token::Double(d) => values.push(Some(Expr::Double(DoubleSpan {
                            value: -d,
                            pos: token_span.pos,
                        }))),
                        Token::Integer(i) => values.push(Some(Expr::Integer(IntegerSpan {
                            value: -i,
                            pos: token_span.pos,
                        }))),
                        _ => {
                            return Err(Error::Bad(
                                token_span.pos,
                                "Expected number after -".to_owned(),
                            ));
                        }
                    }
                }

                Token::Eof | Token::Eol | Token::Else => {
                    panic!("Should not be consumed here; handled above")
                }

                Token::Comma => {
                    values.push(None);
                    continue;
                }

                t => {
                    return Err(Error::Bad(