frg 0.1.1

Compiled programming language with frogs!
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use super::*;
pub fn parse_params(
    mut token_iter: Peekable<Iter<Token>>,
) -> Option<(Vec<Parameter>, Peekable<Iter<Token>>)> {
    expect_symbol(&mut token_iter, lexer::Symbol::LeftParen);
    let mut params = vec![];

    while let Some(token) = token_iter.next() {
        let new_param = match token {
            Token::Keyword(keyword) => {
                let param_type = parse_types::match_lexer_types(keyword);
                // if let token_iter.next()
                if let Some(Token::Literal(lexer::Literal::Identifier(param_name))) =
                    token_iter.next()
                {
                    Parameter {
                        name: param_name.to_string(),
                        param_type,
                    }
                } else {
                    return None;
                }
            }
            Token::Symbol(lexer::Symbol::RightParen) => break,
            _ => return None,
        };
        params.push(new_param);
        if token_iter.peek() == Some(&&Token::Symbol(lexer::Symbol::Comma)) {
            token_iter.next();
        }
    }
    Some((params, token_iter))
}

pub fn parse_body(token_iter: &mut Peekable<Iter<Token>>) -> Vec<Statement> {
    expect_symbol(token_iter, lexer::Symbol::LeftBrace);
    if token_iter.peek() == Some(&&Token::Symbol(lexer::Symbol::RightBrace)) {
        token_iter.next();
        return vec![];
    }
    let mut nodes = vec![];
    while let Some(new_node) = parse_next_statement(token_iter) {
        nodes.push(new_node);
        if token_iter.peek() == Some(&&Token::Symbol(lexer::Symbol::RightBrace)) {
            token_iter.next();
            break;
        }
    }
    nodes
}

pub fn parse_arguments(token_iter: &mut Peekable<Iter<Token>>) -> Vec<Expression> {
    let mut arguments = vec![];
    expect_symbol(token_iter, lexer::Symbol::LeftParen);
    while let Some(token) = token_iter.peek() {
        let new_argument = match token {
            Token::Symbol(lexer::Symbol::RightParen) => {
                token_iter.next();
                return arguments;
            }
            Token::Symbol(lexer::Symbol::Comma) => {
                token_iter.next();
                continue;
            }
            _ => parse_expression(token_iter),
        };
        arguments.push(new_argument);
    }
    arguments
}

pub fn parse_return(token_iter: &mut Peekable<Iter<Token>>) -> Statement {
    expect_token(token_iter, Token::Keyword(lexer::Keyword::Return));
    let value = parse_expression(token_iter);
    Statement::Return(value)
}