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
77
78
79
80
81
82
83
84
85
86
87
88
89
90

use std::collections::HashMap;

use super::*;

pub fn is_struct_definition(mut token_iter: Peekable<Iter<Token>>) -> bool {
    token_iter.next();
    if let Some(Token::Literal(lexer::Literal::Identifier(_struct_variable_name))) =
        token_iter.next()
    {
        return true;
    }
    false
}

pub fn parse_type(token_iter: &mut Peekable<Iter<Token>>) -> Statement {
    expect_token(token_iter, Token::Keyword(lexer::Keyword::Struct));
    let name = match token_iter.next() {
        Some(Token::Literal(lexer::Literal::Identifier(n))) => n,
        _ => panic!("identifier after type"),
    };
    expect_symbol(token_iter, lexer::Symbol::LeftBrace);
    let mut fields: Vec<Parameter> = vec![];
    while let Some(token) = token_iter.next() {
        let var_type = match token {
            Token::Keyword(n) => n,
            _ => panic!("type expected"),
        };
        let field_name = match token_iter.next() {
            Some(Token::Literal(lexer::Literal::Identifier(n))) => n,
            _ => panic!("identifier after type"),
        };
        fields.push(Parameter {
            name: field_name.to_string(),
            param_type: parse_types::match_lexer_types(var_type),
        });
        if token_iter.peek() == Some(&&Token::Symbol(lexer::Symbol::Comma)) {
            token_iter.next();
        }
        if token_iter.peek() == Some(&&Token::Symbol(lexer::Symbol::RightBrace)) {
            token_iter.next();
            break;
        }
    }
    Statement::StructDeclaration {
        name: name.to_string(),
        fields,
    }
}

pub fn parse_declaration(token_iter: &mut Peekable<Iter<Token>>) -> Statement {
    let Token::Literal(lexer::Literal::Identifier(struct_name)) = token_iter.next().unwrap() else {
        unreachable!()
    };
    let name = match token_iter.next() {
        Some(Token::Literal(lexer::Literal::Identifier(n))) => n,
        _ => panic!("identifier after type"),
    };
    expect_symbol(token_iter, lexer::Symbol::Equals);
    let value = parse_struct::parse_data(token_iter);
    Statement::VariableDeclaration {
        var_type: VarType::Struct(struct_name.to_string()),
        name: name.clone(),
        value,
    }
}

fn parse_data(token_iter: &mut Peekable<Iter<Token>>) -> Expression {
    expect_symbol(token_iter, lexer::Symbol::LeftBrace);
    let mut fields = HashMap::new();
    while let Some(token) = token_iter.next() {
        let field_name = match token {
            Token::Literal(lexer::Literal::Identifier(id)) => id,
            _ => panic!("expected identifier"),
        };
        // if token_iter.peek() == Some(&&Token::Symbol(lexer::Symbol::Colon)) {
        //     token_iter.next();
        // }
        expect_symbol(token_iter, lexer::Symbol::Colon);
        let value = parse_expression(token_iter);
        fields.insert(field_name.to_string(), value);
        if token_iter.peek() == Some(&&Token::Symbol(lexer::Symbol::Comma)) {
            token_iter.next();
        }
        if token_iter.peek() == Some(&&Token::Symbol(lexer::Symbol::RightBrace)) {
            token_iter.next();
            break;
        }
    }
    Expression::CompositeLiteral(CompositeLiteral::Struct(fields))
}