126 lines
3.7 KiB
Rust
126 lines
3.7 KiB
Rust
use env::Env;
|
|
use expression::{BinaryOperation, Expression};
|
|
use function::{Function, FunctionMap, NativeFunction};
|
|
use statement::Statement;
|
|
use value::Value;
|
|
|
|
mod env;
|
|
mod expression;
|
|
mod function;
|
|
mod macros;
|
|
mod statement;
|
|
mod value;
|
|
|
|
fn run(functions: FunctionMap, statements: &[Statement]) {
|
|
let env = Env::new();
|
|
for statement in statements {
|
|
statement.eval(&env, &functions);
|
|
}
|
|
}
|
|
|
|
fn main() {
|
|
let statements = vec![
|
|
Statement::Assignment("a".to_string(), Expression::from(1)),
|
|
Statement::Assignment("b".to_string(), Expression::from(2)),
|
|
Statement::Assignment("c".to_string(), Expression::from(3)),
|
|
Statement::Print(Expression::Binary(
|
|
Box::new(Expression::Variable("a".to_string())),
|
|
BinaryOperation::Add,
|
|
Box::new(Expression::Variable("b".to_string())),
|
|
)),
|
|
Statement::Print(Expression::Binary(
|
|
Box::new(Expression::Variable("a".to_string())),
|
|
BinaryOperation::Add,
|
|
Box::new(Expression::Variable("c".to_string())),
|
|
)),
|
|
Statement::Print(Expression::Binary(
|
|
Box::new(Expression::Variable("b".to_string())),
|
|
BinaryOperation::Add,
|
|
Box::new(Expression::Variable("c".to_string())),
|
|
)),
|
|
];
|
|
run(FunctionMap::new(), &statements);
|
|
|
|
let while_test = vec![
|
|
Statement::Print("while test".to_string().into()),
|
|
Statement::Assignment("a".to_string(), Expression::from(1)),
|
|
Statement::While(
|
|
Expression::Binary(
|
|
Box::new(Expression::Variable("a".to_string())),
|
|
BinaryOperation::LessThan,
|
|
Box::new(10.into()),
|
|
),
|
|
vec![
|
|
Statement::Assignment(
|
|
"a".to_string(),
|
|
Expression::Binary(
|
|
Box::new(Expression::Variable("a".to_string())),
|
|
BinaryOperation::Add,
|
|
Box::new(1.into()),
|
|
),
|
|
),
|
|
Statement::Print(Expression::Variable("a".to_string())),
|
|
],
|
|
),
|
|
];
|
|
run(FunctionMap::new(), &while_test);
|
|
|
|
{
|
|
let env = Env::new();
|
|
|
|
let res = (|arg: &i32| arg + 1).native_execute(&env, &[Value::Int(1)]);
|
|
println!("{:?}", res);
|
|
}
|
|
|
|
{
|
|
let z = || 100;
|
|
let env = Env::new();
|
|
let res = z.native_execute(&env, &[]);
|
|
println!("{:?}", res);
|
|
}
|
|
|
|
{
|
|
let z = |a: &Value| a.clone();
|
|
let env = Env::new();
|
|
let res = z.into_function().execute(&env, &FunctionMap::new(), &[]);
|
|
println!("{:?}", res);
|
|
}
|
|
|
|
{
|
|
let z = |a: &String| a.clone();
|
|
let env = Env::new();
|
|
let res = z.native_execute(&env, &[100.into()]);
|
|
println!("{:?}", res);
|
|
}
|
|
|
|
{
|
|
let v: Vec<Box<dyn Function>> = vec![
|
|
Box::new((|| 100).into_function()),
|
|
Box::new((|a: &i32| a + 1).into_function()),
|
|
];
|
|
for f in v {
|
|
let r = f.execute(&Env::new(), &FunctionMap::new(), &[100.into()]);
|
|
println!("{:?}", r);
|
|
}
|
|
}
|
|
|
|
let mut m: FunctionMap = Default::default();
|
|
m.insert_native("print", |a: &Value| {
|
|
println!("{}", a);
|
|
});
|
|
|
|
m.insert_native("waluigi", || "Waluigi");
|
|
|
|
m.insert_interpreter("call_print", vec!["what".to_string()], vec![
|
|
Statement::Expression(Expression::Call("print".to_string(), vec![Expression::Variable("what".to_string())])),
|
|
]);
|
|
|
|
run(
|
|
m,
|
|
&vec![Statement::Expression(Expression::Call(
|
|
"call_print".to_string(),
|
|
vec![Expression::Call("waluigi".to_string(), vec![])],
|
|
))],
|
|
);
|
|
}
|