From 871fcb38be48153c3970d8968e2726560ddcb599 Mon Sep 17 00:00:00 2001 From: Stephen Chung Date: Fri, 31 Jul 2020 16:03:08 +0800 Subject: [PATCH] Minor style changes and make sure no_shared works on all. --- .github/workflows/build.yml | 2 + Cargo.toml | 6 +- src/any.rs | 276 +++++++++++++++++++++--------------- src/engine.rs | 85 ++++++----- src/fn_call.rs | 8 +- src/fn_native.rs | 25 +++- src/token.rs | 12 +- 7 files changed, 246 insertions(+), 168 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 1370e03e..cd10a5a6 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -29,6 +29,8 @@ jobs: - "--features no_object" - "--features no_function" - "--features no_module" + - "--features no_capture" + - "--features no_shared" - "--features unicode-xid-ident" toolchain: [stable] experimental: [false] diff --git a/Cargo.toml b/Cargo.toml index 0cc0e20d..13ef119f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -22,7 +22,7 @@ smallvec = { version = "1.4.1", default-features = false } [features] #default = ["unchecked", "sync", "no_optimize", "no_float", "only_i32", "no_index", "no_object", "no_function", "no_module"] -default = [] +default = [ "no_shared"] plugins = [] unchecked = [] # unchecked arithmetic sync = [] # restrict to only types that implement Send + Sync @@ -34,13 +34,13 @@ no_index = [] # no arrays and indexing no_object = [] # no custom objects no_function = [] # no script-defined functions no_capture = [] # no automatic read/write binding of anonymous function's local variables to it's external context -no_shared = [] # no explicit shared() and take() functions in the script code +no_shared = [] # no shared values no_module = [] # no modules internals = [] # expose internal data structures unicode-xid-ident = ["unicode-xid"] # allow Unicode Standard Annex #31 for identifiers. # compiling for no-std -no_std = [ "num-traits/libm", "hashbrown", "core-error", "libm", "ahash" ] +no_std = [ "no_shared", "num-traits/libm", "hashbrown", "core-error", "libm", "ahash" ] [profile.release] lto = "fat" diff --git a/src/any.rs b/src/any.rs index cbb3e444..470d86c7 100644 --- a/src/any.rs +++ b/src/any.rs @@ -1,9 +1,12 @@ //! Helper module which defines the `Any` trait to to allow dynamic value handling. -use crate::fn_native::{FnPtr, SendSync, SharedMut}; +use crate::fn_native::{FnPtr, SendSync}; use crate::parser::{ImmutableString, INT}; use crate::r#unsafe::{unsafe_cast_box, unsafe_try_cast}; +#[cfg(not(feature = "no_shared"))] +use crate::fn_native::SharedMut; + #[cfg(not(feature = "no_float"))] use crate::parser::FLOAT; @@ -17,13 +20,18 @@ use crate::stdlib::{ any::{type_name, Any, TypeId}, boxed::Box, fmt, + ops::{Deref, DerefMut}, string::String, - ops::{DerefMut, Deref} }; +#[cfg(not(feature = "no_shared"))] #[cfg(not(feature = "sync"))] -use crate::stdlib::{rc::Rc, cell::{RefCell, Ref, RefMut}}; +use crate::stdlib::{ + cell::{Ref, RefCell, RefMut}, + rc::Rc, +}; +#[cfg(not(feature = "no_shared"))] #[cfg(feature = "sync")] use crate::stdlib::sync::{Arc, RwLock, RwLockReadGuard, RwLockWriteGuard}; @@ -151,32 +159,39 @@ pub enum Union { Map(Box), FnPtr(Box), Variant(Box>), + #[cfg(not(feature = "no_shared"))] Shared(Box), } /// Internal Shared Dynamic representation. /// /// Created with `Dynamic::into_shared()`. +#[cfg(not(feature = "no_shared"))] #[derive(Clone)] pub struct SharedCell { value_type_id: TypeId, value_type_name: &'static str, - container: SharedMut + container: SharedMut, } -/// Dynamic's underlying `Variant` read guard that supports `Deref` for Variant's -/// reference reading. +/// Underlying `Variant` read guard for `Dynamic`. /// -/// This data structure provides transparent interoperability between normal -/// `Dynamic` types and Shared Dynamic references. +/// This data structure provides transparent interoperability between +/// normal `Dynamic` and shared Dynamic values. #[derive(Debug)] pub struct DynamicReadLock<'d, T: Variant + Clone>(DynamicReadLockInner<'d, T>); +/// Different types of read guards for `DynamicReadLock`. #[derive(Debug)] enum DynamicReadLockInner<'d, T: Variant + Clone> { + /// A simple reference to a non-shared value. Reference(&'d T), + /// A read guard to a shared `RefCell`. + #[cfg(not(feature = "no_shared"))] #[cfg(not(feature = "sync"))] Guard(Ref<'d, Dynamic>), + /// A read guard to a shared `RwLock`. + #[cfg(not(feature = "no_shared"))] #[cfg(feature = "sync")] Guard(RwLockReadGuard<'d, Dynamic>), } @@ -188,25 +203,31 @@ impl<'d, T: Variant + Clone> Deref for DynamicReadLock<'d, T> { fn deref(&self) -> &Self::Target { match &self.0 { DynamicReadLockInner::Reference(reference) => reference.deref(), - // unwrapping is safe because all checks already done in it's constructor + // Unwrapping is safe because all checking is already done in its constructor + #[cfg(not(feature = "no_shared"))] DynamicReadLockInner::Guard(guard) => guard.downcast_ref().unwrap(), } } } -/// Dynamic's underlying `Variant` write guard that supports `Deref` and `DerefMut` -/// for Variant's reference reading/writing. +/// Underlying `Variant` write guard for `Dynamic`. /// -/// This data structure provides transparent interoperability between normal -/// `Dynamic` types and Shared Dynamic references. +/// This data structure provides transparent interoperability between +/// normal `Dynamic` and shared Dynamic values. #[derive(Debug)] pub struct DynamicWriteLock<'d, T: Variant + Clone>(DynamicWriteLockInner<'d, T>); +/// Different types of write guards for `DynamicReadLock`. #[derive(Debug)] enum DynamicWriteLockInner<'d, T: Variant + Clone> { + /// A simple mutable reference to a non-shared value. Reference(&'d mut T), + /// A write guard to a shared `RefCell`. + #[cfg(not(feature = "no_shared"))] #[cfg(not(feature = "sync"))] Guard(RefMut<'d, Dynamic>), + /// A write guard to a shared `RwLock`. + #[cfg(not(feature = "no_shared"))] #[cfg(feature = "sync")] Guard(RwLockWriteGuard<'d, Dynamic>), } @@ -218,7 +239,8 @@ impl<'d, T: Variant + Clone> Deref for DynamicWriteLock<'d, T> { fn deref(&self) -> &Self::Target { match &self.0 { DynamicWriteLockInner::Reference(reference) => reference.deref(), - // unwrapping is safe because all checks already done in it's constructor + // Unwrapping is safe because all checking is already done in its constructor + #[cfg(not(feature = "no_shared"))] DynamicWriteLockInner::Guard(guard) => guard.downcast_ref().unwrap(), } } @@ -229,7 +251,8 @@ impl<'d, T: Variant + Clone> DerefMut for DynamicWriteLock<'d, T> { fn deref_mut(&mut self) -> &mut Self::Target { match &mut self.0 { DynamicWriteLockInner::Reference(reference) => reference.deref_mut(), - // unwrapping is safe because all checks already done in it's constructor + // Unwrapping is safe because all checking is already done in its constructor + #[cfg(not(feature = "no_shared"))] DynamicWriteLockInner::Guard(guard) => guard.downcast_mut().unwrap(), } } @@ -247,6 +270,7 @@ 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 { Union::Shared(_) => true, @@ -284,6 +308,7 @@ impl Dynamic { Union::Map(_) => TypeId::of::(), Union::FnPtr(_) => TypeId::of::(), Union::Variant(value) => (***value).type_id(), + #[cfg(not(feature = "no_shared"))] Union::Shared(cell) => (**cell).value_type_id, } } @@ -307,6 +332,7 @@ impl Dynamic { #[cfg(not(feature = "no_std"))] Union::Variant(value) if value.is::() => "timestamp", Union::Variant(value) => (***value).type_name(), + #[cfg(not(feature = "no_shared"))] Union::Shared(cell) => (**cell).value_type_name, } } @@ -363,7 +389,8 @@ impl fmt::Display for Dynamic { #[cfg(not(feature = "no_std"))] Union::Variant(value) if value.is::() => write!(f, ""), Union::Variant(value) => write!(f, "{}", (*value).type_name()), - Union::Shared(cell) => write!(f, "{}", (**cell).value_type_name), + #[cfg(not(feature = "no_shared"))] + Union::Shared(cell) => write!(f, "", (**cell).value_type_name), } } } @@ -390,7 +417,8 @@ impl fmt::Debug for Dynamic { #[cfg(not(feature = "no_std"))] Union::Variant(value) if value.is::() => write!(f, ""), Union::Variant(value) => write!(f, "{}", (*value).type_name()), - Union::Shared(cell) => write!(f, "{}", (**cell).value_type_name), + #[cfg(not(feature = "no_shared"))] + Union::Shared(cell) => write!(f, "", (**cell).value_type_name), } } } @@ -411,7 +439,8 @@ impl Clone for Dynamic { Union::Map(ref value) => Self(Union::Map(value.clone())), Union::FnPtr(ref value) => Self(Union::FnPtr(value.clone())), Union::Variant(ref value) => (***value).clone_into_dynamic(), - Union::Shared(ref cell) => Self(Union::Shared(Box::new((**cell).clone()))) + #[cfg(not(feature = "no_shared"))] + Union::Shared(ref cell) => Self(Union::Shared(Box::new((**cell).clone()))), } } } @@ -523,53 +552,42 @@ impl Dynamic { Self(Union::Variant(Box::new(boxed))) } - /// Turns Dynamic into Shared Dynamic variant backed by runtime - /// mutable reference-counter container(`Arc>` or - /// `Rc` depending on `sync` feature). + /// Turn the `Dynamic` value into a shared `Dynamic` value backed by an `Rc>` + /// or `Arc>` depending on the `sync` feature. /// - /// Instances of Shared Dynamic are relatively cheap to clone. All clones of - /// Shared Dynamic references the same chunk of memory. + /// Shared `Dynamic` values are relatively cheap to clone as they simply increment the + /// reference counts. /// - /// The Dynamic is capable to work transparently with the it's inner - /// data, seamlessly casting between ordinary instances of Dynamic and - /// Shared Dynamic instances. + /// Shared `Dynamic` values can be converted seamlessly to and from ordinary `Dynamic` values. /// - /// If original value already a Shared variant returns identity. + /// If the `Dynamic` value is already shared, this method returns itself. + #[cfg(not(feature = "no_shared"))] pub fn into_shared(self) -> Self { match self.0 { Union::Shared(..) => self, - _ => { - let cell = SharedCell { - value_type_id: self.type_id(), - value_type_name: self.type_name(), - #[cfg(not(feature = "sync"))] - container: Rc::new(RefCell::new(self)), - #[cfg(feature = "sync")] - container: Arc::new(RwLock::new(self)), - }; + _ => Self(Union::Shared(Box::new(SharedCell { + value_type_id: self.type_id(), + value_type_name: self.type_name(), - Self(Union::Shared(Box::new(cell))) - }, + #[cfg(not(feature = "sync"))] + container: Rc::new(RefCell::new(self)), + #[cfg(feature = "sync")] + container: Arc::new(RwLock::new(self)), + }))), } } - /// Get a copy of the `Dynamic` value as a specific type. + /// Convert the `Dynamic` value into specific type. /// Casting to a `Dynamic` just returns as is. /// - /// Returns None if types mismatched. + /// Returns `None` if types mismatched. /// - /// # Shared Dynamic + /// # Panics and Deadlocks /// - /// When accessing Shared Dynamic in sync mode(`sync` feature enabled) - /// can block current thread while the underlined data is being written. + /// Under the `sync` feature, this call may deadlock. + /// Otherwise, this call panics if the data is currently borrowed for write. /// - /// When accessing Shared Dynamic in NON-sync mode can **panic** if the data - /// is currently borrowed for write. - /// - /// ## Safety - /// - /// Both situations normally shouldn't happen since most operations in Rhai - /// use pass-by-value data and the script executed in a single thread. + /// These normally shouldn't occur since most operations in Rhai is single-threaded. /// /// # Example /// @@ -588,20 +606,6 @@ impl Dynamic { return unsafe_cast_box::<_, T>(Box::new(self)).ok().map(|v| *v); } - #[cfg(not(feature = "sync"))] - if let Union::Shared(cell) = self.0 { - let reference = cell.container.borrow(); - - return (*reference).clone().try_cast() - } - - #[cfg(feature = "sync")] - if let Union::Shared(cell) = self.0 { - let read_lock = cell.container.read().unwrap(); - - return (*read_lock).clone().try_cast() - } - if type_id == TypeId::of::() { return match self.0 { Union::Int(value) => unsafe_try_cast(value), @@ -677,23 +681,35 @@ impl Dynamic { match self.0 { Union::Variant(value) => (*value).as_box_any().downcast().map(|x| *x).ok(), + + #[cfg(not(feature = "no_shared"))] + #[cfg(not(feature = "sync"))] + Union::Shared(cell) => return cell.container.borrow().deref().clone().try_cast(), + + #[cfg(not(feature = "no_shared"))] + #[cfg(feature = "sync")] + Union::Shared(cell) => { + return cell.container.read().unwrap().deref().clone().try_cast() + } + _ => None, } } - /// Get a copy of the `Dynamic` value as a specific type. + /// Convert the `Dynamic` value into a specific type. /// Casting to a `Dynamic` just returns as is. /// - /// # Panics + /// Returns `None` if types mismatched. + /// + /// # Panics and Deadlocks /// /// Panics if the cast fails (e.g. the type of the actual value is not the - /// same as the specified type), or if the data held by Shared Dynamic is - /// currently borrowed(when the `sync` feature disabled). + /// same as the specified type). /// - /// # Notes + /// Under the `sync` feature, this call may deadlock. + /// Otherwise, this call panics if the data is currently borrowed for write. /// - /// If the `sync` feature enabled Shared Dynamic can block current thread - /// while the data being written. + /// These normally shouldn't occur since most operations in Rhai is single-threaded. /// /// # Example /// @@ -709,108 +725,115 @@ impl Dynamic { self.try_cast::().unwrap() } - /// Get a copy of a specific type to the `Dynamic`. - /// Casting to `Dynamic` returns a clone of the value in case of NON-shared - /// Dynamic. In case of Shared Dynamic returns a clone of the inner data of - /// Shared Dynamic. + /// Get a copy of the `Dynamic` as a specific type. + /// + /// If the `Dynamic` is not a shared value, it returns a cloned copy of the value. + /// + /// If the `Dynamic` is a shared value, it returns a cloned copy of the shared value. + /// /// Returns `None` if the cast fails. #[inline(always)] pub fn clone_inner_data(&self) -> Option { match self.0 { + #[cfg(not(feature = "no_shared"))] Union::Shared(ref cell) => { let type_id = TypeId::of::(); - if type_id != TypeId::of::() && cell.value_type_id != type_id { - return None + if type_id != TypeId::of::() && type_id != cell.value_type_id { + return None; } #[cfg(not(feature = "sync"))] - return Some(cell - .container - .borrow() - .deref() - .downcast_ref::() - .unwrap() - .clone()); + return Some( + cell.container + .borrow() + .deref() + .downcast_ref::() + .unwrap() + .clone(), + ); #[cfg(feature = "sync")] - return Some(cell - .container - .read() - .unwrap() - .deref() - .downcast_ref::() - .unwrap() - .clone()); - }, - _ => { - self.downcast_ref().cloned() + return Some( + cell.container + .read() + .unwrap() + .deref() + .downcast_ref::() + .unwrap() + .clone(), + ); } + _ => self.downcast_ref().cloned(), } } /// Get a reference of a specific type to the `Dynamic`. /// Casting to `Dynamic` just returns a reference to it. + /// /// Returns `None` if the cast fails. #[inline(always)] pub fn read_lock(&self) -> Option> { match self.0 { + #[cfg(not(feature = "no_shared"))] Union::Shared(ref cell) => { let type_id = TypeId::of::(); - if type_id != TypeId::of::() && cell.value_type_id != type_id { - return None + if type_id != TypeId::of::() && type_id != cell.value_type_id { + return None; } #[cfg(not(feature = "sync"))] return Some(DynamicReadLock(DynamicReadLockInner::Guard( - cell.container.borrow() + cell.container.borrow(), ))); #[cfg(feature = "sync")] return Some(DynamicReadLock(DynamicReadLockInner::Guard( - cell.container.read().unwrap() + cell.container.read().unwrap(), ))); - }, - _ => { - self.downcast_ref().map(|reference| { - DynamicReadLock(DynamicReadLockInner::Reference(reference)) - }) } + _ => self + .downcast_ref() + .map(|reference| DynamicReadLock(DynamicReadLockInner::Reference(reference))), } } /// Get a mutable reference of a specific type to the `Dynamic`. /// Casting to `Dynamic` just returns a mutable reference to it. + /// /// Returns `None` if the cast fails. #[inline(always)] pub fn write_lock(&mut self) -> Option> { match self.0 { + #[cfg(not(feature = "no_shared"))] Union::Shared(ref cell) => { let type_id = TypeId::of::(); if type_id != TypeId::of::() && cell.value_type_id != type_id { - return None + return None; } #[cfg(not(feature = "sync"))] return Some(DynamicWriteLock(DynamicWriteLockInner::Guard( - cell.container.borrow_mut() + cell.container.borrow_mut(), ))); #[cfg(feature = "sync")] return Some(DynamicWriteLock(DynamicWriteLockInner::Guard( - cell.container.write().unwrap() + cell.container.write().unwrap(), ))); - }, - _ => { - self.downcast_mut().map(|reference| { - DynamicWriteLock(DynamicWriteLockInner::Reference(reference)) - }) } + _ => self + .downcast_mut() + .map(|reference| DynamicWriteLock(DynamicWriteLockInner::Reference(reference))), } } + /// Get a reference of a specific type to the `Dynamic`. + /// Casting to `Dynamic` just returns a reference to it. + /// + /// Returns `None` if the cast fails. #[inline(always)] fn downcast_ref(&self) -> Option<&T> { let type_id = TypeId::of::(); @@ -884,10 +907,16 @@ impl Dynamic { match &self.0 { Union::Variant(value) => value.as_ref().as_ref().as_any().downcast_ref::(), + #[cfg(not(feature = "no_shared"))] + Union::Shared(_) => unreachable!(), _ => None, } } + /// Get a mutable reference of a specific type to the `Dynamic`. + /// Casting to `Dynamic` just returns a mutable reference to it. + /// + /// Returns `None` if the cast fails. #[inline(always)] fn downcast_mut(&mut self) -> Option<&mut T> { let type_id = TypeId::of::(); @@ -955,6 +984,8 @@ impl Dynamic { match &mut self.0 { Union::Variant(value) => value.as_mut().as_mut_any().downcast_mut::(), + #[cfg(not(feature = "no_shared"))] + Union::Shared(_) => unreachable!(), _ => None, } } @@ -964,7 +995,10 @@ impl Dynamic { pub fn as_int(&self) -> Result { match self.0 { Union::Int(n) => Ok(n), - Union::Shared(_) => self.clone_inner_data::().ok_or_else(|| self.type_name()), + #[cfg(not(feature = "no_shared"))] + Union::Shared(_) => self + .clone_inner_data::() + .ok_or_else(|| self.type_name()), _ => Err(self.type_name()), } } @@ -975,7 +1009,10 @@ impl Dynamic { pub fn as_float(&self) -> Result { match self.0 { Union::Float(n) => Ok(n), - Union::Shared(_) => self.clone_inner_data::().ok_or_else(|| self.type_name()), + #[cfg(not(feature = "no_shared"))] + Union::Shared(_) => self + .clone_inner_data::() + .ok_or_else(|| self.type_name()), _ => Err(self.type_name()), } } @@ -985,7 +1022,10 @@ impl Dynamic { pub fn as_bool(&self) -> Result { match self.0 { Union::Bool(b) => Ok(b), - Union::Shared(_) => self.clone_inner_data::().ok_or_else(|| self.type_name()), + #[cfg(not(feature = "no_shared"))] + Union::Shared(_) => self + .clone_inner_data::() + .ok_or_else(|| self.type_name()), _ => Err(self.type_name()), } } @@ -995,7 +1035,10 @@ impl Dynamic { pub fn as_char(&self) -> Result { match self.0 { Union::Char(n) => Ok(n), - Union::Shared(_) => self.clone_inner_data::().ok_or_else(|| self.type_name()), + #[cfg(not(feature = "no_shared"))] + Union::Shared(_) => self + .clone_inner_data::() + .ok_or_else(|| self.type_name()), _ => Err(self.type_name()), } } @@ -1025,6 +1068,7 @@ impl Dynamic { match self.0 { Union::Str(s) => Ok(s), Union::FnPtr(f) => Ok(f.take_data().0), + #[cfg(not(feature = "no_shared"))] Union::Shared(cell) => { #[cfg(not(feature = "sync"))] match &cell.container.borrow().deref().0 { diff --git a/src/engine.rs b/src/engine.rs index e083f84d..e3f5dad8 100644 --- a/src/engine.rs +++ b/src/engine.rs @@ -1,6 +1,6 @@ //! Main module defining the script evaluation `Engine`. -use crate::any::{map_std_type_name, Dynamic, Union, DynamicWriteLock}; +use crate::any::{map_std_type_name, Dynamic, DynamicWriteLock, Union}; use crate::calc_fn_hash; use crate::fn_call::run_builtin_op_assignment; use crate::fn_native::{CallableFunction, Callback, FnPtr}; @@ -37,9 +37,9 @@ use crate::stdlib::{ collections::{HashMap, HashSet}, fmt, format, iter::{empty, once}, + ops::DerefMut, string::{String, ToString}, vec::Vec, - ops::DerefMut, }; #[cfg(not(feature = "no_index"))] @@ -172,9 +172,9 @@ impl Target<'_> { /// Get the value of the `Target` as a `Dynamic`, cloning a referenced value if necessary. pub fn clone_into_dynamic(self) -> Dynamic { match self { - Self::Ref(r) => r.clone(), // Referenced value is cloned + Self::Ref(r) => r.clone(), // Referenced value is cloned Self::LockGuard((_, orig)) => orig, // Return original container of the Shared Dynamic - Self::Value(v) => v, // Owned value is simply taken + Self::Value(v) => v, // Owned value is simply taken #[cfg(not(feature = "no_index"))] Self::StringChar(_, _, ch) => ch, // Character is taken } @@ -229,15 +229,17 @@ impl Target<'_> { #[cfg(any(not(feature = "no_index"), not(feature = "no_object")))] impl<'a> From<&'a mut Dynamic> for Target<'a> { fn from(value: &'a mut Dynamic) -> Self { + #[cfg(not(feature = "no_shared"))] if value.is_shared() { - // clone is cheap since it holds Arc/Rw under the hood + // cloning is cheap since it holds Arc/Rw under the hood let container = value.clone(); - Self::LockGuard((value.write_lock::().unwrap(), container)) - } else { - Self::Ref(value) + return Self::LockGuard((value.write_lock::().unwrap(), container)); } + + Self::Ref(value) } } + #[cfg(any(not(feature = "no_index"), not(feature = "no_object")))] impl> From for Target<'_> { fn from(value: T) -> Self { @@ -706,7 +708,7 @@ impl Engine { // Try to call an index setter #[cfg(not(feature = "no_index"))] Ok(obj_ptr) if obj_ptr.is_value() => { - next = Some((1, _new_val.unwrap())); + next = Some((1, _new_val.unwrap())); } // Indexed value is a reference - update directly Ok(ref mut obj_ptr) => { @@ -740,13 +742,13 @@ impl Engine { state, lib, FN_IDX_SET, 0, args, is_ref, true, false, None, None, level, ) - .or_else(|err| match *err { - // If there is no index setter, no need to set it back because the indexer is read-only - EvalAltResult::ErrorFunctionNotFound(_, _) => { - Ok(Default::default()) - } - _ => Err(err), - })?; + .or_else(|err| match *err { + // If there is no index setter, no need to set it back because the indexer is read-only + EvalAltResult::ErrorFunctionNotFound(_, _) => { + Ok(Default::default()) + } + _ => Err(err), + })?; } // next step is custom index setter call in case of error @@ -759,7 +761,7 @@ impl Engine { )?; } None => (), - _ => unreachable!() + _ => unreachable!(), } Ok(Default::default()) @@ -881,8 +883,15 @@ impl Engine { let (result, may_be_changed) = self .eval_dot_index_chain_helper( - state, lib, this_ptr, &mut val.into(), expr, idx_values, next_chain, - level, _new_val, + state, + lib, + this_ptr, + &mut val.into(), + expr, + idx_values, + next_chain, + level, + _new_val, ) .map_err(|err| err.new_position(*pos))?; @@ -1318,11 +1327,13 @@ impl Engine { )), // Normal assignment ScopeEntryType::Normal if op.is_empty() => { - if lhs_ptr.is_shared() { - *lhs_ptr.write_lock::().unwrap() = rhs_val; + #[cfg(not(feature = "no_shared"))] + let lhs_ptr = if lhs_ptr.is_shared() { + lhs_ptr.write_lock::().unwrap(); } else { - *lhs_ptr = rhs_val; - } + lhs_ptr + }; + *lhs_ptr = rhs_val; Ok(Default::default()) } // Op-assignment - in order of precedence: @@ -1340,13 +1351,15 @@ impl Engine { .get_fn(hash_fn, false) .or_else(|| self.packages.get_fn(hash_fn, false)) { - if lhs_ptr.is_shared() { - // Overriding exact implementation - func(self, lib, &mut [&mut lhs_ptr.write_lock::().unwrap(), &mut rhs_val])?; + // Overriding exact implementation + #[cfg(not(feature = "no_shared"))] + let lhs_ptr = if lhs_ptr.is_shared() { + &mut lhs_ptr.write_lock::().unwrap() } else { - // Overriding exact implementation - func(self, lib, &mut [lhs_ptr, &mut rhs_val])?; - } + lhs_ptr + }; + + func(self, lib, &mut [lhs_ptr, &mut rhs_val])?; } else if run_builtin_op_assignment(op, lhs_ptr, &rhs_val)?.is_none() { // Not built in, map to `var = var op rhs` let op = &op[..op.len() - 1]; // extract operator without = @@ -1360,13 +1373,15 @@ impl Engine { state, lib, op, 0, args, false, false, false, None, None, level, ) .map_err(|err| err.new_position(*op_pos))?; - if lhs_ptr.is_shared() { - // Set value to LHS - *lhs_ptr.write_lock::().unwrap() = value; + + #[cfg(not(feature = "no_shared"))] + let lhs_ptr = if lhs_ptr.is_shared() { + lhs_ptr.write_lock::().unwrap() } else { - // Set value to LHS - *lhs_ptr = value; - } + lhs_ptr + }; + + *lhs_ptr = value; } Ok(Default::default()) } diff --git a/src/fn_call.rs b/src/fn_call.rs index bed49230..d093c165 100644 --- a/src/fn_call.rs +++ b/src/fn_call.rs @@ -5,7 +5,7 @@ use crate::calc_fn_hash; use crate::engine::{ search_imports, search_namespace, search_scope_only, Engine, Imports, State, KEYWORD_DEBUG, KEYWORD_EVAL, KEYWORD_FN_PTR, KEYWORD_FN_PTR_CALL, KEYWORD_FN_PTR_CURRY, KEYWORD_PRINT, - KEYWORD_TYPE_OF, KEYWORD_SHARED, + KEYWORD_TYPE_OF, }; use crate::error::ParseErrorType; use crate::fn_native::{FnCallArgs, FnPtr}; @@ -14,9 +14,9 @@ use crate::optimize::OptimizationLevel; use crate::parser::{Expr, ImmutableString, AST, INT}; use crate::result::EvalAltResult; use crate::scope::Scope; +use crate::stdlib::ops::Deref; use crate::token::Position; use crate::utils::StaticVec; -use crate::stdlib::ops::Deref; #[cfg(not(feature = "no_function"))] use crate::{ @@ -34,6 +34,9 @@ use crate::engine::{FN_IDX_GET, FN_IDX_SET}; #[cfg(not(feature = "no_object"))] use crate::engine::{Map, Target, FN_GET, FN_SET, KEYWORD_TAKE}; +#[cfg(not(feature = "no_shared"))] +use crate::engine::KEYWORD_SHARED; + use crate::stdlib::{ any::{type_name, TypeId}, boxed::Box, @@ -771,6 +774,7 @@ impl Engine { } // Handle shared() + #[cfg(not(feature = "no_shared"))] if 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)?; diff --git a/src/fn_native.rs b/src/fn_native.rs index f1e3a63c..f8bb0bf1 100644 --- a/src/fn_native.rs +++ b/src/fn_native.rs @@ -18,33 +18,46 @@ use crate::stdlib::{boxed::Box, convert::TryFrom, fmt, iter::empty, string::Stri use crate::stdlib::mem; #[cfg(not(feature = "sync"))] -use crate::stdlib::{rc::Rc, cell::RefCell}; +use crate::stdlib::rc::Rc; #[cfg(feature = "sync")] -use crate::stdlib::sync::{Arc, RwLock}; +use crate::stdlib::sync::Arc; + +#[cfg(not(feature = "no_shared"))] +#[cfg(not(feature = "sync"))] +use crate::stdlib::cell::RefCell; +#[cfg(not(feature = "no_shared"))] +#[cfg(feature = "sync")] +use crate::stdlib::sync::RwLock; /// Trait that maps to `Send + Sync` only under the `sync` feature. #[cfg(feature = "sync")] pub trait SendSync: Send + Sync {} +/// Trait that maps to `Send + Sync` only under the `sync` feature. #[cfg(feature = "sync")] impl SendSync for T {} /// Trait that maps to `Send + Sync` only under the `sync` feature. #[cfg(not(feature = "sync"))] pub trait SendSync {} +/// Trait that maps to `Send + Sync` only under the `sync` feature. #[cfg(not(feature = "sync"))] impl SendSync for T {} -/// Immutable reference counting container +/// Immutable reference-counted container #[cfg(not(feature = "sync"))] pub type Shared = Rc; +/// Immutable reference-counted container #[cfg(feature = "sync")] pub type Shared = Arc; -/// Mutable reference counting container(read-write lock) +/// Mutable reference-counted container (read-write lock) +#[cfg(not(feature = "no_shared"))] #[cfg(not(feature = "sync"))] -pub type SharedMut = Rc>; +pub type SharedMut = Shared>; +/// Mutable reference-counted container (read-write lock) +#[cfg(not(feature = "no_shared"))] #[cfg(feature = "sync")] -pub type SharedMut = Arc>; +pub type SharedMut = Shared>; /// Consume a `Shared` resource and return a mutable reference to the wrapped value. /// If the resource is shared (i.e. has other outstanding references), a cloned copy is used. diff --git a/src/token.rs b/src/token.rs index 367a1dcc..f5a160e3 100644 --- a/src/token.rs +++ b/src/token.rs @@ -2,7 +2,7 @@ use crate::engine::{ Engine, KEYWORD_DEBUG, KEYWORD_EVAL, KEYWORD_FN_PTR, KEYWORD_FN_PTR_CALL, KEYWORD_FN_PTR_CURRY, - KEYWORD_SHARED, KEYWORD_TAKE, KEYWORD_PRINT, KEYWORD_THIS, KEYWORD_TYPE_OF, + KEYWORD_PRINT, KEYWORD_SHARED, KEYWORD_TAKE, KEYWORD_THIS, KEYWORD_TYPE_OF, }; use crate::error::LexError; @@ -503,12 +503,12 @@ impl Token { "===" | "!==" | "->" | "<-" | "=>" | ":=" | "::<" | "(*" | "*)" | "#" | "public" | "new" | "use" | "module" | "package" | "var" | "static" | "with" | "do" | "each" | "then" | "goto" | "exit" | "switch" | "match" | "case" | "try" | "catch" - | "default" | "void" | "null" | "nil" | "spawn" | "go" | "sync" - | "async" | "await" | "yield" => Reserved(syntax.into()), + | "default" | "void" | "null" | "nil" | "spawn" | "go" | "sync" | "async" | "await" + | "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_SHARED | KEYWORD_TAKE + | KEYWORD_THIS => Reserved(syntax.into()), _ => return None, }) @@ -1439,7 +1439,7 @@ pub fn is_keyword_function(name: &str) -> bool { || name == KEYWORD_FN_PTR_CALL || name == KEYWORD_FN_PTR_CURRY; - #[cfg(not(feature = "no-shared"))] + #[cfg(not(feature = "no_shared"))] { result = result || name == KEYWORD_SHARED || name == KEYWORD_TAKE; }