2024-02-29 02:04:38 +00:00
|
|
|
use crate::{
|
|
|
|
error::{RuntimeError, ValidationError},
|
2024-03-25 04:16:55 +00:00
|
|
|
identifier::Identifier,
|
2024-03-18 09:39:09 +00:00
|
|
|
value::ValueInner,
|
|
|
|
Context, Value,
|
2024-02-29 02:04:38 +00:00
|
|
|
};
|
2024-02-25 18:49:26 +00:00
|
|
|
|
2024-03-25 04:16:55 +00:00
|
|
|
use super::{AbstractNode, Action, Statement, Type, WithPosition};
|
2024-02-25 18:49:26 +00:00
|
|
|
|
2024-02-25 19:26:22 +00:00
|
|
|
#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
|
2024-03-08 21:14:47 +00:00
|
|
|
pub struct Assignment {
|
2024-03-18 07:24:41 +00:00
|
|
|
identifier: WithPosition<Identifier>,
|
2024-03-17 11:31:45 +00:00
|
|
|
r#type: Option<WithPosition<Type>>,
|
2024-03-08 17:39:35 +00:00
|
|
|
operator: AssignmentOperator,
|
2024-03-25 04:16:55 +00:00
|
|
|
statement: Box<Statement>,
|
2024-02-25 18:49:26 +00:00
|
|
|
}
|
|
|
|
|
2024-03-08 17:39:35 +00:00
|
|
|
#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
|
|
|
|
pub enum AssignmentOperator {
|
|
|
|
Assign,
|
|
|
|
AddAssign,
|
|
|
|
SubAssign,
|
|
|
|
}
|
|
|
|
|
2024-03-08 21:14:47 +00:00
|
|
|
impl Assignment {
|
2024-03-08 17:39:35 +00:00
|
|
|
pub fn new(
|
2024-03-18 07:24:41 +00:00
|
|
|
identifier: WithPosition<Identifier>,
|
2024-03-17 11:31:45 +00:00
|
|
|
r#type: Option<WithPosition<Type>>,
|
2024-03-08 17:39:35 +00:00
|
|
|
operator: AssignmentOperator,
|
2024-03-25 04:16:55 +00:00
|
|
|
statement: Statement,
|
2024-03-08 17:39:35 +00:00
|
|
|
) -> Self {
|
2024-02-25 18:49:26 +00:00
|
|
|
Self {
|
|
|
|
identifier,
|
2024-02-29 02:04:38 +00:00
|
|
|
r#type,
|
2024-03-08 17:39:35 +00:00
|
|
|
operator,
|
2024-02-25 18:49:26 +00:00
|
|
|
statement: Box::new(statement),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-20 04:28:28 +00:00
|
|
|
impl AbstractNode for Assignment {
|
2024-04-22 12:25:20 +00:00
|
|
|
fn expected_type(&self, _context: &mut Context) -> Result<Type, ValidationError> {
|
2024-03-11 19:17:01 +00:00
|
|
|
Ok(Type::None)
|
2024-02-29 02:04:38 +00:00
|
|
|
}
|
|
|
|
|
2024-04-22 12:25:20 +00:00
|
|
|
fn validate(&self, context: &mut Context, manage_memory: bool) -> Result<(), ValidationError> {
|
2024-03-25 04:16:55 +00:00
|
|
|
let statement_type = self.statement.expected_type(context)?;
|
2024-03-17 04:49:01 +00:00
|
|
|
|
2024-03-17 11:31:45 +00:00
|
|
|
if let Some(WithPosition {
|
2024-04-22 07:41:21 +00:00
|
|
|
item: expected_type,
|
2024-03-17 04:49:01 +00:00
|
|
|
position: expected_position,
|
|
|
|
}) = &self.r#type
|
|
|
|
{
|
|
|
|
expected_type.check(&statement_type).map_err(|conflict| {
|
|
|
|
ValidationError::TypeCheck {
|
|
|
|
conflict,
|
2024-03-25 04:16:55 +00:00
|
|
|
actual_position: self.statement.position(),
|
2024-03-17 04:49:01 +00:00
|
|
|
expected_position: expected_position.clone(),
|
|
|
|
}
|
|
|
|
})?;
|
2024-03-06 23:15:25 +00:00
|
|
|
|
2024-04-22 07:41:21 +00:00
|
|
|
context.set_type(self.identifier.item.clone(), expected_type.clone())?;
|
2024-03-06 23:15:25 +00:00
|
|
|
} else {
|
2024-04-22 07:41:21 +00:00
|
|
|
context.set_type(self.identifier.item.clone(), statement_type)?;
|
2024-03-06 17:15:03 +00:00
|
|
|
}
|
|
|
|
|
2024-04-22 11:56:03 +00:00
|
|
|
self.statement.validate(context, manage_memory)?;
|
2024-03-11 18:49:44 +00:00
|
|
|
|
2024-03-06 17:15:03 +00:00
|
|
|
Ok(())
|
2024-02-29 02:04:38 +00:00
|
|
|
}
|
|
|
|
|
2024-04-22 11:56:03 +00:00
|
|
|
fn run(self, context: &mut Context, manage_memory: bool) -> Result<Action, RuntimeError> {
|
|
|
|
let action = self.statement.run(context, manage_memory)?;
|
2024-03-18 09:39:09 +00:00
|
|
|
let right = match action {
|
2024-03-08 17:24:11 +00:00
|
|
|
Action::Return(value) => value,
|
|
|
|
r#break => return Ok(r#break),
|
|
|
|
};
|
2024-02-25 18:49:26 +00:00
|
|
|
|
2024-03-08 18:26:55 +00:00
|
|
|
match self.operator {
|
|
|
|
AssignmentOperator::Assign => {
|
2024-04-22 07:41:21 +00:00
|
|
|
context.set_value(self.identifier.item, right)?;
|
2024-03-08 18:26:55 +00:00
|
|
|
}
|
|
|
|
AssignmentOperator::AddAssign => {
|
2024-04-22 11:56:03 +00:00
|
|
|
let left_option = if manage_memory {
|
|
|
|
context.use_value(&self.identifier.item)?
|
|
|
|
} else {
|
|
|
|
context.get_value(&self.identifier.item)?
|
|
|
|
};
|
|
|
|
|
|
|
|
if let Some(left) = left_option {
|
2024-03-18 09:39:09 +00:00
|
|
|
let new_value = match (left.inner().as_ref(), right.inner().as_ref()) {
|
|
|
|
(ValueInner::Integer(left), ValueInner::Integer(right)) => {
|
|
|
|
let sum = left.saturating_add(*right);
|
|
|
|
|
|
|
|
Value::integer(sum)
|
|
|
|
}
|
|
|
|
(ValueInner::Float(left), ValueInner::Float(right)) => {
|
|
|
|
let sum = left + right;
|
|
|
|
|
|
|
|
Value::float(sum)
|
|
|
|
}
|
|
|
|
(ValueInner::Float(left), ValueInner::Integer(right)) => {
|
|
|
|
let sum = left + *right as f64;
|
|
|
|
|
|
|
|
Value::float(sum)
|
|
|
|
}
|
|
|
|
(ValueInner::Integer(left), ValueInner::Float(right)) => {
|
|
|
|
let sum = *left as f64 + right;
|
|
|
|
|
|
|
|
Value::float(sum)
|
|
|
|
}
|
|
|
|
_ => {
|
|
|
|
return Err(RuntimeError::ValidationFailure(
|
|
|
|
ValidationError::ExpectedIntegerOrFloat(self.identifier.position),
|
|
|
|
))
|
|
|
|
}
|
|
|
|
};
|
2024-04-22 07:41:21 +00:00
|
|
|
context.set_value(self.identifier.item, new_value)?;
|
2024-03-08 18:26:55 +00:00
|
|
|
} else {
|
|
|
|
return Err(RuntimeError::ValidationFailure(
|
2024-03-25 04:16:55 +00:00
|
|
|
ValidationError::VariableNotFound {
|
2024-04-22 07:41:21 +00:00
|
|
|
identifier: self.identifier.item,
|
2024-03-25 04:16:55 +00:00
|
|
|
position: self.identifier.position,
|
|
|
|
},
|
2024-03-08 18:26:55 +00:00
|
|
|
));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
AssignmentOperator::SubAssign => {
|
2024-04-22 11:56:03 +00:00
|
|
|
let left_option = if manage_memory {
|
|
|
|
context.use_value(&self.identifier.item)?
|
|
|
|
} else {
|
|
|
|
context.get_value(&self.identifier.item)?
|
|
|
|
};
|
|
|
|
|
|
|
|
if let Some(left) = left_option {
|
2024-03-18 09:39:09 +00:00
|
|
|
let new_value = match (left.inner().as_ref(), right.inner().as_ref()) {
|
|
|
|
(ValueInner::Integer(left), ValueInner::Integer(right)) => {
|
|
|
|
let difference = left.saturating_sub(*right);
|
|
|
|
|
|
|
|
Value::integer(difference)
|
|
|
|
}
|
|
|
|
(ValueInner::Float(left), ValueInner::Float(right)) => {
|
|
|
|
let difference = left - right;
|
|
|
|
|
|
|
|
Value::float(difference)
|
|
|
|
}
|
|
|
|
(ValueInner::Float(left), ValueInner::Integer(right)) => {
|
|
|
|
let difference = left - *right as f64;
|
|
|
|
|
|
|
|
Value::float(difference)
|
|
|
|
}
|
|
|
|
(ValueInner::Integer(left), ValueInner::Float(right)) => {
|
|
|
|
let difference = *left as f64 - right;
|
|
|
|
|
|
|
|
Value::float(difference)
|
|
|
|
}
|
|
|
|
_ => {
|
|
|
|
return Err(RuntimeError::ValidationFailure(
|
|
|
|
ValidationError::ExpectedIntegerOrFloat(self.identifier.position),
|
|
|
|
))
|
|
|
|
}
|
|
|
|
};
|
2024-04-22 07:41:21 +00:00
|
|
|
context.set_value(self.identifier.item, new_value)?;
|
2024-03-08 18:26:55 +00:00
|
|
|
} else {
|
|
|
|
return Err(RuntimeError::ValidationFailure(
|
2024-03-25 04:16:55 +00:00
|
|
|
ValidationError::VariableNotFound {
|
2024-04-22 07:41:21 +00:00
|
|
|
identifier: self.identifier.item,
|
2024-03-25 04:16:55 +00:00
|
|
|
position: self.identifier.position,
|
|
|
|
},
|
2024-03-08 18:26:55 +00:00
|
|
|
));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2024-02-25 18:49:26 +00:00
|
|
|
|
2024-03-08 17:24:11 +00:00
|
|
|
Ok(Action::None)
|
2024-02-25 18:49:26 +00:00
|
|
|
}
|
|
|
|
}
|