Method parse_callable_body

core/src/parser.rs:1386–1452

Parses the body of a callable and returns the collection of statements and the position of the end of the body.

(
        &mut self,
        start_pos: LineCol,
        exp_token: Token,
    )

    /// Parses the body of a callable and returns the collection of statements and the position
    /// of the end of the body.
    fn parse_callable_body(
        &mut self,
        start_pos: LineCol,
        exp_token: Token,
    ) -> Result<(Vec<Statement>, LineCol)> {
        debug_assert!(matches!(exp_token, Token::Function | Token::Sub));

        let mut body = vec![];
        let end_pos;
        loop {
            let peeked = self.lexer.peek()?;
            match peeked.token {
                Token::Eof => {
                    end_pos = peeked.pos;
                    break;
                }

                Token::Eol => {
                    self.lexer.consume_peeked();
                }

                Token::Function | Token::Sub => {
                    return Err(Error::Bad(
                        peeked.pos,
                        "Cannot nest FUNCTION or SUB definitions".to_owned(),
                    ));
                }

                Token::End => {
                    let end_span = self.lexer.consume_peeked();
                    match self.maybe_parse_end(end_span.pos)? {
                        Ok(stmt) => {
                            body.push(stmt);
                        }
                        Err(token) if token == exp_token => {
                            end_pos = end_span.pos;
                            break;
                        }
                        Err(token) => {
                            return Err(Error::Bad(
                                end_span.pos,
                                format!("END {} without {}", token, token),
                            ));
                        }
                    }
                }

                _ => match self.parse_one_safe()? {
                    Some(stmt) => body.push(stmt),
                    None => {
                        return Err(Error::Bad(
                            start_pos,
                            format!("{} without END {}", exp_token, exp_token),
                        ));
                    }
                },
            }
        }