frg 2.1.0

Compiled programming language with frogs!
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

use super::{TreeCursor, VarType, expressions, types};

mod function;
mod map;
mod reference;
mod set;
mod vec;

pub fn parse(cursor: &mut TreeCursor, code: &str) -> VarType {
    cursor.goto_first_child();

    let type_name = cursor.node().kind();
    let var_type = match type_name {
        "void" => VarType::Void,
        "int" => VarType::Int,
        "str" => VarType::Str,
        "float" => VarType::Float,
        "bool" => VarType::Bool,
        "reference_type" => reference::parse(cursor, code),
        "function_type" => function::parse(cursor, code),
        "struct_identifier" => VarType::Struct(code[cursor.node().byte_range()].to_string()),
        "vec_type" => vec::parse(cursor, code),
        "set_type" => set::parse(cursor, code),
        "map_type" => map::parse(cursor, code),
        _ => todo!("{type_name}"),
    };

    cursor.goto_parent();
    var_type
}

pub fn transpile(var_type: &VarType) -> String {
    let s = match &var_type {
        VarType::Void => "()",
        VarType::Int => "i32",
        VarType::Float => "f32",
        // could be a mistake
        VarType::Str => "&'static str",
        VarType::Bool => "bool",
        VarType::Reference(ref_type) => &format!("&mut {}", transpile(ref_type)),
        VarType::Struct(struct_name) => struct_name,
        VarType::Function {
            return_type,
            param_types,
        } => &format!(
            "fn({}) -> {}",
            expressions::transpile_list(&param_types.iter().map(transpile).collect()),
            transpile(return_type),
        ),
        VarType::Vec(inner_type) => &vec::transpile(inner_type),
        VarType::Set(inner_type) => &set::transpile(inner_type),
        VarType::Map(map_types) => &map::transpile(map_types),
        _ => todo!("{var_type:?}"),
    };
    s.to_string()
}