First commitHEADmain

1 files changed, 293 insertions, 0 deletions

diff --git a/src/interpreter.rs b/src/interpreter.rs
new file mode 100644
index 0000000..264e634
--- /dev/null
+++ b/src/interpreter.rs
@@ -0,0 +1,293 @@
+use std::{
+	collections::{HashMap, HashSet},
+	fmt::Debug,
+	sync::Arc,
+};
+
+use rust_decimal::Decimal;
+
+use crate::{
+	ast::{self, Expression, List},
+	builtins::NIL,
+};
+
+type NativeFunction = fn(&mut Interpreter, &[Arc<Value>]) -> Arc<Value>;
+
+#[derive(Debug, Default)]
+pub struct Interpreter {
+	stack: Vec<HashMap<Arc<str>, Arc<Value>>>,
+}
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub enum Value {
+	Identifier(Arc<str>),
+	Number(Decimal),
+	String(Arc<str>),
+	Pair(Arc<Value>, Arc<Value>),
+	RustFn(NativeFunction),
+	DelshFn {
+		args: Arc<[Arc<str>]>,
+		command: Arc<Value>,
+	},
+}
+
+impl Debug for Value {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		fn fmt_pair(
+			f: &mut std::fmt::Formatter<'_>,
+			a: Arc<Value>,
+			b: Arc<Value>,
+		) -> std::fmt::Result {
+			a.fmt(f)?;
+
+			if let Value::Pair(a, b) = &*b {
+				f.write_str(" ")?;
+				fmt_pair(f, a.clone(), b.clone())
+			} else if b == NIL.clone() {
+				f.write_str(")")
+			} else {
+				f.write_str(" . ")?;
+				b.fmt(f)?;
+				f.write_str(")")
+			}
+		}
+
+		match self {
+			Value::Identifier(identifier) => f.write_str(identifier),
+			Value::Number(number) => write!(f, "{number}"),
+			Value::String(string) => write!(f, "\"{string}\""),
+			Value::Pair(a, b) => {
+				f.write_str("(")?;
+				fmt_pair(f, a.clone(), b.clone())
+			}
+			Value::RustFn(_) => f.write_str("builtin function"),
+			Value::DelshFn { .. } => f.write_str("function"),
+		}
+	}
+}
+
+impl Value {
+	pub fn identifier(&self) -> Option<&Arc<str>> {
+		if let Value::Identifier(identifier) = self {
+			Some(identifier)
+		} else {
+			None
+		}
+	}
+
+	pub fn number(&self) -> Option<&Decimal> {
+		if let Value::Number(number) = self {
+			Some(number)
+		} else {
+			None
+		}
+	}
+
+	pub fn string(&self) -> Option<&Arc<str>> {
+		if let Value::String(string) = self {
+			Some(string)
+		} else {
+			None
+		}
+	}
+
+	pub fn pair(&self) -> Option<(&Arc<Value>, &Arc<Value>)> {
+		if let Value::Pair(a, b) = self {
+			Some((a, b))
+		} else {
+			None
+		}
+	}
+
+	pub fn list(&self) -> Option<Vec<Arc<Value>>> {
+		let mut list = self;
+		let mut builder = Vec::new();
+		loop {
+			if let Value::Pair(head, rest) = &list {
+				builder.push(head.clone());
+				list = rest;
+			} else if list == &**NIL {
+				return Some(builder);
+			} else {
+				return None;
+			}
+		}
+	}
+
+	pub fn set(&self) -> Option<HashSet<Arc<Value>>> {
+		let mut head = self;
+		let mut builder = HashSet::new();
+		loop {
+			if let Value::Pair(car, cdr) = &head {
+				builder.insert(car.clone());
+				head = cdr;
+			} else if head == &**NIL {
+				return Some(builder);
+			} else {
+				return None;
+			}
+		}
+	}
+
+	pub fn rust_fn(&self) -> Option<&NativeFunction> {
+		if let Value::RustFn(func) = self {
+			Some(func)
+		} else {
+			None
+		}
+	}
+
+	pub fn is_function(&self) -> bool {
+		matches!(self, Value::RustFn(_) | Value::DelshFn { .. })
+	}
+}
+
+pub fn wrap_in_quote(value: Arc<Value>) -> Arc<Value> {
+	Arc::new(Value::Pair(
+		Arc::new(Value::Identifier("QUOTE".into())),
+		Arc::new(Value::Pair(value, NIL.clone())),
+	))
+}
+
+pub fn vec_to_value(list: &[Arc<Value>]) -> Arc<Value> {
+	if list.is_empty() {
+		NIL.clone()
+	} else if list.len() == 1 {
+		Arc::new(Value::Pair(list[0].clone(), NIL.clone()))
+	} else {
+		Arc::new(Value::Pair(list[0].clone(), vec_to_value(&list[1..])))
+	}
+}
+
+impl Interpreter {
+	pub fn new() -> Self {
+		Self {
+			stack: vec![HashMap::new()],
+		}
+	}
+
+	fn current_stack_frame_mut(&mut self) -> &mut HashMap<Arc<str>, Arc<Value>> {
+		self.stack
+			.last_mut()
+			.expect("there should always be at least one stack frame")
+	}
+
+	pub fn push_frame(&mut self) {
+		self.stack.push(HashMap::new());
+	}
+
+	pub fn pop_frame(&mut self) {
+		if self.stack.len() == 1 {
+			return;
+		}
+
+		self.stack.pop();
+	}
+
+	pub fn get_atom(&self, name: &str) -> Option<Arc<Value>> {
+		for frame in self.stack.iter().rev() {
+			if let Some(value) = frame.get(name) {
+				return Some(value.clone());
+			}
+		}
+
+		None
+	}
+
+	pub fn set_atom(&mut self, name: Arc<str>, value: Arc<Value>) {
+		self.current_stack_frame_mut()
+			.insert(name.to_uppercase().into(), value);
+	}
+
+	pub fn run_function(&mut self, function: &Value, arguments: &[Arc<Value>]) -> Arc<Value> {
+		match function {
+			Value::RustFn(func) => func(self, arguments),
+			Value::DelshFn { args, command } => {
+				self.push_frame();
+				for (name, value) in args.iter().zip(arguments) {
+					let value = self.eval(value.clone());
+					self.set_atom(name.clone(), value);
+				}
+
+				let return_value = self.eval(command.clone());
+				self.pop_frame();
+				return_value
+			}
+			_ => panic!("expected a function"),
+		}
+	}
+
+	pub fn eval(&mut self, value: Arc<Value>) -> Arc<Value> {
+		match &*value {
+			Value::Identifier(identifier) => {
+				self.get_atom(identifier).expect("a defined atom").clone()
+			}
+			Value::Pair(function, arguments) => {
+				let function = self.eval(function.clone());
+				let arguments = arguments.list().expect("arguments to be a list");
+				self.run_function(&function, &arguments)
+			}
+			_ => value,
+		}
+	}
+
+	fn ast_list_to_value(&mut self, list: &List) -> Arc<Value> {
+		let contains_dot = list.items.iter().any(|item| item.dot().is_some());
+		let mut head = (!contains_dot).then(|| NIL.clone());
+		for item in list.items.iter().rev() {
+			let Some(item) = item.expression() else {
+				continue;
+			};
+			let Some(head) = head.as_mut() else {
+				head = Some(self.ast_expression_value(item));
+				continue;
+			};
+
+			*head = Arc::new(Value::Pair(self.ast_expression_value(item), head.clone()));
+		}
+
+		head.unwrap_or_else(|| NIL.clone())
+	}
+
+	pub fn ast_expression_value(&mut self, expr: &Expression) -> Arc<Value> {
+		let suffix_value = match &expr.suffix {
+			ast::ExpressionSuffix::Nothing => NIL.clone(),
+			ast::ExpressionSuffix::Number { value, .. } => Arc::new(Value::Number(*value)),
+			ast::ExpressionSuffix::String { value, .. } => Arc::new(Value::String(value.clone())),
+			ast::ExpressionSuffix::Identifier { name, .. } => {
+				Arc::new(Value::Identifier(name.clone()))
+			}
+			ast::ExpressionSuffix::List(list) => self.ast_list_to_value(list),
+		};
+
+		if expr.is_quoted() {
+			wrap_in_quote(suffix_value)
+		} else {
+			suffix_value
+		}
+	}
+
+	pub fn run_ast_command(&mut self, command: &ast::Command) -> Arc<Value> {
+		match command {
+			ast::Command::Statement(statement) => {
+				let function_name = &statement.function_name;
+				let function = self
+					.get_atom(function_name)
+					.expect("expected a defined value")
+					.clone();
+				let arguments = statement
+					.args
+					.iter()
+					.map(|arg| self.ast_expression_value(arg))
+					.collect::<Box<_>>();
+
+				self.run_function(&function, &arguments)
+			}
+			ast::Command::Expression(expression) => {
+				let value = self.ast_expression_value(expression);
+				self.eval(value)
+			}
+			ast::Command::PanicMode(_) => NIL.clone(),
+		}
+	}
+}