From 906ab3a29514274fa9f689998d4cdda33e8ca6cd Mon Sep 17 00:00:00 2001 From: Stephen Chung Date: Thu, 9 Mar 2023 22:03:27 +0800 Subject: [PATCH] Add short-circuits to op-assignments. --- CHANGELOG.md | 1 + src/eval/stmt.rs | 122 ++++++++++++++++++++++++------ src/func/builtin.rs | 1 + src/func/call.rs | 180 ++++++++++++++++++++++---------------------- 4 files changed, 193 insertions(+), 111 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 643e1074..812cfa50 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,6 +14,7 @@ Bug fixes * Expressions such as `!inside` now parses correctly instead of as `!in` followed by `side`. * Custom syntax starting with symbols now works correctly and no longer raises a parse error. * Comparing different custom types now works correctly when the appropriate comparison operators are registered. +* Op-assignments to bit flags or bit ranges now work correctly. Potentially breaking changes ---------------------------- diff --git a/src/eval/stmt.rs b/src/eval/stmt.rs index 9a70177d..4846c9a7 100644 --- a/src/eval/stmt.rs +++ b/src/eval/stmt.rs @@ -7,6 +7,7 @@ use crate::ast::{ SwitchCasesCollection, }; use crate::func::{get_builtin_op_assignment_fn, get_hasher}; +use crate::tokenizer::Token; use crate::types::dynamic::{AccessMode, Union}; use crate::{Dynamic, Engine, RhaiResult, RhaiResultOf, Scope, ERR, INT}; use std::hash::{Hash, Hasher}; @@ -130,38 +131,117 @@ impl Engine { if let Some((hash_x, hash, op_x, op_x_str, op, op_str)) = op_info.get_op_assignment_info() { let mut lock_guard = target.write_lock::().unwrap(); - let args = &mut [&mut *lock_guard, &mut new_val]; + let mut done = false; + // Short-circuit built-in op-assignments if under Fast Operators mode if self.fast_operators() { - if let Some((func, need_context)) = - get_builtin_op_assignment_fn(op_x, args[0], args[1]) - { - // Built-in found - auto_restore! { let orig_level = global.level; global.level += 1 } + #[allow(clippy::wildcard_imports)] + use Token::*; - let context = need_context - .then(|| (self, op_x_str, global.source(), &*global, pos).into()); - return func(context, args).map(|_| ()); + done = true; + + // For extremely simple primary data operations, do it directly + // to avoid the overhead of calling a function. + match (&mut lock_guard.0, &mut new_val.0) { + (Union::Bool(b1, ..), Union::Bool(b2, ..)) => match op_x { + AndAssign => *b1 = *b1 && *b2, + OrAssign => *b1 = *b1 || *b2, + XOrAssign => *b1 = *b1 ^ *b2, + _ => done = false, + }, + (Union::Int(n1, ..), Union::Int(n2, ..)) => { + #[cfg(not(feature = "unchecked"))] + #[allow(clippy::wildcard_imports)] + use crate::packages::arithmetic::arith_basic::INT::functions::*; + + #[cfg(not(feature = "unchecked"))] + match op_x { + PlusAssign => { + *n1 = add(*n1, *n2).map_err(|err| err.fill_position(pos))? + } + MinusAssign => { + *n1 = subtract(*n1, *n2).map_err(|err| err.fill_position(pos))? + } + MultiplyAssign => { + *n1 = multiply(*n1, *n2).map_err(|err| err.fill_position(pos))? + } + DivideAssign => { + *n1 = divide(*n1, *n2).map_err(|err| err.fill_position(pos))? + } + ModuloAssign => { + *n1 = modulo(*n1, *n2).map_err(|err| err.fill_position(pos))? + } + _ => done = false, + } + #[cfg(feature = "unchecked")] + match op_x { + PlusAssign => *n1 += *n2, + MinusAssign => *n1 -= *n2, + MultiplyAssign => *n1 *= *n2, + DivideAssign => *n1 /= *n2, + ModuloAssign => *n1 %= *n2, + _ => done = false, + } + } + #[cfg(not(feature = "no_float"))] + (Union::Float(f1, ..), Union::Float(f2, ..)) => match op_x { + PlusAssign => **f1 += **f2, + MinusAssign => **f1 -= **f2, + MultiplyAssign => **f1 *= **f2, + DivideAssign => **f1 /= **f2, + ModuloAssign => **f1 %= **f2, + _ => done = false, + }, + #[cfg(not(feature = "no_float"))] + (Union::Float(f1, ..), Union::Int(n2, ..)) => match op_x { + PlusAssign => **f1 += *n2 as crate::FLOAT, + MinusAssign => **f1 -= *n2 as crate::FLOAT, + MultiplyAssign => **f1 *= *n2 as crate::FLOAT, + DivideAssign => **f1 /= *n2 as crate::FLOAT, + ModuloAssign => **f1 %= *n2 as crate::FLOAT, + _ => done = false, + }, + _ => done = false, + } + + if !done { + if let Some((func, need_context)) = + get_builtin_op_assignment_fn(op_x, &*lock_guard, &new_val) + { + // We may not need to bump the level because built-in's do not need it. + //auto_restore! { let orig_level = global.level; global.level += 1 } + + let args = &mut [&mut *lock_guard, &mut new_val]; + let context = need_context + .then(|| (self, op_x_str, global.source(), &*global, pos).into()); + let _ = func(context, args).map_err(|err| err.fill_position(pos))?; + done = true; + } } } - let opx = Some(op_x); + if !done { + let opx = Some(op_x); + let args = &mut [&mut *lock_guard, &mut new_val]; - match self.exec_native_fn_call(global, caches, op_x_str, opx, hash_x, args, true, pos) { - Ok(_) => (), - Err(err) if matches!(*err, ERR::ErrorFunctionNotFound(ref f, ..) if f.starts_with(op_x_str)) => + match self + .exec_native_fn_call(global, caches, op_x_str, opx, hash_x, args, true, pos) { - // Expand to `var = var op rhs` - let op = Some(op); + Ok(_) => (), + Err(err) if matches!(*err, ERR::ErrorFunctionNotFound(ref f, ..) if f.starts_with(op_x_str)) => + { + // Expand to `var = var op rhs` + let op = Some(op); - *args[0] = self - .exec_native_fn_call(global, caches, op_str, op, hash, args, true, pos)? - .0; + *args[0] = self + .exec_native_fn_call(global, caches, op_str, op, hash, args, true, pos)? + .0; + } + Err(err) => return Err(err), } - Err(err) => return Err(err), - } - self.check_data_size(&*args[0], root.position())?; + self.check_data_size(&*args[0], root.position())?; + } } else { // Normal assignment match target { diff --git a/src/func/builtin.rs b/src/func/builtin.rs index d6b2a9e5..50f757f5 100644 --- a/src/func/builtin.rs +++ b/src/func/builtin.rs @@ -684,6 +684,7 @@ pub fn get_builtin_op_assignment_fn(op: &Token, x: &Dynamic, y: &Dynamic) -> Opt return match op { AndAssign => impl_op!(bool = x && as_bool), OrAssign => impl_op!(bool = x || as_bool), + XOrAssign => impl_op!(bool = x ^ as_bool), _ => None, }; } diff --git a/src/func/call.rs b/src/func/call.rs index 5dc96184..079c095b 100644 --- a/src/func/call.rs +++ b/src/func/call.rs @@ -1547,6 +1547,9 @@ impl Engine { /// # Main Entry-Point (`FnCallExpr`) /// /// Evaluate a function call expression. + /// + /// This method tries to short-circuit function resolution under Fast Operators mode if the + /// function call is an operator. pub(crate) fn eval_fn_call_expr( &self, global: &mut GlobalRuntimeState, @@ -1570,28 +1573,29 @@ impl Engine { let op_token = op_token.as_ref(); // Short-circuit native unary operator call if under Fast Operators mode - if op_token == Some(&Token::Bang) && self.fast_operators() && args.len() == 1 { + if self.fast_operators() && args.len() == 1 && op_token == Some(&Token::Bang) { let mut value = self .get_arg_value(global, caches, scope, this_ptr.as_deref_mut(), &args[0])? .0 .flatten(); - match value.0 { - Union::Bool(b, ..) => return Ok((!b).into()), - _ => (), - } - - return value.as_bool().map(|r| (!r).into()).or_else(|_| { - let operand = &mut [&mut value]; - self.exec_fn_call( - global, caches, None, name, op_token, *hashes, operand, false, false, pos, - ) - .map(|(v, ..)| v) - }); + return match value.0 { + Union::Bool(b, ..) => Ok((!b).into()), + _ => { + let operand = &mut [&mut value]; + self.exec_fn_call( + global, caches, None, name, op_token, *hashes, operand, false, false, pos, + ) + .map(|(v, ..)| v) + } + }; } // Short-circuit native binary operator call if under Fast Operators mode if op_token.is_some() && self.fast_operators() && args.len() == 2 { + #[allow(clippy::wildcard_imports)] + use Token::*; + let mut lhs = self .get_arg_value(global, caches, scope, this_ptr.as_deref_mut(), &args[0])? .0 @@ -1606,23 +1610,19 @@ impl Engine { // to avoid the overhead of calling a function. match (&lhs.0, &rhs.0) { (Union::Unit(..), Union::Unit(..)) => match op_token.unwrap() { - Token::EqualsTo => return Ok(Dynamic::TRUE), - Token::NotEqualsTo - | Token::GreaterThan - | Token::GreaterThanEqualsTo - | Token::LessThan - | Token::LessThanEqualsTo => return Ok(Dynamic::FALSE), + EqualsTo => return Ok(Dynamic::TRUE), + NotEqualsTo | GreaterThan | GreaterThanEqualsTo | LessThan + | LessThanEqualsTo => return Ok(Dynamic::FALSE), _ => (), }, (Union::Bool(b1, ..), Union::Bool(b2, ..)) => match op_token.unwrap() { - Token::EqualsTo => return Ok((*b1 == *b2).into()), - Token::NotEqualsTo => return Ok((*b1 != *b2).into()), - Token::GreaterThan - | Token::GreaterThanEqualsTo - | Token::LessThan - | Token::LessThanEqualsTo => return Ok(Dynamic::FALSE), - Token::Pipe => return Ok((*b1 || *b2).into()), - Token::Ampersand => return Ok((*b1 && *b2).into()), + EqualsTo => return Ok((*b1 == *b2).into()), + NotEqualsTo => return Ok((*b1 != *b2).into()), + GreaterThan | GreaterThanEqualsTo | LessThan | LessThanEqualsTo => { + return Ok(Dynamic::FALSE) + } + Pipe => return Ok((*b1 || *b2).into()), + Ampersand => return Ok((*b1 && *b2).into()), _ => (), }, (Union::Int(n1, ..), Union::Int(n2, ..)) => { @@ -1632,87 +1632,87 @@ impl Engine { #[cfg(not(feature = "unchecked"))] match op_token.unwrap() { - Token::EqualsTo => return Ok((*n1 == *n2).into()), - Token::NotEqualsTo => return Ok((*n1 != *n2).into()), - Token::GreaterThan => return Ok((*n1 > *n2).into()), - Token::GreaterThanEqualsTo => return Ok((*n1 >= *n2).into()), - Token::LessThan => return Ok((*n1 < *n2).into()), - Token::LessThanEqualsTo => return Ok((*n1 <= *n2).into()), - Token::Plus => return add(*n1, *n2).map(Into::into), - Token::Minus => return subtract(*n1, *n2).map(Into::into), - Token::Multiply => return multiply(*n1, *n2).map(Into::into), - Token::Divide => return divide(*n1, *n2).map(Into::into), - Token::Modulo => return modulo(*n1, *n2).map(Into::into), + EqualsTo => return Ok((*n1 == *n2).into()), + NotEqualsTo => return Ok((*n1 != *n2).into()), + GreaterThan => return Ok((*n1 > *n2).into()), + GreaterThanEqualsTo => return Ok((*n1 >= *n2).into()), + LessThan => return Ok((*n1 < *n2).into()), + LessThanEqualsTo => return Ok((*n1 <= *n2).into()), + Plus => return add(*n1, *n2).map(Into::into), + Minus => return subtract(*n1, *n2).map(Into::into), + Multiply => return multiply(*n1, *n2).map(Into::into), + Divide => return divide(*n1, *n2).map(Into::into), + Modulo => return modulo(*n1, *n2).map(Into::into), _ => (), } #[cfg(feature = "unchecked")] match op_token.unwrap() { - Token::EqualsTo => return Ok((*n1 == *n2).into()), - Token::NotEqualsTo => return Ok((*n1 != *n2).into()), - Token::GreaterThan => return Ok((*n1 > *n2).into()), - Token::GreaterThanEqualsTo => return Ok((*n1 >= *n2).into()), - Token::LessThan => return Ok((*n1 < *n2).into()), - Token::LessThanEqualsTo => return Ok((*n1 <= *n2).into()), - Token::Plus => return Ok((*n1 + *n2).into()), - Token::Minus => return Ok((*n1 - *n2).into()), - Token::Multiply => return Ok((*n1 * *n2).into()), - Token::Divide => return Ok((*n1 / *n2).into()), - Token::Modulo => return Ok((*n1 % *n2).into()), + EqualsTo => return Ok((*n1 == *n2).into()), + NotEqualsTo => return Ok((*n1 != *n2).into()), + GreaterThan => return Ok((*n1 > *n2).into()), + GreaterThanEqualsTo => return Ok((*n1 >= *n2).into()), + LessThan => return Ok((*n1 < *n2).into()), + LessThanEqualsTo => return Ok((*n1 <= *n2).into()), + Plus => return Ok((*n1 + *n2).into()), + Minus => return Ok((*n1 - *n2).into()), + Multiply => return Ok((*n1 * *n2).into()), + Divide => return Ok((*n1 / *n2).into()), + Modulo => return Ok((*n1 % *n2).into()), _ => (), } } #[cfg(not(feature = "no_float"))] (Union::Float(f1, ..), Union::Float(f2, ..)) => match op_token.unwrap() { - Token::EqualsTo => return Ok((**f1 == **f2).into()), - Token::NotEqualsTo => return Ok((**f1 != **f2).into()), - Token::GreaterThan => return Ok((**f1 > **f2).into()), - Token::GreaterThanEqualsTo => return Ok((**f1 >= **f2).into()), - Token::LessThan => return Ok((**f1 < **f2).into()), - Token::LessThanEqualsTo => return Ok((**f1 <= **f2).into()), - Token::Plus => return Ok((**f1 + **f2).into()), - Token::Minus => return Ok((**f1 - **f2).into()), - Token::Multiply => return Ok((**f1 * **f2).into()), - Token::Divide => return Ok((**f1 / **f2).into()), - Token::Modulo => return Ok((**f1 % **f2).into()), + EqualsTo => return Ok((**f1 == **f2).into()), + NotEqualsTo => return Ok((**f1 != **f2).into()), + GreaterThan => return Ok((**f1 > **f2).into()), + GreaterThanEqualsTo => return Ok((**f1 >= **f2).into()), + LessThan => return Ok((**f1 < **f2).into()), + LessThanEqualsTo => return Ok((**f1 <= **f2).into()), + Plus => return Ok((**f1 + **f2).into()), + Minus => return Ok((**f1 - **f2).into()), + Multiply => return Ok((**f1 * **f2).into()), + Divide => return Ok((**f1 / **f2).into()), + Modulo => return Ok((**f1 % **f2).into()), _ => (), }, #[cfg(not(feature = "no_float"))] (Union::Float(f1, ..), Union::Int(n2, ..)) => match op_token.unwrap() { - Token::EqualsTo => return Ok((**f1 == (*n2 as crate::FLOAT)).into()), - Token::NotEqualsTo => return Ok((**f1 != (*n2 as crate::FLOAT)).into()), - Token::GreaterThan => return Ok((**f1 > (*n2 as crate::FLOAT)).into()), - Token::GreaterThanEqualsTo => return Ok((**f1 >= (*n2 as crate::FLOAT)).into()), - Token::LessThan => return Ok((**f1 < (*n2 as crate::FLOAT)).into()), - Token::LessThanEqualsTo => return Ok((**f1 <= (*n2 as crate::FLOAT)).into()), - Token::Plus => return Ok((**f1 + (*n2 as crate::FLOAT)).into()), - Token::Minus => return Ok((**f1 - (*n2 as crate::FLOAT)).into()), - Token::Multiply => return Ok((**f1 * (*n2 as crate::FLOAT)).into()), - Token::Divide => return Ok((**f1 / (*n2 as crate::FLOAT)).into()), - Token::Modulo => return Ok((**f1 % (*n2 as crate::FLOAT)).into()), + EqualsTo => return Ok((**f1 == (*n2 as crate::FLOAT)).into()), + NotEqualsTo => return Ok((**f1 != (*n2 as crate::FLOAT)).into()), + GreaterThan => return Ok((**f1 > (*n2 as crate::FLOAT)).into()), + GreaterThanEqualsTo => return Ok((**f1 >= (*n2 as crate::FLOAT)).into()), + LessThan => return Ok((**f1 < (*n2 as crate::FLOAT)).into()), + LessThanEqualsTo => return Ok((**f1 <= (*n2 as crate::FLOAT)).into()), + Plus => return Ok((**f1 + (*n2 as crate::FLOAT)).into()), + Minus => return Ok((**f1 - (*n2 as crate::FLOAT)).into()), + Multiply => return Ok((**f1 * (*n2 as crate::FLOAT)).into()), + Divide => return Ok((**f1 / (*n2 as crate::FLOAT)).into()), + Modulo => return Ok((**f1 % (*n2 as crate::FLOAT)).into()), _ => (), }, #[cfg(not(feature = "no_float"))] (Union::Int(n1, ..), Union::Float(f2, ..)) => match op_token.unwrap() { - Token::EqualsTo => return Ok(((*n1 as crate::FLOAT) == **f2).into()), - Token::NotEqualsTo => return Ok(((*n1 as crate::FLOAT) != **f2).into()), - Token::GreaterThan => return Ok(((*n1 as crate::FLOAT) > **f2).into()), - Token::GreaterThanEqualsTo => return Ok(((*n1 as crate::FLOAT) >= **f2).into()), - Token::LessThan => return Ok(((*n1 as crate::FLOAT) < **f2).into()), - Token::LessThanEqualsTo => return Ok(((*n1 as crate::FLOAT) <= **f2).into()), - Token::Plus => return Ok(((*n1 as crate::FLOAT) + **f2).into()), - Token::Minus => return Ok(((*n1 as crate::FLOAT) - **f2).into()), - Token::Multiply => return Ok(((*n1 as crate::FLOAT) * **f2).into()), - Token::Divide => return Ok(((*n1 as crate::FLOAT) / **f2).into()), - Token::Modulo => return Ok(((*n1 as crate::FLOAT) % **f2).into()), + EqualsTo => return Ok(((*n1 as crate::FLOAT) == **f2).into()), + NotEqualsTo => return Ok(((*n1 as crate::FLOAT) != **f2).into()), + GreaterThan => return Ok(((*n1 as crate::FLOAT) > **f2).into()), + GreaterThanEqualsTo => return Ok(((*n1 as crate::FLOAT) >= **f2).into()), + LessThan => return Ok(((*n1 as crate::FLOAT) < **f2).into()), + LessThanEqualsTo => return Ok(((*n1 as crate::FLOAT) <= **f2).into()), + Plus => return Ok(((*n1 as crate::FLOAT) + **f2).into()), + Minus => return Ok(((*n1 as crate::FLOAT) - **f2).into()), + Multiply => return Ok(((*n1 as crate::FLOAT) * **f2).into()), + Divide => return Ok(((*n1 as crate::FLOAT) / **f2).into()), + Modulo => return Ok(((*n1 as crate::FLOAT) % **f2).into()), _ => (), }, (Union::Str(s1, ..), Union::Str(s2, ..)) => match op_token.unwrap() { - Token::EqualsTo => return Ok((s1 == s2).into()), - Token::NotEqualsTo => return Ok((s1 != s2).into()), - Token::GreaterThan => return Ok((s1 > s2).into()), - Token::GreaterThanEqualsTo => return Ok((s1 >= s2).into()), - Token::LessThan => return Ok((s1 < s2).into()), - Token::LessThanEqualsTo => return Ok((s1 <= s2).into()), + EqualsTo => return Ok((s1 == s2).into()), + NotEqualsTo => return Ok((s1 != s2).into()), + GreaterThan => return Ok((s1 > s2).into()), + GreaterThanEqualsTo => return Ok((s1 >= s2).into()), + LessThan => return Ok((s1 < s2).into()), + LessThanEqualsTo => return Ok((s1 <= s2).into()), _ => (), }, _ => (), @@ -1723,8 +1723,8 @@ impl Engine { if let Some((func, need_context)) = get_builtin_binary_op_fn(op_token.as_ref().unwrap(), operands[0], operands[1]) { - // Built-in found - auto_restore! { let orig_level = global.level; global.level += 1 } + // We may not need to bump the level because built-in's do not need it. + //auto_restore! { let orig_level = global.level; global.level += 1 } let context = need_context.then(|| (self, name.as_str(), None, &*global, pos).into());