diff --git a/src/engine.rs b/src/engine.rs index c94d1423..c3a7be8e 100644 --- a/src/engine.rs +++ b/src/engine.rs @@ -1783,7 +1783,6 @@ impl Engine { self.call_script_fn(&mut scope, state, lib, name, fn_def, args, level) .map_err(|err| EvalAltResult::new_position(err, *pos)) } - Ok(f) if f.is_plugin_fn() => f.get_plugin_fn().call(args.as_mut(), *pos), Ok(f) => { f.get_native_fn()(self, args.as_mut()).map_err(|err| err.new_position(*pos)) } diff --git a/src/fn_native.rs b/src/fn_native.rs index fc6e7673..b7805ff5 100644 --- a/src/fn_native.rs +++ b/src/fn_native.rs @@ -1,7 +1,6 @@ use crate::any::Dynamic; use crate::engine::Engine; use crate::parser::ScriptFnDef; -use crate::plugin::PluginFunction; use crate::result::EvalAltResult; use crate::stdlib::{boxed::Box, fmt, rc::Rc, sync::Arc}; @@ -60,11 +59,6 @@ pub type FnAny = pub type IteratorFn = fn(Dynamic) -> Box>; -#[cfg(feature = "sync")] -pub type SharedPluginFunction = Arc; -#[cfg(not(feature = "sync"))] -pub type SharedPluginFunction = Rc; - #[cfg(not(feature = "sync"))] pub type Callback = Box R + 'static>; #[cfg(feature = "sync")] @@ -80,8 +74,6 @@ pub enum CallableFunction { Method(Shared), /// An iterator function. Iterator(IteratorFn), - /// A plugin-defined function, - Plugin(SharedPluginFunction), /// A script-defined function. Script(Shared), } @@ -92,7 +84,6 @@ impl fmt::Debug for CallableFunction { Self::Pure(_) => write!(f, "NativePureFunction"), Self::Method(_) => write!(f, "NativeMethod"), Self::Iterator(_) => write!(f, "NativeIterator"), - Self::Plugin(_) => write!(f, "PluginFunction"), Self::Script(fn_def) => fmt::Debug::fmt(fn_def, f), } } @@ -104,7 +95,6 @@ impl CallableFunction { match self { Self::Pure(_) => true, Self::Method(_) | Self::Iterator(_) | Self::Script(_) => false, - Self::Plugin(_) => false, } } /// Is this a pure native Rust method-call? @@ -112,7 +102,6 @@ impl CallableFunction { match self { Self::Method(_) => true, Self::Pure(_) | Self::Iterator(_) | Self::Script(_) => false, - Self::Plugin(_) => false, } } /// Is this an iterator function? @@ -120,7 +109,6 @@ impl CallableFunction { match self { Self::Iterator(_) => true, Self::Pure(_) | Self::Method(_) | Self::Script(_) => false, - Self::Plugin(_) => false, } } /// Is this a Rhai-scripted function? @@ -128,14 +116,6 @@ impl CallableFunction { match self { Self::Script(_) => true, Self::Pure(_) | Self::Method(_) | Self::Iterator(_) => false, - Self::Plugin(_) => false, - } - } - /// Is this a plugin-defined function? - pub fn is_plugin_fn(&self) -> bool { - match self { - Self::Plugin(_) => true, - Self::Pure(_) | Self::Method(_) | Self::Iterator(_) | Self::Script(_) => false, } } /// Get a reference to a native Rust function. @@ -147,7 +127,6 @@ impl CallableFunction { match self { Self::Pure(f) | Self::Method(f) => f.as_ref(), Self::Iterator(_) | Self::Script(_) => panic!(), - Self::Plugin(_) => panic!(), } } /// Get a shared reference to a script-defined function definition. @@ -157,7 +136,7 @@ impl CallableFunction { /// Panics if the `CallableFunction` is not `Script`. pub fn get_shared_fn_def(&self) -> Shared { match self { - Self::Pure(_) | Self::Method(_) | Self::Plugin(_) | Self::Iterator(_) => panic!(), + Self::Pure(_) | Self::Method(_) | Self::Iterator(_) => panic!(), Self::Script(f) => f.clone(), } } @@ -170,7 +149,6 @@ impl CallableFunction { match self { Self::Pure(_) | Self::Method(_) | Self::Iterator(_) => panic!(), Self::Script(f) => f, - Self::Plugin(_) => panic!(), } } /// Get a reference to an iterator function. @@ -182,18 +160,6 @@ impl CallableFunction { match self { Self::Iterator(f) => *f, Self::Pure(_) | Self::Method(_) | Self::Script(_) => panic!(), - Self::Plugin(_) => panic!(), - } - } - /// Get a reference to a plugin function. - /// - /// # Panics - /// - /// Panics if the `CallableFunction` is not `Plugin`. - pub fn get_plugin_fn<'s>(&'s self) -> SharedPluginFunction { - match self { - Self::Plugin(f) => f.clone(), - Self::Pure(_) | Self::Method(_) | Self::Script(_) | Self::Iterator(_) => panic!(), } } /// Create a new `CallableFunction::Pure`. @@ -204,18 +170,6 @@ impl CallableFunction { pub fn from_method(func: Box) -> Self { Self::Method(func.into()) } - - #[cfg(feature = "sync")] - /// Create a new `CallableFunction::Plugin`. - pub fn from_plugin(plugin: impl PluginFunction + 'static + Send + Sync) -> Self { - Self::Plugin(Arc::new(plugin)) - } - - #[cfg(not(feature = "sync"))] - /// Create a new `CallableFunction::Plugin`. - pub fn from_plugin(plugin: impl PluginFunction + 'static) -> Self { - Self::Plugin(Rc::new(plugin)) - } } impl From for CallableFunction { diff --git a/src/fn_register.rs b/src/fn_register.rs index cf83ae14..1b07cbe8 100644 --- a/src/fn_register.rs +++ b/src/fn_register.rs @@ -5,91 +5,11 @@ use crate::any::{Dynamic, Variant}; use crate::engine::Engine; use crate::fn_native::{CallableFunction, FnAny, FnCallArgs, SendSync}; use crate::parser::FnAccess; -use crate::plugin::Plugin; use crate::result::EvalAltResult; use crate::utils::ImmutableString; use crate::stdlib::{any::TypeId, boxed::Box, mem}; -/// A trait to register custom plugins with the `Engine`. -/// -/// A plugin consists of a number of functions. All functions will be registered with the engine. -pub trait RegisterPlugin { - /// Allow extensions of the engine's behavior. - /// - /// This can include importing modules, registering functions to the global name space, and - /// more. - /// - /// # Example - /// - /// ``` - /// use rhai::{FLOAT, INT, Module, ModuleResolver, RegisterFn, RegisterPlugin}; - /// use rhai::plugin::*; - /// use rhai::module_resolvers::*; - /// - /// // A function we want to expose to Rhai. - /// #[derive(Copy, Clone)] - /// struct DistanceFunction(); - /// - /// impl PluginFunction for DistanceFunction { - /// fn is_method_call(&self) -> bool { false } - /// fn is_varadic(&self) -> bool { false } - /// - /// fn call(&self, args: &[&mut Dynamic], pos: Position) -> Result> { - /// let x1: &FLOAT = args[0].downcast_ref::().unwrap(); - /// let y1: &FLOAT = args[1].downcast_ref::().unwrap(); - /// let x2: &FLOAT = args[2].downcast_ref::().unwrap(); - /// let y2: &FLOAT = args[3].downcast_ref::().unwrap(); - /// let square_sum = (y2 - y1).abs().powf(2.0) + (x2 -x1).abs().powf(2.0); - /// Ok(Dynamic::from(square_sum.sqrt())) - /// } - /// - /// fn clone_boxed(&self) -> Box { - /// Box::new(DistanceFunction()) - /// } - /// } - /// - /// // A simple custom plugin. This should not usually be done with hand-written code. - /// #[derive(Copy, Clone)] - /// pub struct AdvancedMathPlugin(); - /// - /// impl Plugin for AdvancedMathPlugin { - /// fn register_contents(self, engine: &mut Engine) { - /// // Plugins are allowed to have side-effects on the engine. - /// engine.register_fn("get_mystic_number", || { 42 as FLOAT }); - /// - /// // Main purpose: create a module to expose the functions to Rhai. - /// // - /// // This is currently a hack. There needs to be a better API here for "plugin" - /// // modules. - /// let mut m = Module::new(); - /// m.set_fn("euclidean_distance".to_string(), FnAccess::Public, - /// &[std::any::TypeId::of::(), - /// std::any::TypeId::of::(), - /// std::any::TypeId::of::(), - /// std::any::TypeId::of::()], - /// CallableFunction::from_plugin(DistanceFunction())); - /// let mut r = StaticModuleResolver::new(); - /// r.insert("Math::Advanced".to_string(), m); - /// engine.set_module_resolver(Some(r)); - /// } - /// } - /// - /// - /// # fn main() -> Result<(), Box> { - /// - /// let mut engine = Engine::new(); - /// engine.register_plugin(AdvancedMathPlugin()); - /// - /// assert_eq!(engine.eval::( - /// r#"import "Math::Advanced" as math; - /// let x = math::euclidean_distance(0.0, 1.0, 0.0, get_mystic_number()); x"#)?, 41.0); - /// # Ok(()) - /// # } - /// ``` - fn register_plugin(&mut self, plugin: PL); -} - /// Trait to register custom functions with the `Engine`. pub trait RegisterFn { /// Register a custom function with the `Engine`. @@ -191,12 +111,6 @@ pub fn by_value(data: &mut Dynamic) -> T { } } -impl RegisterPlugin for Engine { - fn register_plugin(&mut self, plugin: PL) { - plugin.register_contents(self); - } -} - /// This macro creates a closure wrapping a registered function. macro_rules! make_func { ($fn:ident : $map:expr ; $($par:ident => $convert:expr),*) => { diff --git a/src/lib.rs b/src/lib.rs index e0f2245c..d4dedda3 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -79,10 +79,6 @@ pub mod fn_native; mod fn_register; mod module; mod optimize; -#[cfg(not(feature = "no_module"))] -pub mod plugin; -#[cfg(feature = "no_module")] -mod plugin; pub mod packages; mod parser; mod result; @@ -96,7 +92,6 @@ pub use any::Dynamic; pub use engine::Engine; pub use error::{ParseError, ParseErrorType}; pub use fn_register::{RegisterFn, RegisterResultFn}; -pub use fn_register::RegisterPlugin; pub use module::Module; pub use parser::{ImmutableString, AST, INT}; pub use result::EvalAltResult; diff --git a/src/plugin.rs b/src/plugin.rs deleted file mode 100644 index 8159d3c8..00000000 --- a/src/plugin.rs +++ /dev/null @@ -1,42 +0,0 @@ -//! Module defining plugins in Rhai. Is exported for use by plugin authors. - -pub use crate::Engine; -pub use crate::any::{Dynamic, Variant}; -pub use crate::fn_native::{CallableFunction, FnCallArgs, IteratorFn}; -pub use crate::parser::{ - FnAccess, - FnAccess::{Private, Public}, - AST, -}; -pub use crate::result::EvalAltResult; -pub use crate::scope::{Entry as ScopeEntry, EntryType as ScopeEntryType, Scope}; -pub use crate::token::{Position, Token}; -pub use crate::utils::StaticVec; - -#[cfg(features = "sync")] -/// Represents an externally-written plugin for the Rhai interpreter. -/// -/// This trait should not be used directly. Use the `#[plugin]` procedural attribute instead. -pub trait Plugin: Send { - fn register_contents(self, engine: &mut Engine); -} - -#[cfg(not(features = "sync"))] -/// Represents an externally-written plugin for the Rhai interpreter. -/// -/// This trait should not be used directly. Use the `#[plugin]` procedural attribute instead. -pub trait Plugin: Send + Sync { - fn register_contents(self, engine: &mut Engine); -} - -/// Represents a function that is statically defined within a plugin. -/// -/// This trait should not be used directly. Use the `#[plugin]` procedural attribute instead. -pub trait PluginFunction { - fn is_method_call(&self) -> bool; - fn is_varadic(&self) -> bool; - - fn call(&self, args: &[&mut Dynamic], pos: Position) -> Result>; - - fn clone_boxed(&self) -> Box; -}