From 60891e694f480e7c62f7a6d06749958503ceaa3b Mon Sep 17 00:00:00 2001 From: Stephen Chung Date: Fri, 31 Jul 2020 22:30:23 +0800 Subject: [PATCH] Streamline code and feature gates. --- src/any.rs | 17 ++- src/api.rs | 19 ++-- src/engine.rs | 69 +++++++----- src/fn_call.rs | 125 ++++++++++----------- src/optimize.rs | 23 ++-- src/packages/arithmetic.rs | 210 +++++++++++++---------------------- src/packages/array_basic.rs | 8 +- src/packages/iter_basic.rs | 18 ++- src/packages/logic.rs | 7 +- src/packages/map_basic.rs | 19 ++-- src/packages/math_basic.rs | 35 +++--- src/packages/string_basic.rs | 7 +- src/packages/string_more.rs | 7 +- src/parser.rs | 67 ++++++----- src/scope.rs | 55 ++++++++- src/token.rs | 4 +- 16 files changed, 337 insertions(+), 353 deletions(-) diff --git a/src/any.rs b/src/any.rs index 520bad0d..a8ee1e66 100644 --- a/src/any.rs +++ b/src/any.rs @@ -270,9 +270,9 @@ impl Dynamic { /// Does this `Dynamic` hold a shared data type /// instead of one of the support system primitive types? - #[cfg(not(feature = "no_shared"))] pub fn is_shared(&self) -> bool { match self.0 { + #[cfg(not(feature = "no_shared"))] Union::Shared(_) => true, _ => false, } @@ -440,7 +440,7 @@ impl Clone for Dynamic { Union::FnPtr(ref value) => Self(Union::FnPtr(value.clone())), Union::Variant(ref value) => (***value).clone_into_dynamic(), #[cfg(not(feature = "no_shared"))] - Union::Shared(ref cell) => Self(Union::Shared(Box::new((**cell).clone()))), + Union::Shared(ref cell) => Self(Union::Shared(cell.clone())), } } } @@ -561,9 +561,13 @@ impl Dynamic { /// Shared `Dynamic` values can be converted seamlessly to and from ordinary `Dynamic` values. /// /// If the `Dynamic` value is already shared, this method returns itself. - #[cfg(not(feature = "no_shared"))] + /// + /// # Panics + /// + /// Panics under the `no_shared` feature. pub fn into_shared(self) -> Self { - match self.0 { + #[cfg(not(feature = "no_shared"))] + return match self.0 { Union::Shared(..) => self, _ => Self(Union::Shared(Box::new(SharedCell { value_type_id: self.type_id(), @@ -574,7 +578,10 @@ impl Dynamic { #[cfg(feature = "sync")] container: Arc::new(RwLock::new(self)), }))), - } + }; + + #[cfg(feature = "no_shared")] + unimplemented!() } /// Convert the `Dynamic` value into specific type. diff --git a/src/api.rs b/src/api.rs index 42ff7037..e6e9ea7a 100644 --- a/src/api.rs +++ b/src/api.rs @@ -1305,16 +1305,15 @@ impl Engine { mut ast: AST, optimization_level: OptimizationLevel, ) -> AST { - #[cfg(not(feature = "no_function"))] - let lib = ast - .lib() - .iter_fn() - .filter(|(_, _, _, f)| f.is_script()) - .map(|(_, _, _, f)| f.get_fn_def().clone()) - .collect(); - - #[cfg(feature = "no_function")] - let lib = Default::default(); + let lib = if cfg!(not(feature = "no_function")) { + ast.lib() + .iter_fn() + .filter(|(_, _, _, f)| f.is_script()) + .map(|(_, _, _, f)| f.get_fn_def().clone()) + .collect() + } else { + Default::default() + }; let stmt = mem::take(ast.statements_mut()); optimize_into_ast(self, scope, stmt, lib, optimization_level) diff --git a/src/engine.rs b/src/engine.rs index bd778e4e..cdd9c040 100644 --- a/src/engine.rs +++ b/src/engine.rs @@ -32,6 +32,7 @@ use crate::module::resolvers; use crate::utils::ImmutableString; #[cfg(not(feature = "no_shared"))] +#[cfg(not(feature = "no_object"))] use crate::any::DynamicWriteLock; use crate::stdlib::{ @@ -44,12 +45,13 @@ use crate::stdlib::{ vec::Vec, }; +#[cfg(not(feature = "no_shared"))] +#[cfg(not(feature = "no_object"))] +use crate::stdlib::ops::DerefMut; + #[cfg(not(feature = "no_index"))] use crate::stdlib::any::TypeId; -#[cfg(not(feature = "no_shared"))] -use crate::stdlib::ops::DerefMut; - /// Variable-sized array of `Dynamic` values. /// /// Not available under the `no_index` feature. @@ -134,6 +136,7 @@ pub enum Target<'a> { /// The target is a mutable reference to a Shared `Dynamic` value. /// It holds both the access guard and the original shared value. #[cfg(not(feature = "no_shared"))] + #[cfg(not(feature = "no_object"))] LockGuard((DynamicWriteLock<'a, Dynamic>, Dynamic)), /// The target is a temporary `Dynamic` value (i.e. the mutation can cause no side effects). Value(Dynamic), @@ -150,6 +153,7 @@ impl Target<'_> { match self { Self::Ref(_) => true, #[cfg(not(feature = "no_shared"))] + #[cfg(not(feature = "no_object"))] Self::LockGuard(_) => true, Self::Value(_) => false, #[cfg(not(feature = "no_index"))] @@ -161,18 +165,32 @@ impl Target<'_> { match self { Self::Ref(_) => false, #[cfg(not(feature = "no_shared"))] + #[cfg(not(feature = "no_object"))] Self::LockGuard(_) => false, Self::Value(_) => true, #[cfg(not(feature = "no_index"))] Self::StringChar(_, _, _) => false, } } + /// Is the `Target` a shared value? + pub fn is_shared(&self) -> bool { + match self { + Self::Ref(r) => r.is_shared(), + #[cfg(not(feature = "no_shared"))] + #[cfg(not(feature = "no_object"))] + Self::LockGuard(_) => true, + Self::Value(r) => r.is_shared(), + #[cfg(not(feature = "no_index"))] + Self::StringChar(_, _, _) => false, + } + } /// Is the `Target` a specific type? #[allow(dead_code)] pub fn is(&self) -> bool { match self { Target::Ref(r) => r.is::(), #[cfg(not(feature = "no_shared"))] + #[cfg(not(feature = "no_object"))] Target::LockGuard((r, _)) => r.is::(), Target::Value(r) => r.is::(), #[cfg(not(feature = "no_index"))] @@ -184,6 +202,7 @@ impl Target<'_> { match self { Self::Ref(r) => r.clone(), // Referenced value is cloned #[cfg(not(feature = "no_shared"))] + #[cfg(not(feature = "no_object"))] Self::LockGuard((_, orig)) => orig, // Original value is simply taken Self::Value(v) => v, // Owned value is simply taken #[cfg(not(feature = "no_index"))] @@ -195,6 +214,7 @@ impl Target<'_> { match self { Self::Ref(r) => *r, #[cfg(not(feature = "no_shared"))] + #[cfg(not(feature = "no_object"))] Self::LockGuard((r, _)) => r.deref_mut(), Self::Value(ref mut r) => r, #[cfg(not(feature = "no_index"))] @@ -207,6 +227,7 @@ impl Target<'_> { match self { Self::Ref(r) => **r = new_val, #[cfg(not(feature = "no_shared"))] + #[cfg(not(feature = "no_object"))] Self::LockGuard((r, _)) => **r = new_val, Self::Value(_) => { return Err(Box::new(EvalAltResult::ErrorAssignmentToUnknownLHS( @@ -243,6 +264,7 @@ impl Target<'_> { impl<'a> From<&'a mut Dynamic> for Target<'a> { fn from(value: &'a mut Dynamic) -> Self { #[cfg(not(feature = "no_shared"))] + #[cfg(not(feature = "no_object"))] if value.is_shared() { // Cloning is cheap for a shared value let container = value.clone(); @@ -427,11 +449,11 @@ impl Default for Engine { progress: None, // optimization level - #[cfg(feature = "no_optimize")] - optimization_level: OptimizationLevel::None, - - #[cfg(not(feature = "no_optimize"))] - optimization_level: OptimizationLevel::Simple, + optimization_level: if cfg!(feature = "no_optimize") { + OptimizationLevel::None + } else { + OptimizationLevel::Simple + }, #[cfg(not(feature = "unchecked"))] limits: Limits { @@ -639,11 +661,11 @@ impl Engine { debug: Box::new(|_| {}), progress: None, - #[cfg(feature = "no_optimize")] - optimization_level: OptimizationLevel::None, - - #[cfg(not(feature = "no_optimize"))] - optimization_level: OptimizationLevel::Simple, + optimization_level: if cfg!(feature = "no_optimize") { + OptimizationLevel::None + } else { + OptimizationLevel::Simple + }, #[cfg(not(feature = "unchecked"))] limits: Limits { @@ -1340,16 +1362,11 @@ impl Engine { )), // Normal assignment ScopeEntryType::Normal if op.is_empty() => { - #[cfg(not(feature = "no_shared"))] - if lhs_ptr.is_shared() { + if cfg!(not(feature = "no_shared")) && lhs_ptr.is_shared() { *lhs_ptr.write_lock::().unwrap() = rhs_val; } else { *lhs_ptr = rhs_val; } - #[cfg(feature = "no_shared")] - { - *lhs_ptr = rhs_val; - } Ok(Default::default()) } // Op-assignment - in order of precedence: @@ -1394,16 +1411,11 @@ impl Engine { ) .map_err(|err| err.new_position(*op_pos))?; - #[cfg(not(feature = "no_shared"))] - if lhs_ptr.is_shared() { + if cfg!(not(feature = "no_shared")) && lhs_ptr.is_shared() { *lhs_ptr.write_lock::().unwrap() = value; } else { *lhs_ptr = value; } - #[cfg(feature = "no_shared")] - { - *lhs_ptr = value; - } } Ok(Default::default()) } @@ -1845,13 +1857,15 @@ impl Engine { .map_err(|err| err.new_position(stmt.position())) } + /// Check a result to ensure that the data size is within allowable limit. + /// Position in `EvalAltResult` may be None and should be set afterwards. #[cfg(feature = "unchecked")] #[inline(always)] fn check_data_size( &self, result: Result>, ) -> Result> { - return result; + result } /// Check a result to ensure that the data size is within allowable limit. @@ -1861,9 +1875,6 @@ impl Engine { &self, result: Result>, ) -> Result> { - #[cfg(feature = "unchecked")] - return result; - // If no data size limits, just return if self.limits.max_string_size + self.limits.max_array_size + self.limits.max_map_size == 0 { diff --git a/src/fn_call.rs b/src/fn_call.rs index d680800a..cbddcff3 100644 --- a/src/fn_call.rs +++ b/src/fn_call.rs @@ -20,9 +20,8 @@ use crate::utils::StaticVec; #[cfg(not(feature = "no_function"))] use crate::{ - parser::ScriptFnDef, - r#unsafe::unsafe_cast_var_name_to_lifetime, - scope::{Entry as ScopeEntry, EntryType as ScopeEntryType}, + parser::ScriptFnDef, r#unsafe::unsafe_cast_var_name_to_lifetime, + scope::EntryType as ScopeEntryType, }; #[cfg(not(feature = "no_float"))] @@ -34,18 +33,23 @@ use crate::engine::{FN_IDX_GET, FN_IDX_SET}; #[cfg(not(feature = "no_object"))] use crate::engine::{Map, Target, FN_GET, FN_SET}; +#[cfg(not(feature = "no_capture"))] +use crate::scope::Entry as ScopeEntry; + use crate::stdlib::{ any::{type_name, TypeId}, boxed::Box, - collections::HashSet, convert::TryFrom, format, iter::{empty, once}, mem, - string::{String, ToString}, + string::ToString, vec::Vec, }; +#[cfg(not(feature = "no_capture"))] +use crate::stdlib::{collections::HashSet, string::String}; + /// Extract the property name from a getter function name. #[inline(always)] fn extract_prop_from_getter(_fn_name: &str) -> Option<&str> { @@ -422,7 +426,7 @@ impl Engine { is_ref: bool, is_method: bool, pub_only: bool, - capture: Option, + _capture: Option, def_val: Option, level: usize, ) -> Result<(Dynamic, bool), Box> { @@ -451,12 +455,6 @@ impl Engine { ))) } - // Fn - KEYWORD_IS_SHARED if args.len() == 1 => Err(Box::new(EvalAltResult::ErrorRuntime( - "'is_shared' should not be called in method style. Try is_shared(...);".into(), - Position::none(), - ))), - // eval - reaching this point it must be a method-style call KEYWORD_EVAL if args.len() == 1 && !self.has_override(lib, hash_fn, hash_script, pub_only) => @@ -478,7 +476,7 @@ impl Engine { // Add captured variables into scope #[cfg(not(feature = "no_capture"))] - if let Some(captured) = capture { + if let Some(captured) = _capture { add_captured_variables_into_scope(&func.externals, captured, scope); } @@ -662,22 +660,18 @@ impl Engine { .into(), false, )) - } else if _fn_name == KEYWORD_SHARED && idx.is_empty() { + } else if cfg!(not(feature = "no_shared")) + && _fn_name == KEYWORD_IS_SHARED + && idx.is_empty() + { // take call - #[cfg(not(feature = "no_shared"))] - { - Ok((obj.clone().into_shared(), false)) - } - #[cfg(feature = "no_shared")] - unreachable!() - } else if _fn_name == KEYWORD_TAKE && idx.is_empty() { + Ok((target.is_shared().into(), false)) + } else if cfg!(not(feature = "no_shared")) && _fn_name == KEYWORD_SHARED && idx.is_empty() { // take call - #[cfg(not(feature = "no_shared"))] - { - Ok((obj.clone_inner_data::().unwrap(), false)) - } - #[cfg(feature = "no_shared")] - unreachable!() + Ok((obj.clone().into_shared(), false)) + } else if cfg!(not(feature = "no_shared")) && _fn_name == KEYWORD_TAKE && idx.is_empty() { + // take call + Ok((obj.clone_inner_data::().unwrap(), false)) } else { #[cfg(not(feature = "no_object"))] let redirected; @@ -790,8 +784,7 @@ impl Engine { } // Handle is_shared() - #[cfg(not(feature = "no_shared"))] - if name == KEYWORD_IS_SHARED && args_expr.len() == 1 { + if cfg!(not(feature = "no_shared")) && name == KEYWORD_IS_SHARED && args_expr.len() == 1 { let expr = args_expr.get(0).unwrap(); let value = self.eval_expr(scope, mods, state, lib, this_ptr, expr, level)?; @@ -799,8 +792,7 @@ impl Engine { } // Handle shared() - #[cfg(not(feature = "no_shared"))] - if name == KEYWORD_SHARED && args_expr.len() == 1 { + if cfg!(not(feature = "no_shared")) && name == KEYWORD_SHARED && args_expr.len() == 1 { let expr = args_expr.get(0).unwrap(); let value = self.eval_expr(scope, mods, state, lib, this_ptr, expr, level)?; @@ -808,8 +800,7 @@ impl Engine { } // Handle take() - #[cfg(not(feature = "no_shared"))] - if name == KEYWORD_TAKE && args_expr.len() == 1 { + if cfg!(not(feature = "no_shared")) && name == KEYWORD_TAKE && args_expr.len() == 1 { let expr = args_expr.get(0).unwrap(); let value = self.eval_expr(scope, mods, state, lib, this_ptr, expr, level)?; @@ -875,7 +866,7 @@ impl Engine { let mut arg_values: StaticVec<_>; let mut args: StaticVec<_>; let mut is_ref = false; - let capture = if capture && !scope.is_empty() { + let capture = if cfg!(not(feature = "no_capture")) && capture && !scope.is_empty() { Some(scope.flatten_clone()) } else { None @@ -943,18 +934,10 @@ impl Engine { args_expr: &[Expr], def_val: Option, hash_script: u64, - capture: bool, + _capture: bool, level: usize, ) -> Result> { let modules = modules.as_ref().unwrap(); - - #[cfg(not(feature = "no_capture"))] - let capture = if capture && !scope.is_empty() { - Some(scope.flatten_clone()) - } else { - None - }; - let mut arg_values: StaticVec<_>; let mut args: StaticVec<_>; @@ -1027,8 +1010,12 @@ impl Engine { // Add captured variables into scope #[cfg(not(feature = "no_capture"))] - if let Some(captured) = capture { - add_captured_variables_into_scope(&func.externals, captured, scope); + if _capture && !scope.is_empty() { + add_captured_variables_into_scope( + &func.externals, + scope.flatten_clone(), + scope, + ); } self.call_script_fn(scope, mods, state, lib, &mut None, name, func, args, level) @@ -1073,30 +1060,30 @@ pub fn run_builtin_binary_op( let x = x.clone().cast::(); let y = y.clone().cast::(); - #[cfg(not(feature = "unchecked"))] - match op { - "+" => return add(x, y).map(Into::into).map(Some), - "-" => return sub(x, y).map(Into::into).map(Some), - "*" => return mul(x, y).map(Into::into).map(Some), - "/" => return div(x, y).map(Into::into).map(Some), - "%" => return modulo(x, y).map(Into::into).map(Some), - "~" => return pow_i_i(x, y).map(Into::into).map(Some), - ">>" => return shr(x, y).map(Into::into).map(Some), - "<<" => return shl(x, y).map(Into::into).map(Some), - _ => (), - } - - #[cfg(feature = "unchecked")] - match op { - "+" => return Ok(Some((x + y).into())), - "-" => return Ok(Some((x - y).into())), - "*" => return Ok(Some((x * y).into())), - "/" => return Ok(Some((x / y).into())), - "%" => return Ok(Some((x % y).into())), - "~" => return pow_i_i_u(x, y).map(Into::into).map(Some), - ">>" => return shr_u(x, y).map(Into::into).map(Some), - "<<" => return shl_u(x, y).map(Into::into).map(Some), - _ => (), + if cfg!(not(feature = "unchecked")) { + match op { + "+" => return add(x, y).map(Into::into).map(Some), + "-" => return sub(x, y).map(Into::into).map(Some), + "*" => return mul(x, y).map(Into::into).map(Some), + "/" => return div(x, y).map(Into::into).map(Some), + "%" => return modulo(x, y).map(Into::into).map(Some), + "~" => return pow_i_i(x, y).map(Into::into).map(Some), + ">>" => return shr(x, y).map(Into::into).map(Some), + "<<" => return shl(x, y).map(Into::into).map(Some), + _ => (), + } + } else { + match op { + "+" => return Ok(Some((x + y).into())), + "-" => return Ok(Some((x - y).into())), + "*" => return Ok(Some((x * y).into())), + "/" => return Ok(Some((x / y).into())), + "%" => return Ok(Some((x % y).into())), + "~" => return pow_i_i_u(x, y).map(Into::into).map(Some), + ">>" => return shr_u(x, y).map(Into::into).map(Some), + "<<" => return shl_u(x, y).map(Into::into).map(Some), + _ => (), + } } match op { diff --git a/src/optimize.rs b/src/optimize.rs index 3244540b..9072a550 100644 --- a/src/optimize.rs +++ b/src/optimize.rs @@ -576,17 +576,13 @@ fn optimize_expr(expr: Expr, state: &mut State) -> Expr { // First search in functions lib (can override built-in) // Cater for both normal function call style and method call style (one additional arguments) - #[cfg(not(feature = "no_function"))] - let _has_script_fn = state.lib.iter_fn().find(|(_, _, _, f)| { + let has_script_fn = cfg!(not(feature = "no_function")) && state.lib.iter_fn().find(|(_, _, _, f)| { if !f.is_script() { return false; } let fn_def = f.get_fn_def(); fn_def.name == name && (args.len()..=args.len() + 1).contains(&fn_def.params.len()) }).is_some(); - #[cfg(feature = "no_function")] - let _has_script_fn: bool = false; - - if _has_script_fn { + if has_script_fn { // A script-defined function overrides the built-in function - do not make the call x.3 = x.3.into_iter().map(|a| optimize_expr(a, state)).collect(); return Expr::FnCall(x); @@ -748,11 +744,13 @@ pub fn optimize_into_ast( _functions: Vec, level: OptimizationLevel, ) -> AST { - #[cfg(feature = "no_optimize")] - const level: OptimizationLevel = OptimizationLevel::None; + let level = if cfg!(feature = "no_optimize") { + OptimizationLevel::None + } else { + level + }; - #[cfg(not(feature = "no_function"))] - let lib = { + let lib = if cfg!(not(feature = "no_function")) { let mut module = Module::new(); if !level.is_none() { @@ -814,11 +812,10 @@ pub fn optimize_into_ast( } module + } else { + Default::default() }; - #[cfg(feature = "no_function")] - let lib = Default::default(); - AST::new( match level { OptimizationLevel::None => statements, diff --git a/src/packages/arithmetic.rs b/src/packages/arithmetic.rs index fd95e675..d8e256cc 100644 --- a/src/packages/arithmetic.rs +++ b/src/packages/arithmetic.rs @@ -2,38 +2,29 @@ use crate::def_package; use crate::module::FuncReturn; use crate::parser::INT; -#[cfg(not(feature = "unchecked"))] use crate::{result::EvalAltResult, token::Position}; #[cfg(not(feature = "no_float"))] use crate::parser::FLOAT; -#[cfg(not(feature = "no_float"))] -#[cfg(feature = "no_std")] -use num_traits::*; - -#[cfg(not(feature = "unchecked"))] use num_traits::{ identities::Zero, CheckedAdd, CheckedDiv, CheckedMul, CheckedNeg, CheckedRem, CheckedShl, CheckedShr, CheckedSub, }; -#[cfg(not(feature = "only_i32"))] -#[cfg(not(feature = "only_i64"))] -use crate::stdlib::ops::{BitAnd, BitOr, BitXor}; +#[cfg(feature = "no_std")] +#[cfg(not(feature = "no_float"))] +use num_traits::float::Float; -#[cfg(any(feature = "unchecked", not(feature = "no_float")))] -use crate::stdlib::ops::{Add, Div, Mul, Neg, Rem, Sub}; - -#[cfg(feature = "unchecked")] -use crate::stdlib::ops::{Shl, Shr}; - -#[cfg(not(feature = "unchecked"))] -use crate::stdlib::{boxed::Box, fmt::Display, format}; +use crate::stdlib::{ + boxed::Box, + fmt::Display, + format, + ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Neg, Rem, Shl, Shr, Sub}, +}; // Checked add -#[cfg(not(feature = "unchecked"))] -pub(crate) fn add(x: T, y: T) -> FuncReturn { +pub fn add(x: T, y: T) -> FuncReturn { x.checked_add(&y).ok_or_else(|| { Box::new(EvalAltResult::ErrorArithmetic( format!("Addition overflow: {} + {}", x, y), @@ -42,8 +33,7 @@ pub(crate) fn add(x: T, y: T) -> FuncReturn { }) } // Checked subtract -#[cfg(not(feature = "unchecked"))] -pub(crate) fn sub(x: T, y: T) -> FuncReturn { +pub fn sub(x: T, y: T) -> FuncReturn { x.checked_sub(&y).ok_or_else(|| { Box::new(EvalAltResult::ErrorArithmetic( format!("Subtraction underflow: {} - {}", x, y), @@ -52,8 +42,7 @@ pub(crate) fn sub(x: T, y: T) -> FuncReturn { }) } // Checked multiply -#[cfg(not(feature = "unchecked"))] -pub(crate) fn mul(x: T, y: T) -> FuncReturn { +pub fn mul(x: T, y: T) -> FuncReturn { x.checked_mul(&y).ok_or_else(|| { Box::new(EvalAltResult::ErrorArithmetic( format!("Multiplication overflow: {} * {}", x, y), @@ -62,8 +51,7 @@ pub(crate) fn mul(x: T, y: T) -> FuncReturn { }) } // Checked divide -#[cfg(not(feature = "unchecked"))] -pub(crate) fn div(x: T, y: T) -> FuncReturn +pub fn div(x: T, y: T) -> FuncReturn where T: Display + CheckedDiv + PartialEq + Zero, { @@ -83,8 +71,7 @@ where }) } // Checked negative - e.g. -(i32::MIN) will overflow i32::MAX -#[cfg(not(feature = "unchecked"))] -pub(crate) fn neg(x: T) -> FuncReturn { +pub fn neg(x: T) -> FuncReturn { x.checked_neg().ok_or_else(|| { Box::new(EvalAltResult::ErrorArithmetic( format!("Negation overflow: -{}", x), @@ -93,8 +80,7 @@ pub(crate) fn neg(x: T) -> FuncReturn { }) } // Checked absolute -#[cfg(not(feature = "unchecked"))] -pub(crate) fn abs(x: T) -> FuncReturn { +pub fn abs(x: T) -> FuncReturn { // FIX - We don't use Signed::abs() here because, contrary to documentation, it panics // when the number is ::MIN instead of returning ::MIN itself. if x >= ::zero() { @@ -109,32 +95,26 @@ pub(crate) fn abs(x: T) -> FuncRetu } } // Unchecked add - may panic on overflow -#[cfg(any(feature = "unchecked", not(feature = "no_float")))] fn add_u(x: T, y: T) -> FuncReturn<::Output> { Ok(x + y) } // Unchecked subtract - may panic on underflow -#[cfg(any(feature = "unchecked", not(feature = "no_float")))] fn sub_u(x: T, y: T) -> FuncReturn<::Output> { Ok(x - y) } // Unchecked multiply - may panic on overflow -#[cfg(any(feature = "unchecked", not(feature = "no_float")))] fn mul_u(x: T, y: T) -> FuncReturn<::Output> { Ok(x * y) } // Unchecked divide - may panic when dividing by zero -#[cfg(any(feature = "unchecked", not(feature = "no_float")))] fn div_u(x: T, y: T) -> FuncReturn<::Output> { Ok(x / y) } // Unchecked negative - may panic on overflow -#[cfg(any(feature = "unchecked", not(feature = "no_float")))] fn neg_u(x: T) -> FuncReturn<::Output> { Ok(-x) } // Unchecked absolute - may panic on overflow -#[cfg(any(feature = "unchecked", not(feature = "no_float")))] fn abs_u(x: T) -> FuncReturn<::Output> where T: Neg + PartialOrd + Default + Into<::Output>, @@ -147,24 +127,17 @@ where } } // Bit operators -#[cfg(not(feature = "only_i32"))] -#[cfg(not(feature = "only_i64"))] fn binary_and(x: T, y: T) -> FuncReturn<::Output> { Ok(x & y) } -#[cfg(not(feature = "only_i32"))] -#[cfg(not(feature = "only_i64"))] fn binary_or(x: T, y: T) -> FuncReturn<::Output> { Ok(x | y) } -#[cfg(not(feature = "only_i32"))] -#[cfg(not(feature = "only_i64"))] fn binary_xor(x: T, y: T) -> FuncReturn<::Output> { Ok(x ^ y) } // Checked left-shift -#[cfg(not(feature = "unchecked"))] -pub(crate) fn shl(x: T, y: INT) -> FuncReturn { +pub fn shl(x: T, y: INT) -> FuncReturn { // Cannot shift by a negative number of bits if y < 0 { return Err(Box::new(EvalAltResult::ErrorArithmetic( @@ -181,8 +154,7 @@ pub(crate) fn shl(x: T, y: INT) -> FuncReturn { }) } // Checked right-shift -#[cfg(not(feature = "unchecked"))] -pub(crate) fn shr(x: T, y: INT) -> FuncReturn { +pub fn shr(x: T, y: INT) -> FuncReturn { // Cannot shift by a negative number of bits if y < 0 { return Err(Box::new(EvalAltResult::ErrorArithmetic( @@ -199,18 +171,15 @@ pub(crate) fn shr(x: T, y: INT) -> FuncReturn { }) } // Unchecked left-shift - may panic if shifting by a negative number of bits -#[cfg(feature = "unchecked")] -pub(crate) fn shl_u>(x: T, y: T) -> FuncReturn<>::Output> { +pub fn shl_u>(x: T, y: T) -> FuncReturn<>::Output> { Ok(x.shl(y)) } // Unchecked right-shift - may panic if shifting by a negative number of bits -#[cfg(feature = "unchecked")] -pub(crate) fn shr_u>(x: T, y: T) -> FuncReturn<>::Output> { +pub fn shr_u>(x: T, y: T) -> FuncReturn<>::Output> { Ok(x.shr(y)) } // Checked modulo -#[cfg(not(feature = "unchecked"))] -pub(crate) fn modulo(x: T, y: T) -> FuncReturn { +pub fn modulo(x: T, y: T) -> FuncReturn { x.checked_rem(&y).ok_or_else(|| { Box::new(EvalAltResult::ErrorArithmetic( format!("Modulo division by zero or overflow: {} % {}", x, y), @@ -219,62 +188,58 @@ pub(crate) fn modulo(x: T, y: T) -> FuncReturn { }) } // Unchecked modulo - may panic if dividing by zero -#[cfg(any(feature = "unchecked", not(feature = "no_float")))] fn modulo_u(x: T, y: T) -> FuncReturn<::Output> { Ok(x % y) } // Checked power -#[cfg(not(feature = "unchecked"))] -pub(crate) fn pow_i_i(x: INT, y: INT) -> FuncReturn { - #[cfg(not(feature = "only_i32"))] - if y > (u32::MAX as INT) { - Err(Box::new(EvalAltResult::ErrorArithmetic( - format!("Integer raised to too large an index: {} ~ {}", x, y), - Position::none(), - ))) - } else if y < 0 { - Err(Box::new(EvalAltResult::ErrorArithmetic( - format!("Integer raised to a negative index: {} ~ {}", x, y), - Position::none(), - ))) - } else { - x.checked_pow(y as u32).ok_or_else(|| { - Box::new(EvalAltResult::ErrorArithmetic( - format!("Power overflow: {} ~ {}", x, y), +pub fn pow_i_i(x: INT, y: INT) -> FuncReturn { + if cfg!(not(feature = "only_i32")) { + if y > (u32::MAX as INT) { + Err(Box::new(EvalAltResult::ErrorArithmetic( + format!("Integer raised to too large an index: {} ~ {}", x, y), Position::none(), - )) - }) - } - - #[cfg(feature = "only_i32")] - if y < 0 { - Err(Box::new(EvalAltResult::ErrorArithmetic( - format!("Integer raised to a negative index: {} ~ {}", x, y), - Position::none(), - ))) - } else { - x.checked_pow(y as u32).ok_or_else(|| { - Box::new(EvalAltResult::ErrorArithmetic( - format!("Power overflow: {} ~ {}", x, y), + ))) + } else if y < 0 { + Err(Box::new(EvalAltResult::ErrorArithmetic( + format!("Integer raised to a negative index: {} ~ {}", x, y), Position::none(), - )) - }) + ))) + } else { + x.checked_pow(y as u32).ok_or_else(|| { + Box::new(EvalAltResult::ErrorArithmetic( + format!("Power overflow: {} ~ {}", x, y), + Position::none(), + )) + }) + } + } else { + if y < 0 { + Err(Box::new(EvalAltResult::ErrorArithmetic( + format!("Integer raised to a negative index: {} ~ {}", x, y), + Position::none(), + ))) + } else { + x.checked_pow(y as u32).ok_or_else(|| { + Box::new(EvalAltResult::ErrorArithmetic( + format!("Power overflow: {} ~ {}", x, y), + Position::none(), + )) + }) + } } } // Unchecked integer power - may panic on overflow or if the power index is too high (> u32::MAX) -#[cfg(feature = "unchecked")] -pub(crate) fn pow_i_i_u(x: INT, y: INT) -> FuncReturn { +pub fn pow_i_i_u(x: INT, y: INT) -> FuncReturn { Ok(x.pow(y as u32)) } // Floating-point power - always well-defined #[cfg(not(feature = "no_float"))] -pub(crate) fn pow_f_f(x: FLOAT, y: FLOAT) -> FuncReturn { +pub fn pow_f_f(x: FLOAT, y: FLOAT) -> FuncReturn { Ok(x.powf(y)) } // Checked power #[cfg(not(feature = "no_float"))] -#[cfg(not(feature = "unchecked"))] -pub(crate) fn pow_f_i(x: FLOAT, y: INT) -> FuncReturn { +pub fn pow_f_i(x: FLOAT, y: INT) -> FuncReturn { // Raise to power that is larger than an i32 if y > (i32::MAX as INT) { return Err(Box::new(EvalAltResult::ErrorArithmetic( @@ -286,9 +251,8 @@ pub(crate) fn pow_f_i(x: FLOAT, y: INT) -> FuncReturn { Ok(x.powi(y as i32)) } // Unchecked power - may be incorrect if the power index is too high (> i32::MAX) -#[cfg(feature = "unchecked")] #[cfg(not(feature = "no_float"))] -pub(crate) fn pow_f_i_u(x: FLOAT, y: INT) -> FuncReturn { +pub fn pow_f_i_u(x: FLOAT, y: INT) -> FuncReturn { Ok(x.powi(y as i32)) } @@ -317,11 +281,8 @@ macro_rules! reg_sign { } def_package!(crate:ArithmeticPackage:"Basic arithmetic", lib, { - #[cfg(not(feature = "only_i32"))] - #[cfg(not(feature = "only_i64"))] - { - #[cfg(not(feature = "unchecked"))] - { + if cfg!(not(feature = "only_i32")) && cfg!(not(feature = "only_i64")) { + if cfg!(not(feature = "unchecked")) { // Checked basic arithmetic reg_op!(lib, "+", add, i8, u8, i16, u16, i32, u32, u64); reg_op!(lib, "-", sub, i8, u8, i16, u16, i32, u32, u64); @@ -332,8 +293,7 @@ def_package!(crate:ArithmeticPackage:"Basic arithmetic", lib, { reg_op!(lib, ">>", shr, i8, u8, i16, u16, i32, u32, u64); reg_op!(lib, "%", modulo, i8, u8, i16, u16, i32, u32, u64); - #[cfg(not(target_arch = "wasm32"))] - { + if cfg!(not(target_arch = "wasm32")) { reg_op!(lib, "+", add, i128, u128); reg_op!(lib, "-", sub, i128, u128); reg_op!(lib, "*", mul, i128, u128); @@ -345,8 +305,7 @@ def_package!(crate:ArithmeticPackage:"Basic arithmetic", lib, { } } - #[cfg(feature = "unchecked")] - { + if cfg!(feature = "unchecked") { // Unchecked basic arithmetic reg_op!(lib, "+", add_u, i8, u8, i16, u16, i32, u32, u64); reg_op!(lib, "-", sub_u, i8, u8, i16, u16, i32, u32, u64); @@ -357,8 +316,7 @@ def_package!(crate:ArithmeticPackage:"Basic arithmetic", lib, { reg_op!(lib, ">>", shr_u, i64, i8, u8, i16, u16, i32, u32, u64); reg_op!(lib, "%", modulo_u, i8, u8, i16, u16, i32, u32, u64); - #[cfg(not(target_arch = "wasm32"))] - { + if cfg!(not(target_arch = "wasm32")) { reg_op!(lib, "+", add_u, i128, u128); reg_op!(lib, "-", sub_u, i128, u128); reg_op!(lib, "*", mul_u, i128, u128); @@ -372,13 +330,13 @@ def_package!(crate:ArithmeticPackage:"Basic arithmetic", lib, { reg_sign!(lib, "sign", INT, i8, i16, i32, i64); - #[cfg(not(target_arch = "wasm32"))] - reg_sign!(lib, "sign", INT, i128); + if cfg!(not(target_arch = "wasm32")) { + reg_sign!(lib, "sign", INT, i128); + } } // Basic arithmetic for floating-point - no need to check - #[cfg(not(feature = "no_float"))] - { + if cfg!(not(feature = "no_float")) { reg_op!(lib, "+", add_u, f32); reg_op!(lib, "-", sub_u, f32); reg_op!(lib, "*", mul_u, f32); @@ -387,15 +345,12 @@ def_package!(crate:ArithmeticPackage:"Basic arithmetic", lib, { reg_sign!(lib, "sign", f64, f64); } - #[cfg(not(feature = "only_i32"))] - #[cfg(not(feature = "only_i64"))] - { + if cfg!(not(feature = "only_i32")) && cfg!(not(feature = "only_i64")) { reg_op!(lib, "|", binary_or, i8, u8, i16, u16, i32, u32, u64); reg_op!(lib, "&", binary_and, i8, u8, i16, u16, i32, u32, u64); reg_op!(lib, "^", binary_xor, i8, u8, i16, u16, i32, u32, u64); - #[cfg(not(target_arch = "wasm32"))] - { + if cfg!(not(target_arch = "wasm32")) { reg_op!(lib, "|", binary_or, i128, u128); reg_op!(lib, "&", binary_and, i128, u128); reg_op!(lib, "^", binary_xor, i128, u128); @@ -405,12 +360,11 @@ def_package!(crate:ArithmeticPackage:"Basic arithmetic", lib, { #[cfg(not(feature = "no_float"))] { // Checked power - #[cfg(not(feature = "unchecked"))] - lib.set_fn_2("~", pow_f_i); - - // Unchecked power - #[cfg(feature = "unchecked")] - lib.set_fn_2("~", pow_f_i_u); + if cfg!(not(feature = "unchecked")) { + lib.set_fn_2("~", pow_f_i); + } else { + lib.set_fn_2("~", pow_f_i_u); + } // Floating-point modulo and power reg_op!(lib, "%", modulo_u, f32); @@ -421,19 +375,15 @@ def_package!(crate:ArithmeticPackage:"Basic arithmetic", lib, { } // Checked unary - #[cfg(not(feature = "unchecked"))] - { + if cfg!(not(feature = "unchecked")) { reg_unary!(lib, "-", neg, INT); reg_unary!(lib, "abs", abs, INT); - #[cfg(not(feature = "only_i32"))] - #[cfg(not(feature = "only_i64"))] - { + if cfg!(not(feature = "only_i32")) && cfg!(not(feature = "only_i64")) { reg_unary!(lib, "-", neg, i8, i16, i32, i64); reg_unary!(lib, "abs", abs, i8, i16, i32, i64); - #[cfg(not(target_arch = "wasm32"))] - { + if cfg!(not(target_arch = "wasm32")) { reg_unary!(lib, "-", neg, i128); reg_unary!(lib, "abs", abs, i128); } @@ -441,19 +391,15 @@ def_package!(crate:ArithmeticPackage:"Basic arithmetic", lib, { } // Unchecked unary - #[cfg(feature = "unchecked")] - { + if cfg!(feature = "unchecked") { reg_unary!(lib, "-", neg_u, INT); reg_unary!(lib, "abs", abs_u, INT); - #[cfg(not(feature = "only_i32"))] - #[cfg(not(feature = "only_i64"))] - { + if cfg!(not(feature = "only_i32")) && cfg!(not(feature = "only_i64")) { reg_unary!(lib, "-", neg_u, i8, i16, i32, i64); reg_unary!(lib, "abs", abs_u, i8, i16, i32, i64); - #[cfg(not(target_arch = "wasm32"))] - { + if cfg!(not(target_arch = "wasm32")) { reg_unary!(lib, "-", neg_u, i128); reg_unary!(lib, "abs", abs_u, i128); } diff --git a/src/packages/array_basic.rs b/src/packages/array_basic.rs index 5ca3b1c7..c246f1d5 100644 --- a/src/packages/array_basic.rs +++ b/src/packages/array_basic.rs @@ -82,7 +82,6 @@ macro_rules! reg_pad { }; } -#[cfg(not(feature = "no_index"))] def_package!(crate:BasicArrayPackage:"Basic array utilities.", lib, { reg_op!(lib, "push", push, INT, bool, char, ImmutableString, Array, ()); reg_pad!(lib, "pad", pad, INT, bool, char, ImmutableString, Array, ()); @@ -104,15 +103,12 @@ def_package!(crate:BasicArrayPackage:"Basic array utilities.", lib, { }, ); - #[cfg(not(feature = "only_i32"))] - #[cfg(not(feature = "only_i64"))] - { + if cfg!(not(feature = "only_i32")) && cfg!(not(feature = "only_i64")) { reg_op!(lib, "push", push, i8, u8, i16, u16, i32, i64, u32, u64); reg_pad!(lib, "pad", pad, i8, u8, i16, u16, i32, u32, i64, u64); reg_tri!(lib, "insert", ins, i8, u8, i16, u16, i32, i64, u32, u64); - #[cfg(not(target_arch = "wasm32"))] - { + if cfg!(not(target_arch = "wasm32")) { reg_op!(lib, "push", push, i128, u128); reg_pad!(lib, "pad", pad, i128, u128); reg_tri!(lib, "insert", ins, i128, u128); diff --git a/src/packages/iter_basic.rs b/src/packages/iter_basic.rs index cccf4b6c..8914c6a5 100644 --- a/src/packages/iter_basic.rs +++ b/src/packages/iter_basic.rs @@ -73,9 +73,7 @@ def_package!(crate:BasicIteratorPackage:"Basic range iterators.", lib, { reg_range::(lib); lib.set_fn_2("range", get_range::); - #[cfg(not(feature = "only_i32"))] - #[cfg(not(feature = "only_i64"))] - { + if cfg!(not(feature = "only_i32")) && cfg!(not(feature = "only_i64")) { macro_rules! reg_range { ($lib:expr, $x:expr, $( $y:ty ),*) => ( $( @@ -87,16 +85,15 @@ def_package!(crate:BasicIteratorPackage:"Basic range iterators.", lib, { reg_range!(lib, "range", i8, u8, i16, u16, i32, i64, u32, u64); - #[cfg(not(target_arch = "wasm32"))] - reg_range!(lib, "range", i128, u128); + if cfg!(not(target_arch = "wasm32")) { + reg_range!(lib, "range", i128, u128); + } } reg_step::(lib); lib.set_fn_3("range", get_step_range::); - #[cfg(not(feature = "only_i32"))] - #[cfg(not(feature = "only_i64"))] - { + if cfg!(not(feature = "only_i32")) && cfg!(not(feature = "only_i64")) { macro_rules! reg_step { ($lib:expr, $x:expr, $( $y:ty ),*) => ( $( @@ -108,7 +105,8 @@ def_package!(crate:BasicIteratorPackage:"Basic range iterators.", lib, { reg_step!(lib, "range", i8, u8, i16, u16, i32, i64, u32, u64); - #[cfg(not(target_arch = "wasm32"))] - reg_step!(lib, "range", i128, u128); + if cfg!(not(target_arch = "wasm32")) { + reg_step!(lib, "range", i128, u128); + } } }); diff --git a/src/packages/logic.rs b/src/packages/logic.rs index 1cb4b437..6c70a38c 100644 --- a/src/packages/logic.rs +++ b/src/packages/logic.rs @@ -33,9 +33,7 @@ macro_rules! reg_op { } def_package!(crate:LogicPackage:"Logical operators.", lib, { - #[cfg(not(feature = "only_i32"))] - #[cfg(not(feature = "only_i64"))] - { + if cfg!(not(feature = "only_i32")) && cfg!(not(feature = "only_i64")) { reg_op!(lib, "<", lt, i8, u8, i16, u16, i32, u32, u64); reg_op!(lib, "<=", lte, i8, u8, i16, u16, i32, u32, u64); reg_op!(lib, ">", gt, i8, u8, i16, u16, i32, u32, u64); @@ -43,8 +41,7 @@ def_package!(crate:LogicPackage:"Logical operators.", lib, { reg_op!(lib, "==", eq, i8, u8, i16, u16, i32, u32, u64); reg_op!(lib, "!=", ne, i8, u8, i16, u16, i32, u32, u64); - #[cfg(not(target_arch = "wasm32"))] - { + if cfg!(not(target_arch = "wasm32")) { reg_op!(lib, "<", lt, i128, u128); reg_op!(lib, "<=", lte, i128, u128); reg_op!(lib, ">", gt, i128, u128); diff --git a/src/packages/map_basic.rs b/src/packages/map_basic.rs index 9437bc67..4e2e58ad 100644 --- a/src/packages/map_basic.rs +++ b/src/packages/map_basic.rs @@ -1,25 +1,20 @@ #![cfg(not(feature = "no_object"))] +use crate::any::Dynamic; use crate::def_package; use crate::engine::Map; +use crate::module::FuncReturn; use crate::parser::{ImmutableString, INT}; -#[cfg(not(feature = "no_index"))] -use crate::{any::Dynamic, module::FuncReturn}; - -#[cfg(not(feature = "no_index"))] use crate::stdlib::vec::Vec; -#[cfg(not(feature = "no_index"))] fn map_get_keys(map: &mut Map) -> FuncReturn> { Ok(map.iter().map(|(k, _)| k.clone().into()).collect()) } -#[cfg(not(feature = "no_index"))] fn map_get_values(map: &mut Map) -> FuncReturn> { Ok(map.iter().map(|(_, v)| v.clone()).collect()) } -#[cfg(not(feature = "no_object"))] def_package!(crate:BasicMapPackage:"Basic object map utilities.", lib, { lib.set_fn_2_mut( "has", @@ -74,9 +69,11 @@ def_package!(crate:BasicMapPackage:"Basic object map utilities.", lib, { ); // Register map access functions - #[cfg(not(feature = "no_index"))] - lib.set_fn_1_mut("keys", map_get_keys); + if cfg!(not(feature = "no_index")) { + lib.set_fn_1_mut("keys", map_get_keys); + } - #[cfg(not(feature = "no_index"))] - lib.set_fn_1_mut("values", map_get_values); + if cfg!(not(feature = "no_index")) { + lib.set_fn_1_mut("values", map_get_values); + } }); diff --git a/src/packages/math_basic.rs b/src/packages/math_basic.rs index 55bb68a3..f8fd2d33 100644 --- a/src/packages/math_basic.rs +++ b/src/packages/math_basic.rs @@ -5,22 +5,20 @@ use crate::parser::INT; use crate::parser::FLOAT; #[cfg(not(feature = "no_float"))] -#[cfg(not(feature = "unchecked"))] use crate::{result::EvalAltResult, token::Position}; -#[cfg(not(feature = "no_float"))] #[cfg(feature = "no_std")] -use num_traits::*; +#[cfg(not(feature = "no_float"))] +use num_traits::float::Float; #[cfg(not(feature = "no_float"))] -#[cfg(not(feature = "unchecked"))] use crate::stdlib::{boxed::Box, format}; +#[allow(dead_code)] #[cfg(feature = "only_i32")] -#[cfg(not(feature = "unchecked"))] pub const MAX_INT: INT = i32::MAX; +#[allow(dead_code)] #[cfg(not(feature = "only_i32"))] -#[cfg(not(feature = "unchecked"))] pub const MAX_INT: INT = i64::MAX; def_package!(crate:BasicMathPackage:"Basic mathematic functions.", lib, { @@ -69,9 +67,7 @@ def_package!(crate:BasicMathPackage:"Basic mathematic functions.", lib, { lib.set_fn_1("to_float", |x: INT| Ok(x as FLOAT)); lib.set_fn_1("to_float", |x: f32| Ok(x as FLOAT)); - #[cfg(not(feature = "only_i32"))] - #[cfg(not(feature = "only_i64"))] - { + if cfg!(not(feature = "only_i32")) && cfg!(not(feature = "only_i64")) { lib.set_fn_1("to_float", |x: i8| Ok(x as FLOAT)); lib.set_fn_1("to_float", |x: u8| Ok(x as FLOAT)); lib.set_fn_1("to_float", |x: i16| Ok(x as FLOAT)); @@ -81,8 +77,7 @@ def_package!(crate:BasicMathPackage:"Basic mathematic functions.", lib, { lib.set_fn_1("to_float", |x: i64| Ok(x as FLOAT)); lib.set_fn_1("to_float", |x: u64| Ok(x as FLOAT)); - #[cfg(not(target_arch = "wasm32"))] - { + if cfg!(not(target_arch = "wasm32")) { lib.set_fn_1("to_float", |x: i128| Ok(x as FLOAT)); lib.set_fn_1("to_float", |x: u128| Ok(x as FLOAT)); } @@ -91,28 +86,25 @@ def_package!(crate:BasicMathPackage:"Basic mathematic functions.", lib, { lib.set_fn_1("to_int", |ch: char| Ok(ch as INT)); - #[cfg(not(feature = "only_i32"))] - #[cfg(not(feature = "only_i64"))] - { + if cfg!(not(feature = "only_i32")) && cfg!(not(feature = "only_i64")) { lib.set_fn_1("to_int", |x: i8| Ok(x as INT)); lib.set_fn_1("to_int", |x: u8| Ok(x as INT)); lib.set_fn_1("to_int", |x: i16| Ok(x as INT)); lib.set_fn_1("to_int", |x: u16| Ok(x as INT)); } - #[cfg(not(feature = "only_i32"))] - { + if cfg!(not(feature = "only_i32")) { lib.set_fn_1("to_int", |x: i32| Ok(x as INT)); lib.set_fn_1("to_int", |x: u64| Ok(x as INT)); - #[cfg(feature = "only_i64")] - lib.set_fn_1("to_int", |x: u32| Ok(x as INT)); + if cfg!(feature = "only_i64") { + lib.set_fn_1("to_int", |x: u32| Ok(x as INT)); + } } #[cfg(not(feature = "no_float"))] { - #[cfg(not(feature = "unchecked"))] - { + if cfg!(not(feature = "unchecked")) { lib.set_fn_1( "to_int", |x: f32| { @@ -141,8 +133,7 @@ def_package!(crate:BasicMathPackage:"Basic mathematic functions.", lib, { ); } - #[cfg(feature = "unchecked")] - { + if cfg!(feature = "unchecked") { lib.set_fn_1("to_int", |x: f32| Ok(x as INT)); lib.set_fn_1("to_int", |x: f64| Ok(x as INT)); } diff --git a/src/packages/string_basic.rs b/src/packages/string_basic.rs index 2e405004..36f4f333 100644 --- a/src/packages/string_basic.rs +++ b/src/packages/string_basic.rs @@ -48,9 +48,7 @@ def_package!(crate:BasicStringPackage:"Basic string utilities, including printin reg_op!(lib, KEYWORD_DEBUG, to_debug, INT, bool, (), char, ImmutableString); - #[cfg(not(feature = "only_i32"))] - #[cfg(not(feature = "only_i64"))] - { + if cfg!(not(feature = "only_i32")) && cfg!(not(feature = "only_i64")) { reg_op!(lib, KEYWORD_PRINT, to_string, i8, u8, i16, u16, i32, u32); reg_op!(lib, FN_TO_STRING, to_string, i8, u8, i16, u16, i32, u32); reg_op!(lib, KEYWORD_DEBUG, to_debug, i8, u8, i16, u16, i32, u32); @@ -58,8 +56,7 @@ def_package!(crate:BasicStringPackage:"Basic string utilities, including printin reg_op!(lib, FN_TO_STRING, to_string, i64, u64); reg_op!(lib, KEYWORD_DEBUG, to_debug, i64, u64); - #[cfg(not(target_arch = "wasm32"))] - { + if cfg!(not(target_arch = "wasm32")) { reg_op!(lib, KEYWORD_PRINT, to_string, i128, u128); reg_op!(lib, FN_TO_STRING, to_string, i128, u128); reg_op!(lib, KEYWORD_DEBUG, to_debug, i128, u128); diff --git a/src/packages/string_more.rs b/src/packages/string_more.rs index b50d6915..130af8b8 100644 --- a/src/packages/string_more.rs +++ b/src/packages/string_more.rs @@ -94,14 +94,11 @@ def_package!(crate:MoreStringPackage:"Additional string utilities, including str reg_op!(lib, "+", prepend, INT, bool, char); lib.set_fn_2("+", |_: (), y: ImmutableString| Ok(y)); - #[cfg(not(feature = "only_i32"))] - #[cfg(not(feature = "only_i64"))] - { + if cfg!(not(feature = "only_i32")) && cfg!(not(feature = "only_i64")) { reg_op!(lib, "+", append, i8, u8, i16, u16, i32, i64, u32, u64); reg_op!(lib, "+", prepend, i8, u8, i16, u16, i32, i64, u32, u64); - #[cfg(not(target_arch = "wasm32"))] - { + if cfg!(not(target_arch = "wasm32")) { reg_op!(lib, "+", append, i128, u128); reg_op!(lib, "+", prepend, i128, u128); } diff --git a/src/parser.rs b/src/parser.rs index 2f832a75..08869146 100644 --- a/src/parser.rs +++ b/src/parser.rs @@ -2,7 +2,9 @@ use crate::any::{Dynamic, Union}; use crate::calc_fn_hash; -use crate::engine::{Engine, KEYWORD_THIS, MARKER_BLOCK, MARKER_EXPR, MARKER_IDENT}; +use crate::engine::{ + Engine, KEYWORD_FN_PTR_CURRY, KEYWORD_THIS, MARKER_BLOCK, MARKER_EXPR, MARKER_IDENT, +}; use crate::error::{LexError, ParseError, ParseErrorType}; use crate::fn_native::Shared; use crate::module::{Module, ModuleRef}; @@ -15,9 +17,6 @@ use crate::utils::{StaticVec, StraightHasherBuilder}; #[cfg(not(feature = "no_function"))] use crate::engine::FN_ANONYMOUS; -#[cfg(not(feature = "no_capture"))] -use crate::engine::KEYWORD_FN_PTR_CURRY; - #[cfg(not(feature = "no_object"))] use crate::engine::{make_getter, make_setter}; @@ -25,7 +24,7 @@ use crate::stdlib::{ borrow::Cow, boxed::Box, char, - collections::{HashMap, HashSet}, + collections::HashMap, fmt, format, hash::{Hash, Hasher}, iter::empty, @@ -40,6 +39,9 @@ use crate::stdlib::{ #[cfg(not(feature = "no_function"))] use crate::stdlib::collections::hash_map::DefaultHasher; +#[cfg(not(feature = "no_capture"))] +use crate::stdlib::collections::HashSet; + #[cfg(feature = "no_std")] #[cfg(not(feature = "no_function"))] use ahash::AHasher; @@ -2211,11 +2213,13 @@ fn parse_binary_op( let (op_token, pos) = input.next().unwrap(); - #[cfg(any(not(feature = "no_object"), not(feature = "no_capture")))] - if op_token == Token::Period { + if cfg!(not(feature = "no_object")) && op_token == Token::Period { if let (Token::Identifier(_), _) = input.peek().unwrap() { // prevents capturing of the object properties as vars: xxx. - state.capture = false; + #[cfg(not(feature = "no_capture"))] + { + state.capture = false; + } } } @@ -3112,7 +3116,6 @@ fn parse_fn( } /// Creates a curried expression from a list of external variables -#[cfg(not(feature = "no_capture"))] fn make_curry_from_externals( fn_expr: Expr, externals: StaticVec<(String, Position)>, @@ -3209,26 +3212,31 @@ fn parse_anon_fn( let body = parse_stmt(input, state, lib, settings.level_up()) .map(|stmt| stmt.unwrap_or_else(|| Stmt::Noop(pos)))?; - #[cfg(feature = "no_capture")] - let params: StaticVec<_> = params.into_iter().map(|(v, _)| v).collect(); - // External variables may need to be processed in a consistent order, // so extract them into a list. - #[cfg(not(feature = "no_capture"))] - let externals: StaticVec<_> = state - .externals - .iter() - .map(|(k, &v)| (k.clone(), v)) - .collect(); + let externals: StaticVec<_> = { + #[cfg(not(feature = "no_capture"))] + { + state + .externals + .iter() + .map(|(k, &v)| (k.clone(), v)) + .collect() + } + #[cfg(feature = "no_capture")] + Default::default() + }; - // Add parameters that are auto-curried - #[cfg(not(feature = "no_capture"))] - let params: StaticVec<_> = externals - .iter() - .map(|(k, _)| k) - .cloned() - .chain(params.into_iter().map(|(v, _)| v)) - .collect(); + let params: StaticVec<_> = if cfg!(not(feature = "no_capture")) { + externals + .iter() + .map(|(k, _)| k) + .cloned() + .chain(params.into_iter().map(|(v, _)| v)) + .collect() + } else { + params.into_iter().map(|(v, _)| v).collect() + }; // Calculate hash #[cfg(feature = "no_std")] @@ -3257,8 +3265,11 @@ fn parse_anon_fn( let expr = Expr::FnPointer(Box::new((fn_name, settings.pos))); - #[cfg(not(feature = "no_capture"))] - let expr = make_curry_from_externals(expr, externals, settings.pos); + let expr = if cfg!(not(feature = "no_capture")) { + make_curry_from_externals(expr, externals, settings.pos) + } else { + expr + }; Ok((expr, script)) } diff --git a/src/scope.rs b/src/scope.rs index b1b9a3b3..37f71e99 100644 --- a/src/scope.rs +++ b/src/scope.rs @@ -158,6 +158,32 @@ impl<'a> Scope<'a> { self.push_dynamic_value(name, EntryType::Normal, Dynamic::from(value), false) } + /// Add (push) a new shared entry to the Scope. + /// + /// # Examples + /// + /// ``` + /// use rhai::Scope; + /// + /// let mut my_scope = Scope::new(); + /// + /// my_scope.push_shared("x", 42_i64); + /// assert_eq!(my_scope.get_value::("x").unwrap(), 42); + /// ``` + #[cfg(not(feature = "no_shared"))] + pub fn push_shared>, T: Variant + Clone>( + &mut self, + name: K, + value: T, + ) -> &mut Self { + self.push_dynamic_value( + name, + EntryType::Normal, + Dynamic::from(value).into_shared(), + false, + ) + } + /// Add (push) a new `Dynamic` entry to the Scope. /// /// # Examples @@ -200,6 +226,34 @@ impl<'a> Scope<'a> { self.push_dynamic_value(name, EntryType::Constant, Dynamic::from(value), true) } + /// Add (push) a new shared constant to the Scope. + /// + /// Shared constants are immutable and cannot be assigned to, but their shared values can change. + /// + /// # Examples + /// + /// ``` + /// use rhai::Scope; + /// + /// let mut my_scope = Scope::new(); + /// + /// my_scope.push_constant_shared("x", 42_i64); + /// assert_eq!(my_scope.get_value::("x").unwrap(), 42); + /// ``` + #[cfg(not(feature = "no_shared"))] + pub fn push_constant_shared>, T: Variant + Clone>( + &mut self, + name: K, + value: T, + ) -> &mut Self { + self.push_dynamic_value( + name, + EntryType::Constant, + Dynamic::from(value).into_shared(), + true, + ) + } + /// Add (push) a new constant with a `Dynamic` value to the Scope. /// /// Constants are immutable and cannot be assigned to. Their values never change. @@ -393,7 +447,6 @@ impl<'a> Scope<'a> { /// Clone the Scope, keeping only the last instances of each variable name. /// Shadowed variables are omitted in the copy. - #[cfg(not(feature = "no_capture"))] pub(crate) fn flatten_clone(&self) -> Self { let mut entries: HashMap<&str, Entry> = Default::default(); diff --git a/src/token.rs b/src/token.rs index dfd50c27..920fb33a 100644 --- a/src/token.rs +++ b/src/token.rs @@ -507,8 +507,8 @@ impl Token { | "yield" => Reserved(syntax.into()), KEYWORD_PRINT | KEYWORD_DEBUG | KEYWORD_TYPE_OF | KEYWORD_EVAL | KEYWORD_FN_PTR - | KEYWORD_FN_PTR_CALL | KEYWORD_FN_PTR_CURRY | KEYWORD_SHARED | KEYWORD_TAKE - | KEYWORD_THIS => Reserved(syntax.into()), + | KEYWORD_FN_PTR_CALL | KEYWORD_FN_PTR_CURRY | KEYWORD_IS_SHARED | KEYWORD_SHARED + | KEYWORD_TAKE | KEYWORD_THIS => Reserved(syntax.into()), _ => return None, })