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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use std::{borrow::Borrow, cell::RefCell, rc::Rc};

use crate::{
	data::Data,
	error::{BeanResult, Error, ErrorSource},
	parser::{Node, PosNode},
	scope::{block_scope::BlockScope, function::Function, ScopeRef},
};

pub fn evaluate_verbose(
	pos_node: &PosNode,
	scope_ref: ScopeRef,
	return_scope: bool,
	access_scope_ref: Option<ScopeRef>,
) -> Result<Data, Error> {
	let scope = RefCell::borrow(&scope_ref);

	match &pos_node.node {
		Node::FnCall {
			name,
			parameters,
			body_fn,
		} => {
			let function = scope.get_function(&name).ok_or_else(|| {
				Error::new(
					&format!("Unknown value or function {}.", name),
					ErrorSource::Line(pos_node.ln),
				)
			})?;
			drop(scope);

			let mut args: Vec<Data> = Vec::new();
			for n in parameters {
				args.push(evaluate(
					n,
					Rc::clone(access_scope_ref.as_ref().unwrap_or(&scope_ref)),
				)?);
			}

			let return_value = function
				.call_from(
					args,
					if let Some(body) = body_fn {
						Some(Function::Custom {
							body: Rc::new(*body.clone()),
							scope_ref: Rc::clone(
								access_scope_ref.as_ref().unwrap_or(&scope_ref),
							),
						})
					} else {
						None
					},
					Rc::clone(&scope_ref),
					access_scope_ref,
				)
				.trace(ErrorSource::Line(pos_node.ln));

			return return_value;
		}
		Node::Scope { body } => {
			let scope = BlockScope::new(Some(Rc::clone(&scope_ref)));
			let scope_ref = Rc::new(RefCell::new(scope));

			for n in body {
				evaluate(n, Rc::clone(&scope_ref) as ScopeRef)?;
				if RefCell::borrow(&scope_ref).did_break() {
					break;
				}
			}

			let scope: &RefCell<BlockScope> = scope_ref.borrow();
			let return_value = scope.borrow().return_value.clone();
			return if return_scope {
				Ok(Data::Scope(scope_ref))
			} else {
				Ok(return_value)
			};
		}
		Node::ParameterBlock { body } => {
			drop(scope);
			let mut return_value: Data = Data::None;
			for n in body {
				return_value = evaluate(n, Rc::clone(&scope_ref))?;
			}

			return Ok(return_value);
		}
		Node::Program { body } => {
			drop(scope);
			for n in body {
				evaluate(n, Rc::clone(&scope_ref))?;
			}
			return Ok(Data::None);
		}
		Node::FnAccess { target, call } => {
			let target = evaluate(target, Rc::clone(&scope_ref))?;

			if let Data::Scope(target_scope) = target {
				drop(scope);
				evaluate_verbose(
					&call,
					Rc::clone(&target_scope),
					false,
					Some(Rc::clone(&scope_ref)),
				)
			} else {
				return Err(Error::new(
					&format!(
						"Expected scope for dot operator, but got {}.",
						target.get_type().to_string()
					),
					ErrorSource::Line(pos_node.ln),
				));
			}
		}
		Node::Boolean(v) => Ok(Data::Boolean(*v)),
		Node::Number(v) => Ok(Data::Number(*v)),
		Node::String(v) => Ok(Data::String(v.clone())),
		Node::Name(name) => Ok(Data::Name {
			scope: Rc::clone(&scope_ref),
			name: name.clone(),
		}),
		Node::None => Ok(Data::None),
	}
}

pub fn evaluate(node: &PosNode, scope_ref: ScopeRef) -> Result<Data, Error> {
	evaluate_verbose(node, scope_ref, false, None)
}