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

use super::*;

pub fn run_function(ctx: &mut ExecutionContext, name: &str, args: &[Expression]) -> VariableValue {
    let params: Vec<VariableValue> = args.iter().map(|exp| eval(ctx, exp)).collect();
    let is_macro = name.ends_with("!");
    if is_macro {
        return macros::run_macro(ctx, name, args);
    }
    let target_func = ctx
        .declared_functions
        .get(name)
        .unwrap_or_else(|| panic!("function `{name}` doesnt exist"));

    let mut func_ctx = target_func.ctx.clone();
    func_ctx
        .declared_functions
        .insert(name.to_string(), target_func.clone());
    target_func
        .params
        .iter()
        .enumerate()
        .for_each(|(i, param)| {
            // println!("adding var `{}` to `{}`", param.name.clone(), name);
            declarations::declare_variable(
                &mut func_ctx,
                &param.param_type.clone(),
                &param.name.clone(),
                params[i].clone(),
            );
        });

    let function_output = interpret_block(func_ctx, &target_func.ast);
    if let Some(returned_value) = function_output {
        return returned_value;
    }
    VariableValue::Void
}

fn conversion_error(value: &VariableValue, to: &VarType, err: impl std::error::Error) -> ! {
    panic!("Failed to parse {value:?} into {to:?} ({err})")
}

pub fn convert(ctx: &mut ExecutionContext, to: &VarType, expr: &Expression) -> VariableValue {
    let value = eval(ctx, expr);
    match to {
        VarType::Int => match value {
            VariableValue::Str(ref target_str) => VariableValue::Int(
                target_str
                    .parse()
                    .unwrap_or_else(|err| conversion_error(&value, to, err)),
            ),
            VariableValue::Float(target_float) => VariableValue::Int(target_float as i32),
            _ => todo!(),
        },
        VarType::Float => match value {
            VariableValue::Str(ref target_str) => VariableValue::Float(
                target_str
                    .parse()
                    .unwrap_or_else(|err| conversion_error(&value, to, err)),
            ),
            VariableValue::Int(target_int) => VariableValue::Float(target_int as f32),
            _ => todo!(),
        },
        VarType::Str => VariableValue::Str(value.to_string()),
        _ => todo!(),
    }
    // match value {
    //     VariableValue::Str(target_str) => match to {
    //         VarType::Int => VariableValue::Int(
    //             target_str
    //                 .parse()
    //                 .expect(&format!("failed to parse {target_str} into int")),
    //         ),
    //         VarType::Float => VariableValue::Float(
    //             target_str
    //                 .parse()
    //                 .expect(&format!("failed to parse {target_str} into float")),
    //         ),

    //         _ => todo!(),
    //     },
    //     _ => todo!(),
    // }
}