kjuulh/rhai
1
0
Fork 0
Code Issues 1 Pull Requests 1 Packages Projects Releases Wiki Activity

Merge pull request #667 from schungx/master

Browse Source 
Code simplification and cleanup.
This commit is contained in:
Stephen Chung 2022-11-08 17:15:13 +08:00 committed by GitHub
commit 2a75d76d03
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
38 changed files with 1042 additions and 1041 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
CHANGELOG.md
View File

@ -41,6 +41,11 @@ New features
* `Scope` is now serializable and deserializable via `serde`.
### Store and recreate `NativeCallContext`
* A convenient API is added to store a `NativeCallContext` into a new `NativeCallContextStore` type.
* This allows a `NativeCallContext` to be stored and recreated later on.
### Call native Rust functions in `NativeCallContext`
* `NativeCallContext::call_native_fn` is added to call registered native Rust functions only.

24
src/api/call_fn.rs
View File

@ -3,9 +3,10 @@
use crate::eval::{Caches, GlobalRuntimeState};
use crate::types::dynamic::Variant;
use crate::types::RestoreOnDrop;
use crate::{
reify, Dynamic, Engine, FuncArgs, Position, RhaiResult, RhaiResultOf, Scope, StaticVec, AST,
ERR,
reify, Dynamic, Engine, FuncArgs, Position, RhaiResult, RhaiResultOf, Scope, SharedModule,
StaticVec, AST, ERR,
};
use std::any::{type_name, TypeId};
#[cfg(feature = "no_std")]
@ -248,8 +249,10 @@ impl Engine {
arg_values: &mut [Dynamic],
) -> RhaiResult {
let statements = ast.statements();
let lib = &[ast.as_ref()];
let mut this_ptr = this_ptr;
let lib = &[AsRef::<SharedModule>::as_ref(ast).clone()];
let mut no_this_ptr = Dynamic::NULL;
let mut this_ptr = this_ptr.unwrap_or(&mut no_this_ptr);
let orig_scope_len = scope.len();
@ -258,6 +261,10 @@ impl Engine {
&mut global.embedded_module_resolver,
ast.resolver().cloned(),
);
#[cfg(not(feature = "no_module"))]
let global = &mut *RestoreOnDrop::lock(global, move |g| {
g.embedded_module_resolver = orig_embedded_module_resolver
});
let result = if eval_ast && !statements.is_empty() {
let r = self.eval_global_statements(global, caches, lib, 0, scope, statements);
@ -293,14 +300,7 @@ impl Engine {
} else {
Err(ERR::ErrorFunctionNotFound(name.into(), Position::NONE).into())
}
});
#[cfg(not(feature = "no_module"))]
{
global.embedded_module_resolver = orig_embedded_module_resolver;
}
let result = result?;
})?;
#[cfg(feature = "debugging")]
if self.debugger.is_some() {

32
src/api/eval.rs
View File

@ -3,6 +3,7 @@
use crate::eval::{Caches, GlobalRuntimeState};
use crate::parser::ParseState;
use crate::types::dynamic::Variant;
use crate::types::RestoreOnDrop;
use crate::{
Dynamic, Engine, OptimizationLevel, Position, RhaiResult, RhaiResultOf, Scope, AST, ERR,
};
@ -195,10 +196,12 @@ impl Engine {
global.debugger.status = crate::eval::DebuggerStatus::Terminate;
let lib = &[
#[cfg(not(feature = "no_function"))]
ast.as_ref(),
AsRef::<crate::SharedModule>::as_ref(ast).clone(),
];
let mut this = Dynamic::NULL;
let node = &crate::ast::Stmt::Noop(Position::NONE);
self.run_debugger(global, caches, lib, 0, scope, &mut None, node)?;
self.run_debugger(global, caches, lib, 0, scope, &mut this, node)?;
}
let typ = self.map_type_name(result.type_name());
@ -225,6 +228,10 @@ impl Engine {
&mut global.embedded_module_resolver,
ast.resolver().cloned(),
);
#[cfg(not(feature = "no_module"))]
let global = &mut *RestoreOnDrop::lock(global, move |g| {
g.embedded_module_resolver = orig_embedded_module_resolver
});
let statements = ast.statements();
@ -232,23 +239,12 @@ impl Engine {
return Ok(Dynamic::UNIT);
}
let mut _lib = &[
let lib = &[
#[cfg(not(feature = "no_function"))]
ast.as_ref(),
][..];
#[cfg(not(feature = "no_function"))]
if !ast.has_functions() {
_lib = &[];
}
AsRef::<crate::SharedModule>::as_ref(ast).clone(),
];
let result = self.eval_global_statements(global, caches, _lib, level, scope, statements);
#[cfg(not(feature = "no_module"))]
{
global.embedded_module_resolver = orig_embedded_module_resolver;
}
result
self.eval_global_statements(global, caches, lib, level, scope, statements)
}
/// _(internals)_ Evaluate a list of statements with no `this` pointer.
/// Exported under the `internals` feature only.
@ -264,7 +260,7 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&crate::Module],
lib: &[crate::SharedModule],
level: usize,
scope: &mut Scope,
statements: &[crate::ast::Stmt],

9
src/api/register.rs
View File

@ -4,6 +4,7 @@ use crate::func::{FnCallArgs, RegisterNativeFunction, SendSync};
use crate::types::dynamic::Variant;
use crate::{
Engine, FnAccess, FnNamespace, Identifier, Module, NativeCallContext, RhaiResultOf, Shared,
SharedModule,
};
use std::any::{type_name, TypeId};
#[cfg(feature = "no_std")]
@ -636,7 +637,7 @@ impl Engine {
/// When searching for functions, modules loaded later are preferred. In other words, loaded
/// modules are searched in reverse order.
#[inline(always)]
pub fn register_global_module(&mut self, module: Shared<Module>) -> &mut Self {
pub fn register_global_module(&mut self, module: SharedModule) -> &mut Self {
// Insert the module into the front.
// The first module is always the global namespace.
self.global_modules.insert(1, module);
@ -680,12 +681,12 @@ impl Engine {
pub fn register_static_module(
&mut self,
name: impl AsRef<str>,
module: Shared<Module>,
module: SharedModule,
) -> &mut Self {
fn register_static_module_raw(
root: &mut std::collections::BTreeMap<Identifier, Shared<Module>>,
root: &mut std::collections::BTreeMap<Identifier, SharedModule>,
name: &str,
module: Shared<Module>,
module: SharedModule,
) {
let separator = crate::tokenizer::Token::DoubleColon.syntax();
let separator = separator.as_ref();

15
src/api/run.rs
View File

@ -2,7 +2,7 @@
use crate::eval::{Caches, GlobalRuntimeState};
use crate::parser::ParseState;
use crate::{Engine, Module, RhaiResultOf, Scope, AST};
use crate::{Engine, RhaiResultOf, Scope, SharedModule, AST};
#[cfg(feature = "no_std")]
use std::prelude::v1::*;
@ -122,12 +122,12 @@ impl Engine {
let statements = ast.statements();
if !statements.is_empty() {
let lib = [
let lib: &[SharedModule] = &[
#[cfg(not(feature = "no_function"))]
ast.as_ref(),
AsRef::<SharedModule>::as_ref(ast).clone(),
];
let lib = if lib.first().map_or(true, |m: &&Module| m.is_empty()) {
&lib[0..0]
let lib = if lib.first().map_or(true, |m| m.is_empty()) {
&[][..]
} else {
&lib
};
@ -139,10 +139,11 @@ impl Engine {
global.debugger.status = crate::eval::DebuggerStatus::Terminate;
let lib = &[
#[cfg(not(feature = "no_function"))]
ast.as_ref(),
AsRef::<crate::SharedModule>::as_ref(ast).clone(),
];
let mut this = crate::Dynamic::NULL;
let node = &crate::ast::Stmt::Noop(crate::Position::NONE);
self.run_debugger(global, caches, lib, 0, scope, &mut None, node)?;
self.run_debugger(global, caches, lib, 0, scope, &mut this, node)?;
}
Ok(())

22
src/ast/ast.rs
View File

@ -28,7 +28,7 @@ pub struct AST {
body: StmtBlock,
/// Script-defined functions.
#[cfg(not(feature = "no_function"))]
lib: crate::Shared<crate::Module>,
lib: crate::SharedModule,
/// Embedded module resolver, if any.
#[cfg(not(feature = "no_module"))]
resolver: Option<crate::Shared<crate::module::resolvers::StaticModuleResolver>>,
@ -74,7 +74,7 @@ impl AST {
#[must_use]
pub(crate) fn new(
statements: impl IntoIterator<Item = Stmt>,
#[cfg(not(feature = "no_function"))] functions: impl Into<crate::Shared<crate::Module>>,
#[cfg(not(feature = "no_function"))] functions: impl Into<crate::SharedModule>,
) -> Self {
Self {
source: None,
@ -94,7 +94,7 @@ impl AST {
#[must_use]
pub fn new(
statements: impl IntoIterator<Item = Stmt>,
#[cfg(not(feature = "no_function"))] functions: impl Into<crate::Shared<crate::Module>>,
#[cfg(not(feature = "no_function"))] functions: impl Into<crate::SharedModule>,
) -> Self {
Self {
source: None,
@ -113,7 +113,7 @@ impl AST {
#[must_use]
pub(crate) fn new_with_source(
statements: impl IntoIterator<Item = Stmt>,
#[cfg(not(feature = "no_function"))] functions: impl Into<crate::Shared<crate::Module>>,
#[cfg(not(feature = "no_function"))] functions: impl Into<crate::SharedModule>,
source: impl Into<ImmutableString>,
) -> Self {
let mut ast = Self::new(
@ -131,7 +131,7 @@ impl AST {
#[must_use]
pub fn new_with_source(
statements: impl IntoIterator<Item = Stmt>,
#[cfg(not(feature = "no_function"))] functions: impl Into<crate::Shared<crate::Module>>,
#[cfg(not(feature = "no_function"))] functions: impl Into<crate::SharedModule>,
source: impl Into<ImmutableString>,
) -> Self {
let mut ast = Self::new(
@ -267,7 +267,7 @@ impl AST {
#[cfg(not(feature = "no_function"))]
#[inline(always)]
#[must_use]
pub(crate) const fn shared_lib(&self) -> &crate::Shared<crate::Module> {
pub(crate) const fn shared_lib(&self) -> &crate::SharedModule {
&self.lib
}
/// _(internals)_ Get the internal shared [`Module`][crate::Module] containing all script-defined functions.
@ -278,7 +278,7 @@ impl AST {
#[cfg(not(feature = "no_function"))]
#[inline(always)]
#[must_use]
pub const fn shared_lib(&self) -> &crate::Shared<crate::Module> {
pub const fn shared_lib(&self) -> &crate::SharedModule {
&self.lib
}
/// Get the embedded [module resolver][crate::ModuleResolver].
@ -957,19 +957,19 @@ impl AsRef<crate::Module> for AST {
}
#[cfg(not(feature = "no_function"))]
impl Borrow<crate::Shared<crate::Module>> for AST {
impl Borrow<crate::SharedModule> for AST {
#[inline(always)]
#[must_use]
fn borrow(&self) -> &crate::Shared<crate::Module> {
fn borrow(&self) -> &crate::SharedModule {
self.shared_lib()
}
}
#[cfg(not(feature = "no_function"))]
impl AsRef<crate::Shared<crate::Module>> for AST {
impl AsRef<crate::SharedModule> for AST {
#[inline(always)]
#[must_use]
fn as_ref(&self) -> &crate::Shared<crate::Module> {
fn as_ref(&self) -> &crate::SharedModule {
self.shared_lib()
}
}

4
src/ast/script_fn.rs
View File

@ -20,9 +20,9 @@ use std::{fmt, hash::Hash};
#[derive(Debug, Clone)]
pub struct EncapsulatedEnviron {
/// Functions defined within the same [`AST`][crate::AST].
pub lib: crate::Shared<crate::Module>,
pub lib: crate::SharedModule,
/// Imported [modules][crate::Module].
pub imports: Box<[(ImmutableString, crate::Shared<crate::Module>)]>,
pub imports: Box<[(ImmutableString, crate::SharedModule)]>,
/// Globally-defined constants.
pub constants: Option<crate::eval::GlobalConstants>,
}

7
src/engine.rs
View File

@ -9,7 +9,8 @@ use crate::packages::{Package, StandardPackage};
use crate::tokenizer::Token;
use crate::types::StringsInterner;
use crate::{
Dynamic, Identifier, ImmutableString, Locked, Module, OptimizationLevel, Shared, StaticVec,
Dynamic, Identifier, ImmutableString, Locked, Module, OptimizationLevel, SharedModule,
StaticVec,
};
#[cfg(feature = "no_std")]
use std::prelude::v1::*;
@ -91,10 +92,10 @@ pub const OP_INCLUSIVE_RANGE: &str = Token::InclusiveRange.literal_syntax();
/// ```
pub struct Engine {
/// A collection of all modules loaded into the global namespace of the Engine.
pub(crate) global_modules: StaticVec<Shared<Module>>,
pub(crate) global_modules: StaticVec<SharedModule>,
/// A collection of all sub-modules directly loaded into the Engine.
#[cfg(not(feature = "no_module"))]
pub(crate) global_sub_modules: std::collections::BTreeMap<Identifier, Shared<Module>>,
pub(crate) global_sub_modules: std::collections::BTreeMap<Identifier, SharedModule>,
/// A module resolution service.
#[cfg(not(feature = "no_module"))]

8
src/eval/cache.rs
View File

@ -3,7 +3,6 @@
use crate::func::{CallableFunction, StraightHashMap};
use crate::types::BloomFilterU64;
use crate::{ImmutableString, StaticVec};
use std::marker::PhantomData;
#[cfg(feature = "no_std")]
use std::prelude::v1::*;
@ -45,21 +44,18 @@ impl FnResolutionCache {
/// The following caches are contained inside this type:
/// * A stack of [function resolution caches][FnResolutionCache]
#[derive(Debug, Clone)]
pub struct Caches<'a> {
pub struct Caches {
/// Stack of [function resolution caches][FnResolutionCache].
stack: StaticVec<FnResolutionCache>,
/// Take care of the lifetime parameter.
dummy: PhantomData<&'a ()>,
}
impl Caches<'_> {
impl Caches {
/// Create an empty [`Caches`].
#[inline(always)]
#[must_use]
pub const fn new() -> Self {
Self {
stack: StaticVec::new_const(),
dummy: PhantomData,
}
}
/// Get the number of function resolution cache(s) in the stack.

118
src/eval/chaining.rs
View File

@ -4,7 +4,10 @@
use super::{Caches, GlobalRuntimeState, Target};
use crate::ast::{ASTFlags, Expr, OpAssignment};
use crate::types::dynamic::Union;
use crate::{Dynamic, Engine, FnArgsVec, Module, Position, RhaiResult, RhaiResultOf, Scope, ERR};
use crate::types::RestoreOnDrop;
use crate::{
Dynamic, Engine, FnArgsVec, Position, RhaiResult, RhaiResultOf, Scope, SharedModule, ERR,
};
use std::hash::Hash;
#[cfg(feature = "no_std")]
use std::prelude::v1::*;
@ -40,9 +43,9 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
level: usize,
this_ptr: &mut Option<&mut Dynamic>,
this_ptr: &mut Dynamic,
target: &mut Target,
root: (&str, Position),
_parent: &Expr,
@ -198,29 +201,30 @@ impl Engine {
// xxx.fn_name(arg_expr_list)
Expr::MethodCall(x, pos) if !x.is_qualified() && new_val.is_none() => {
#[cfg(feature = "debugging")]
let reset_debugger = self.run_debugger_with_reset(
let reset = self.run_debugger_with_reset(
global, caches, lib, level, scope, this_ptr, rhs,
)?;
#[cfg(feature = "debugging")]
let global = &mut *RestoreOnDrop::lock(global, move |g| {
g.debugger.reset_status(reset)
});
let crate::ast::FnCallExpr {
name, hashes, args, ..
} = &**x;
// Truncate the index values upon exit
let offset = idx_values.len() - args.len();
let idx_values =
&mut *RestoreOnDrop::lock(idx_values, move |v| v.truncate(offset));
let call_args = &mut idx_values[offset..];
let pos1 = args.get(0).map_or(Position::NONE, Expr::position);
let result = self.make_method_call(
self.make_method_call(
global, caches, lib, level, name, *hashes, target, call_args, pos1,
*pos,
);
idx_values.truncate(offset);
#[cfg(feature = "debugging")]
global.debugger.reset_status(reset_debugger);
result
)
}
// xxx.fn_name(...) = ???
Expr::MethodCall(..) if new_val.is_some() => {
@ -376,29 +380,33 @@ impl Engine {
// {xxx:map}.fn_name(arg_expr_list)[expr] | {xxx:map}.fn_name(arg_expr_list).expr
Expr::MethodCall(ref x, pos) if !x.is_qualified() => {
#[cfg(feature = "debugging")]
let reset_debugger = self.run_debugger_with_reset(
let reset = self.run_debugger_with_reset(
global, caches, lib, level, scope, this_ptr, _node,
)?;
#[cfg(feature = "debugging")]
let global = &mut *RestoreOnDrop::lock(global, move |g| {
g.debugger.reset_status(reset)
});
let crate::ast::FnCallExpr {
name, hashes, args, ..
} = &**x;
// Truncate the index values upon exit
let offset = idx_values.len() - args.len();
let idx_values = &mut *RestoreOnDrop::lock(idx_values, move |v| {
v.truncate(offset)
});
let call_args = &mut idx_values[offset..];
let pos1 = args.get(0).map_or(Position::NONE, Expr::position);
let result = self.make_method_call(
self.make_method_call(
global, caches, lib, level, name, *hashes, target, call_args,
pos1, pos,
);
idx_values.truncate(offset);
#[cfg(feature = "debugging")]
global.debugger.reset_status(reset_debugger);
result?.0.into()
)?
.0
.into()
}
// {xxx:map}.module::fn_name(...) - syntax error
Expr::MethodCall(..) => unreachable!(
@ -502,32 +510,39 @@ impl Engine {
}
// xxx.fn_name(arg_expr_list)[expr] | xxx.fn_name(arg_expr_list).expr
Expr::MethodCall(ref f, pos) if !f.is_qualified() => {
#[cfg(feature = "debugging")]
let reset_debugger = self.run_debugger_with_reset(
global, caches, lib, level, scope, this_ptr, _node,
)?;
let val = {
#[cfg(feature = "debugging")]
let reset = self.run_debugger_with_reset(
global, caches, lib, level, scope, this_ptr, _node,
)?;
#[cfg(feature = "debugging")]
let global = &mut *RestoreOnDrop::lock(global, move |g| {
g.debugger.reset_status(reset)
});
let crate::ast::FnCallExpr {
name, hashes, args, ..
} = &**f;
let rhs_chain = rhs.into();
let crate::ast::FnCallExpr {
name, hashes, args, ..
} = &**f;
let offset = idx_values.len() - args.len();
let call_args = &mut idx_values[offset..];
let pos1 = args.get(0).map_or(Position::NONE, Expr::position);
// Truncate the index values upon exit
let offset = idx_values.len() - args.len();
let idx_values =
&mut *RestoreOnDrop::lock(idx_values, move |v| {
v.truncate(offset)
});
let result = self.make_method_call(
global, caches, lib, level, name, *hashes, target, call_args,
pos1, pos,
);
let call_args = &mut idx_values[offset..];
let pos1 = args.get(0).map_or(Position::NONE, Expr::position);
idx_values.truncate(offset);
self.make_method_call(
global, caches, lib, level, name, *hashes, target,
call_args, pos1, pos,
)?
.0
};
#[cfg(feature = "debugging")]
global.debugger.reset_status(reset_debugger);
let (val, _) = &mut result?;
let val = &mut val.into();
let rhs_chain = rhs.into();
self.eval_dot_index_chain_helper(
global, caches, lib, level, this_ptr, val, root, rhs, *options,
@ -555,10 +570,10 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
this_ptr: &mut Dynamic,
expr: &Expr,
new_val: &mut Option<(Dynamic, &OpAssignment)>,
) -> RhaiResult {
@ -615,9 +630,10 @@ impl Engine {
let obj_ptr = &mut target;
let root = (x.3.as_str(), *var_pos);
let mut this = Dynamic::NULL;
self.eval_dot_index_chain_helper(
global, caches, lib, level, &mut None, obj_ptr, root, expr, options, rhs,
global, caches, lib, level, &mut this, obj_ptr, root, expr, options, rhs,
idx_values, chain_type, new_val,
)
}
@ -646,10 +662,10 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
this_ptr: &mut Dynamic,
expr: &Expr,
parent_options: ASTFlags,
parent_chain_type: ChainType,
@ -758,7 +774,7 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
level: usize,
target: &mut Dynamic,
idx: &mut Dynamic,
@ -781,7 +797,7 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
level: usize,
target: &mut Dynamic,
idx: &mut Dynamic,
@ -805,7 +821,7 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
level: usize,
target: &'t mut Dynamic,
idx: &mut Dynamic,

21
src/eval/debugger.rs
View File

@ -4,7 +4,7 @@
use super::{Caches, EvalContext, GlobalRuntimeState};
use crate::ast::{ASTNode, Expr, Stmt};
use crate::{
Dynamic, Engine, EvalAltResult, ImmutableString, Module, Position, RhaiResultOf, Scope,
Dynamic, Engine, EvalAltResult, ImmutableString, Position, RhaiResultOf, Scope, SharedModule,
};
#[cfg(feature = "no_std")]
use std::prelude::v1::*;
@ -413,10 +413,10 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
this_ptr: &mut Dynamic,
node: impl Into<ASTNode<'a>>,
) -> RhaiResultOf<()> {
if self.debugger.is_some() {
@ -440,10 +440,10 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
this_ptr: &mut Dynamic,
node: impl Into<ASTNode<'a>>,
) -> RhaiResultOf<Option<DebuggerStatus>> {
if self.debugger.is_some() {
@ -463,10 +463,10 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
this_ptr: &mut Dynamic,
node: impl Into<ASTNode<'a>>,
) -> RhaiResultOf<Option<DebuggerStatus>> {
let node = node.into();
@ -510,17 +510,16 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
this_ptr: &mut Dynamic,
node: ASTNode<'a>,
event: DebuggerEvent,
) -> Result<Option<DebuggerStatus>, Box<crate::EvalAltResult>> {
let src = global.source_raw().cloned();
let src = src.as_ref().map(|s| s.as_str());
let context =
crate::EvalContext::new(self, global, Some(caches), lib, level, scope, this_ptr);
let context = crate::EvalContext::new(self, global, caches, lib, level, scope, this_ptr);
if let Some((.., ref on_debugger)) = self.debugger {
let command = on_debugger(context, event, node, src, node.position())?;

59
src/eval/eval_context.rs
View File

@ -1,42 +1,42 @@
//! Evaluation context.
use super::{Caches, GlobalRuntimeState};
use crate::{Dynamic, Engine, Module, Scope};
use crate::{Dynamic, Engine, Module, Scope, SharedModule};
#[cfg(feature = "no_std")]
use std::prelude::v1::*;
/// Context of a script evaluation process.
#[derive(Debug)]
#[allow(dead_code)]
pub struct EvalContext<'a, 's, 'ps, 'g, 'pg, 'c, 'pc, 't, 'pt> {
pub struct EvalContext<'a, 's, 'ps, 'g, 'c, 't> {
/// The current [`Engine`].
engine: &'a Engine,
/// The current [`Scope`].
scope: &'s mut Scope<'ps>,
/// The current [`GlobalRuntimeState`].
global: &'g mut GlobalRuntimeState<'pg>,
global: &'g mut GlobalRuntimeState,
/// The current [caches][Caches], if available.
caches: Option<&'c mut Caches<'pc>>,
caches: &'c mut Caches,
/// The current stack of imported [modules][Module].
lib: &'a [&'a Module],
lib: &'a [SharedModule],
/// The current bound `this` pointer, if any.
this_ptr: &'t mut Option<&'pt mut Dynamic>,
this_ptr: &'t mut Dynamic,
/// The current nesting level of function calls.
level: usize,
}
impl<'a, 's, 'ps, 'g, 'pg, 'c, 'pc, 't, 'pt> EvalContext<'a, 's, 'ps, 'g, 'pg, 'c, 'pc, 't, 'pt> {
impl<'a, 's, 'ps, 'g, 'c, 't> EvalContext<'a, 's, 'ps, 'g, 'c, 't> {
/// Create a new [`EvalContext`].
#[inline(always)]
#[must_use]
pub fn new(
engine: &'a Engine,
global: &'g mut GlobalRuntimeState<'pg>,
caches: Option<&'c mut Caches<'pc>>,
lib: &'a [&'a Module],
global: &'g mut GlobalRuntimeState,
caches: &'c mut Caches,
lib: &'a [SharedModule],
level: usize,
scope: &'s mut Scope<'ps>,
this_ptr: &'t mut Option<&'pt mut Dynamic>,
this_ptr: &'t mut Dynamic,
) -> Self {
Self {
engine,
@ -104,33 +104,41 @@ impl<'a, 's, 'ps, 'g, 'pg, 'c, 'pc, 't, 'pt> EvalContext<'a, 's, 'ps, 'g, 'pg, '
#[cfg(feature = "internals")]
#[inline(always)]
#[must_use]
pub fn global_runtime_state_mut(&mut self) -> &mut &'g mut GlobalRuntimeState<'pg> {
&mut self.global
pub fn global_runtime_state_mut(&mut self) -> &mut GlobalRuntimeState {
self.global
}
/// Get an iterator over the namespaces containing definition of all script-defined functions.
#[inline]
pub fn iter_namespaces(&self) -> impl Iterator<Item = &Module> {
self.lib.iter().copied()
self.lib.iter().map(|m| m.as_ref())
}
/// _(internals)_ The current set of namespaces containing definitions of all script-defined functions.
/// Exported under the `internals` feature only.
#[cfg(feature = "internals")]
#[inline(always)]
#[must_use]
pub const fn namespaces(&self) -> &[&Module] {
pub const fn namespaces(&self) -> &[SharedModule] {
self.lib
}
/// The current bound `this` pointer, if any.
#[inline(always)]
#[inline]
#[must_use]
pub fn this_ptr(&self) -> Option<&Dynamic> {
self.this_ptr.as_ref().map(|v| &**v)
if self.this_ptr.is_null() {
None
} else {
Some(self.this_ptr)
}
}
/// Mutable reference to the current bound `this` pointer, if any.
#[inline(always)]
#[inline]
#[must_use]
pub fn this_ptr_mut(&mut self) -> &mut Option<&'pt mut Dynamic> {
self.this_ptr
pub fn this_ptr_mut(&mut self) -> Option<&mut Dynamic> {
if self.this_ptr.is_null() {
None
} else {
Some(self.this_ptr)
}
}
/// The current nesting level of function calls.
#[inline(always)]
@ -173,17 +181,10 @@ impl<'a, 's, 'ps, 'g, 'pg, 'c, 'pc, 't, 'pt> EvalContext<'a, 's, 'ps, 'g, 'pg, '
) -> crate::RhaiResult {
let expr: &crate::ast::Expr = expr;
let mut new_caches = Caches::new();
let caches = match self.caches.as_mut() {
Some(c) => c,
None => &mut new_caches,
};
match expr {
crate::ast::Expr::Stmt(statements) => self.engine.eval_stmt_block(
self.global,
caches,
self.caches,
self.lib,
self.level,
self.scope,
@ -193,7 +194,7 @@ impl<'a, 's, 'ps, 'g, 'pg, 'c, 'pc, 't, 'pt> EvalContext<'a, 's, 'ps, 'g, 'pg, '
),
_ => self.engine.eval_expr(
self.global,
caches,
self.caches,
self.lib,
self.level,
self.scope,

142
src/eval/expr.rs
View File

@ -4,7 +4,7 @@ use super::{Caches, EvalContext, GlobalRuntimeState, Target};
use crate::ast::{Expr, OpAssignment};
use crate::engine::{KEYWORD_THIS, OP_CONCAT};
use crate::types::dynamic::AccessMode;
use crate::{Dynamic, Engine, Module, Position, RhaiResult, RhaiResultOf, Scope, ERR};
use crate::{Dynamic, Engine, Position, RhaiResult, RhaiResultOf, Scope, SharedModule, ERR};
use std::num::NonZeroUsize;
#[cfg(feature = "no_std")]
use std::prelude::v1::*;
@ -18,7 +18,7 @@ impl Engine {
&self,
global: &GlobalRuntimeState,
namespace: &crate::ast::Namespace,
) -> Option<crate::Shared<Module>> {
) -> Option<SharedModule> {
assert!(!namespace.is_empty());
let root = namespace.root();
@ -51,10 +51,10 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
level: usize,
scope: &'s mut Scope,
this_ptr: &'s mut Option<&mut Dynamic>,
this_ptr: &'s mut Dynamic,
expr: &Expr,
) -> RhaiResultOf<(Target<'s>, Position)> {
match expr {
@ -137,10 +137,10 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
level: usize,
scope: &'s mut Scope,
this_ptr: &'s mut Option<&mut Dynamic>,
this_ptr: &'s mut Dynamic,
expr: &Expr,
) -> RhaiResultOf<(Target<'s>, Position)> {
// Make sure that the pointer indirection is taken only when absolutely necessary.
@ -148,10 +148,11 @@ impl Engine {
let (index, var_pos) = match expr {
// Check if the variable is `this`
Expr::Variable(v, None, pos) if v.0.is_none() && v.3 == KEYWORD_THIS => {
return this_ptr.as_mut().map_or_else(
|| Err(ERR::ErrorUnboundThis(*pos).into()),
|val| Ok(((*val).into(), *pos)),
)
return if this_ptr.is_null() {
Err(ERR::ErrorUnboundThis(*pos).into())
} else {
Ok((this_ptr.into(), *pos))
};
}
_ if global.always_search_scope => (0, expr.start_position()),
Expr::Variable(.., Some(i), pos) => (i.get() as usize, *pos),
@ -160,7 +161,7 @@ impl Engine {
Expr::Variable(v, None, pos)
if lib
.iter()
.flat_map(|&m| m.iter_script_fn())
.flat_map(|m| m.iter_script_fn())
.any(|(_, _, f, ..)| f == v.3.as_str()) =>
{
let val: Dynamic =
@ -173,7 +174,7 @@ impl Engine {
// Check the variable resolver, if any
if let Some(ref resolve_var) = self.resolve_var {
let context = EvalContext::new(self, global, Some(caches), lib, level, scope, this_ptr);
let context = EvalContext::new(self, global, caches, lib, level, scope, this_ptr);
let var_name = expr.get_variable_name(true).expect("`Expr::Variable`");
match resolve_var(var_name, index, context) {
Ok(Some(mut result)) => {
@ -221,10 +222,10 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
this_ptr: &mut Dynamic,
expr: &Expr,
) -> RhaiResult {
// Coded this way for better branch prediction.
@ -234,18 +235,16 @@ impl Engine {
// binary operators are also function calls.
if let Expr::FnCall(x, pos) = expr {
#[cfg(feature = "debugging")]
let reset_debugger =
let reset =
self.run_debugger_with_reset(global, caches, lib, level, scope, this_ptr, expr)?;
#[cfg(feature = "debugging")]
let global = &mut *crate::types::RestoreOnDrop::lock(global, move |g| {
g.debugger.reset_status(reset)
});
self.track_operation(global, expr.position())?;
let result =
self.eval_fn_call_expr(global, caches, lib, level, scope, this_ptr, x, *pos);
#[cfg(feature = "debugging")]
global.debugger.reset_status(reset_debugger);
return result;
return self.eval_fn_call_expr(global, caches, lib, level, scope, this_ptr, x, *pos);
}
// Then variable access.
@ -258,10 +257,11 @@ impl Engine {
self.track_operation(global, expr.position())?;
return if index.is_none() && x.0.is_none() && x.3 == KEYWORD_THIS {
this_ptr
.as_deref()
.cloned()
.ok_or_else(|| ERR::ErrorUnboundThis(*var_pos).into())
if this_ptr.is_null() {
ERR::ErrorUnboundThis(*var_pos).into()
} else {
Ok(this_ptr.clone())
}
} else {
self.search_namespace(global, caches, lib, level, scope, this_ptr, expr)
.map(|(val, ..)| val.take_or_clone())
@ -269,12 +269,16 @@ impl Engine {
}
#[cfg(feature = "debugging")]
let reset_debugger =
let reset =
self.run_debugger_with_reset(global, caches, lib, level, scope, this_ptr, expr)?;
#[cfg(feature = "debugging")]
let global = &mut *crate::types::RestoreOnDrop::lock(global, move |g| {
g.debugger.reset_status(reset)
});
self.track_operation(global, expr.position())?;
let result = match expr {
match expr {
// Constants
Expr::DynamicConstant(x, ..) => Ok(x.as_ref().clone()),
Expr::IntegerConstant(x, ..) => Ok((*x).into()),
@ -374,60 +378,33 @@ impl Engine {
.map(Into::into)
}
Expr::And(x, ..) => {
let lhs = self
.eval_expr(global, caches, lib, level, scope, this_ptr, &x.lhs)
.and_then(|v| {
v.as_bool().map_err(|typ| {
self.make_type_mismatch_err::<bool>(typ, x.lhs.position())
})
});
Expr::And(x, ..) => Ok((self
.eval_expr(global, caches, lib, level, scope, this_ptr, &x.lhs)?
.as_bool()
.map_err(|typ| self.make_type_mismatch_err::<bool>(typ, x.lhs.position()))?
&& self
.eval_expr(global, caches, lib, level, scope, this_ptr, &x.rhs)?
.as_bool()
.map_err(|typ| self.make_type_mismatch_err::<bool>(typ, x.rhs.position()))?)
.into()),
match lhs {
Ok(true) => self
.eval_expr(global, caches, lib, level, scope, this_ptr, &x.rhs)
.and_then(|v| {
v.as_bool()
.map_err(|typ| {
self.make_type_mismatch_err::<bool>(typ, x.rhs.position())
})
.map(Into::into)
}),
_ => lhs.map(Into::into),
}
}
Expr::Or(x, ..) => {
let lhs = self
.eval_expr(global, caches, lib, level, scope, this_ptr, &x.lhs)
.and_then(|v| {
v.as_bool().map_err(|typ| {
self.make_type_mismatch_err::<bool>(typ, x.lhs.position())
})
});
match lhs {
Ok(false) => self
.eval_expr(global, caches, lib, level, scope, this_ptr, &x.rhs)
.and_then(|v| {
v.as_bool()
.map_err(|typ| {
self.make_type_mismatch_err::<bool>(typ, x.rhs.position())
})
.map(Into::into)
}),
_ => lhs.map(Into::into),
}
}
Expr::Or(x, ..) => Ok((self
.eval_expr(global, caches, lib, level, scope, this_ptr, &x.lhs)?
.as_bool()
.map_err(|typ| self.make_type_mismatch_err::<bool>(typ, x.lhs.position()))?
|| self
.eval_expr(global, caches, lib, level, scope, this_ptr, &x.rhs)?
.as_bool()
.map_err(|typ| self.make_type_mismatch_err::<bool>(typ, x.rhs.position()))?)
.into()),
Expr::Coalesce(x, ..) => {
let lhs = self.eval_expr(global, caches, lib, level, scope, this_ptr, &x.lhs);
let value = self.eval_expr(global, caches, lib, level, scope, this_ptr, &x.lhs)?;
match lhs {
Ok(value) if value.is::<()>() => {
self.eval_expr(global, caches, lib, level, scope, this_ptr, &x.rhs)
}
_ => lhs,
if value.is::<()>() {
self.eval_expr(global, caches, lib, level, scope, this_ptr, &x.rhs)
} else {
Ok(value)
}
}
@ -446,7 +423,7 @@ impl Engine {
))
})?;
let mut context =
EvalContext::new(self, global, Some(caches), lib, level, scope, this_ptr);
EvalContext::new(self, global, caches, lib, level, scope, this_ptr);
let result = (custom_def.func)(&mut context, &expressions, &custom.state);
@ -467,11 +444,6 @@ impl Engine {
.eval_dot_index_chain(global, caches, lib, level, scope, this_ptr, expr, &mut None),
_ => unreachable!("expression cannot be evaluated: {:?}", expr),
};
#[cfg(feature = "debugging")]
global.debugger.reset_status(reset_debugger);
result
}
}
}

40
src/eval/global_state.rs
View File

@ -1,9 +1,9 @@
//! Global runtime state.
use crate::{Dynamic, Engine, ImmutableString};
use std::fmt;
#[cfg(feature = "no_std")]
use std::prelude::v1::*;
use std::{fmt, marker::PhantomData};
/// Collection of globally-defined constants.
#[cfg(not(feature = "no_module"))]
@ -22,13 +22,13 @@ pub type GlobalConstants =
// Most usage will be looking up a particular key from the list and then getting the module that
// corresponds to that key.
#[derive(Clone)]
pub struct GlobalRuntimeState<'a> {
pub struct GlobalRuntimeState {
/// Names of imported [modules][crate::Module].
#[cfg(not(feature = "no_module"))]
imports: crate::StaticVec<ImmutableString>,
/// Stack of imported [modules][crate::Module].
#[cfg(not(feature = "no_module"))]
modules: crate::StaticVec<crate::Shared<crate::Module>>,
modules: crate::StaticVec<crate::SharedModule>,
/// Source of the current context.
///
/// No source if the string is empty.
@ -70,11 +70,9 @@ pub struct GlobalRuntimeState<'a> {
/// Debugging interface.
#[cfg(feature = "debugging")]
pub debugger: super::Debugger,
/// Take care of the lifetime parameter.
dummy: PhantomData<&'a ()>,
}
impl GlobalRuntimeState<'_> {
impl GlobalRuntimeState {
/// Create a new [`GlobalRuntimeState`] based on an [`Engine`].
#[inline(always)]
#[must_use]
@ -112,8 +110,6 @@ impl GlobalRuntimeState<'_> {
None => Dynamic::UNIT,
},
),
dummy: PhantomData::default(),
}
}
/// Get the length of the stack of globally-imported [modules][crate::Module].
@ -131,7 +127,7 @@ impl GlobalRuntimeState<'_> {
#[cfg(not(feature = "no_module"))]
#[inline(always)]
#[must_use]
pub fn get_shared_import(&self, index: usize) -> Option<crate::Shared<crate::Module>> {
pub fn get_shared_import(&self, index: usize) -> Option<crate::SharedModule> {
self.modules.get(index).cloned()
}
/// Get a mutable reference to the globally-imported [module][crate::Module] at a
@ -145,7 +141,7 @@ impl GlobalRuntimeState<'_> {
pub(crate) fn get_shared_import_mut(
&mut self,
index: usize,
) -> Option<&mut crate::Shared<crate::Module>> {
) -> Option<&mut crate::SharedModule> {
self.modules.get_mut(index)
}
/// Get the index of a globally-imported [module][crate::Module] by name.
@ -169,7 +165,7 @@ impl GlobalRuntimeState<'_> {
pub fn push_import(
&mut self,
name: impl Into<ImmutableString>,
module: impl Into<crate::Shared<crate::Module>>,
module: impl Into<crate::SharedModule>,
) {
self.imports.push(name.into());
self.modules.push(module.into());
@ -202,7 +198,7 @@ impl GlobalRuntimeState<'_> {
#[inline]
pub(crate) fn iter_imports_raw(
&self,
) -> impl Iterator<Item = (&ImmutableString, &crate::Shared<crate::Module>)> {
) -> impl Iterator<Item = (&ImmutableString, &crate::SharedModule)> {
self.imports.iter().zip(self.modules.iter()).rev()
}
/// Get an iterator to the stack of globally-imported [modules][crate::Module] in forward order.
@ -212,7 +208,7 @@ impl GlobalRuntimeState<'_> {
#[inline]
pub fn scan_imports_raw(
&self,
) -> impl Iterator<Item = (&ImmutableString, &crate::Shared<crate::Module>)> {
) -> impl Iterator<Item = (&ImmutableString, &crate::SharedModule)> {
self.imports.iter().zip(self.modules.iter())
}
/// Can the particular function with [`Dynamic`] parameter(s) exist in the stack of
@ -319,12 +315,12 @@ impl GlobalRuntimeState<'_> {
}
#[cfg(not(feature = "no_module"))]
impl IntoIterator for GlobalRuntimeState<'_> {
type Item = (ImmutableString, crate::Shared<crate::Module>);
impl IntoIterator for GlobalRuntimeState {
type Item = (ImmutableString, crate::SharedModule);
type IntoIter = std::iter::Rev<
std::iter::Zip<
smallvec::IntoIter<[ImmutableString; crate::STATIC_VEC_INLINE_SIZE]>,
smallvec::IntoIter<[crate::Shared<crate::Module>; crate::STATIC_VEC_INLINE_SIZE]>,
smallvec::IntoIter<[crate::SharedModule; crate::STATIC_VEC_INLINE_SIZE]>,
>,
>;
@ -334,12 +330,12 @@ impl IntoIterator for GlobalRuntimeState<'_> {
}
#[cfg(not(feature = "no_module"))]
impl<'a> IntoIterator for &'a GlobalRuntimeState<'_> {
type Item = (&'a ImmutableString, &'a crate::Shared<crate::Module>);
impl<'a> IntoIterator for &'a GlobalRuntimeState {
type Item = (&'a ImmutableString, &'a crate::SharedModule);
type IntoIter = std::iter::Rev<
std::iter::Zip<
std::slice::Iter<'a, ImmutableString>,
std::slice::Iter<'a, crate::Shared<crate::Module>>,
std::slice::Iter<'a, crate::SharedModule>,
>,
>;
@ -349,9 +345,7 @@ impl<'a> IntoIterator for &'a GlobalRuntimeState<'_> {
}
#[cfg(not(feature = "no_module"))]
impl<K: Into<ImmutableString>, M: Into<crate::Shared<crate::Module>>> Extend<(K, M)>
for GlobalRuntimeState<'_>
{
impl<K: Into<ImmutableString>, M: Into<crate::SharedModule>> Extend<(K, M)> for GlobalRuntimeState {
#[inline]
fn extend<T: IntoIterator<Item = (K, M)>>(&mut self, iter: T) {
for (k, m) in iter {
@ -361,7 +355,7 @@ impl<K: Into<ImmutableString>, M: Into<crate::Shared<crate::Module>>> Extend<(K,
}
}
impl fmt::Debug for GlobalRuntimeState<'_> {
impl fmt::Debug for GlobalRuntimeState {
#[cold]
#[inline(never)]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

909
src/eval/stmt.rs
View File

File diff suppressed because it is too large Load Diff

199
src/func/call.rs
View File

@ -9,9 +9,10 @@ use crate::engine::{
};
use crate::eval::{Caches, FnResolutionCacheEntry, GlobalRuntimeState};
use crate::tokenizer::{is_valid_function_name, Token};
use crate::types::RestoreOnDrop;
use crate::{
calc_fn_hash, calc_fn_hash_full, Dynamic, Engine, FnArgsVec, FnPtr, ImmutableString, Module,
OptimizationLevel, Position, RhaiError, RhaiResult, RhaiResultOf, Scope, ERR,
calc_fn_hash, calc_fn_hash_full, Dynamic, Engine, FnArgsVec, FnPtr, ImmutableString,
OptimizationLevel, Position, RhaiError, RhaiResult, RhaiResultOf, Scope, SharedModule, ERR,
};
#[cfg(feature = "no_std")]
use hashbrown::hash_map::Entry;
@ -88,9 +89,11 @@ impl<'a> ArgBackup<'a> {
/// If `change_first_arg_to_copy` has been called, this function **MUST** be called _BEFORE_
/// exiting the current scope. Otherwise it is undefined behavior as the shorter lifetime will leak.
#[inline(always)]
pub fn restore_first_arg(mut self, args: &mut FnCallArgs<'a>) {
pub fn restore_first_arg(&mut self, args: &mut FnCallArgs<'a>) {
if let Some(p) = self.orig_mut.take() {
args[0] = p;
} else {
unreachable!("`Some`");
}
}
}
@ -166,7 +169,7 @@ impl Engine {
_global: &GlobalRuntimeState,
caches: &'s mut Caches,
local_entry: &'s mut Option<FnResolutionCacheEntry>,
lib: &[&Module],
lib: &[SharedModule],
op_token: Option<&Token>,
hash_base: u64,
args: Option<&mut FnCallArgs>,
@ -193,8 +196,7 @@ impl Engine {
loop {
let func = lib
.iter()
.copied()
.chain(self.global_modules.iter().map(|m| m.as_ref()))
.chain(self.global_modules.iter())
.find_map(|m| m.get_fn(hash).map(|f| (f, m.id_raw())));
#[cfg(not(feature = "no_module"))]
@ -323,12 +325,12 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
level: usize,
name: &str,
op_token: Option<&Token>,
hash: u64,
args: &mut FnCallArgs,
mut args: &mut FnCallArgs,
is_ref_mut: bool,
pos: Position,
) -> RhaiResultOf<(Dynamic, bool)> {
@ -355,48 +357,45 @@ impl Engine {
#[cfg(feature = "debugging")]
let orig_call_stack_len = global.debugger.call_stack().len();
let mut _result = if let Some(FnResolutionCacheEntry { func, source }) = func {
assert!(func.is_native());
let FnResolutionCacheEntry { func, source } = func.unwrap();
assert!(func.is_native());
let mut backup = ArgBackup::new();
let backup = &mut ArgBackup::new();
// Calling pure function but the first argument is a reference?
if is_ref_mut && func.is_pure() && !args.is_empty() {
// Clone the first argument
backup.change_first_arg_to_copy(args);
}
// Calling pure function but the first argument is a reference?
let swap = is_ref_mut && func.is_pure() && !args.is_empty();
#[cfg(feature = "debugging")]
if self.debugger.is_some() {
global.debugger.push_call_stack_frame(
self.get_interned_string(name),
args.iter().map(|v| (*v).clone()).collect(),
source.clone().or_else(|| global.source.clone()),
pos,
);
}
if swap {
// Clone the first argument
backup.change_first_arg_to_copy(args);
}
// Run external function
let src = source.as_ref().map(|s| s.as_str());
let context = (self, name, src, &*global, lib, pos, level).into();
let args =
&mut *RestoreOnDrop::lock_if(swap, &mut args, move |a| backup.restore_first_arg(a));
let result = if func.is_plugin_fn() {
let f = func.get_plugin_fn().unwrap();
if !f.is_pure() && !args.is_empty() && args[0].is_read_only() {
Err(ERR::ErrorNonPureMethodCallOnConstant(name.to_string(), pos).into())
} else {
f.call(context, args)
}
#[cfg(feature = "debugging")]
if self.debugger.is_some() {
global.debugger.push_call_stack_frame(
self.get_interned_string(name),
args.iter().map(|v| (*v).clone()).collect(),
source.clone().or_else(|| global.source.clone()),
pos,
);
}
// Run external function
let src = source.as_ref().map(|s| s.as_str());
let context = (self, name, src, &*global, lib, pos, level).into();
let mut _result = if func.is_plugin_fn() {
let f = func.get_plugin_fn().unwrap();
if !f.is_pure() && !args.is_empty() && args[0].is_read_only() {
Err(ERR::ErrorNonPureMethodCallOnConstant(name.to_string(), pos).into())
} else {
func.get_native_fn().unwrap()(context, args)
};
// Restore the original reference
backup.restore_first_arg(args);
result
f.call(context, args)
}
} else {
unreachable!("`Some`");
func.get_native_fn().unwrap()(context, args)
};
#[cfg(feature = "debugging")]
@ -408,17 +407,18 @@ impl Engine {
};
if trigger {
let scope = &mut &mut Scope::new();
let mut this = Dynamic::NULL;
let node = crate::ast::Stmt::Noop(pos);
let node = (&node).into();
let event = match _result {
Ok(ref r) => crate::eval::DebuggerEvent::FunctionExitWithValue(r),
Err(ref err) => crate::eval::DebuggerEvent::FunctionExitWithError(err),
};
match self
.run_debugger_raw(global, caches, lib, level, scope, &mut None, node, event)
if let Err(err) = self
.run_debugger_raw(global, caches, lib, level, scope, &mut this, node, event)
{
Ok(_) => (),
Err(err) => _result = Err(err),
_result = Err(err);
}
}
@ -538,13 +538,13 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
level: usize,
_scope: Option<&mut Scope>,
fn_name: &str,
op_token: Option<&Token>,
hashes: FnCallHashes,
args: &mut FnCallArgs,
mut args: &mut FnCallArgs,
is_ref_mut: bool,
_is_method_call: bool,
pos: Position,
@ -586,7 +586,7 @@ impl Engine {
} else {
let hash_script =
calc_fn_hash(None, fn_name.as_str(), num_params as usize);
self.has_script_fn(Some(global), caches, lib, hash_script)
self.has_script_fn(global, caches, lib, hash_script)
}
.into(),
false,
@ -614,19 +614,11 @@ impl Engine {
#[cfg(not(feature = "no_function"))]
if !hashes.is_native_only() {
// Script-defined function call?
let hash = hashes.script();
let local_entry = &mut None;
if let Some(FnResolutionCacheEntry { func, ref source }) = self
.resolve_fn(
global,
caches,
local_entry,
lib,
None,
hashes.script(),
None,
false,
)
.resolve_fn(global, caches, local_entry, lib, None, hash, None, false)
.cloned()
{
// Script function call
@ -648,46 +640,37 @@ impl Engine {
};
let orig_source = mem::replace(&mut global.source, source.clone());
let global = &mut *RestoreOnDrop::lock(global, move |g| g.source = orig_source);
let result = if _is_method_call {
return if _is_method_call {
// Method call of script function - map first argument to `this`
let (first_arg, rest_args) = args.split_first_mut().unwrap();
self.call_script_fn(
global,
caches,
lib,
level,
scope,
&mut Some(*first_arg),
func,
rest_args,
true,
pos,
global, caches, lib, level, scope, first_arg, func, rest_args, true, pos,
)
} else {
// Normal call of script function
let mut backup = ArgBackup::new();
let backup = &mut ArgBackup::new();
// The first argument is a reference?
if is_ref_mut && !args.is_empty() {
let swap = is_ref_mut && !args.is_empty();
if swap {
backup.change_first_arg_to_copy(args);
}
let result = self.call_script_fn(
global, caches, lib, level, scope, &mut None, func, args, true, pos,
);
let args = &mut *RestoreOnDrop::lock_if(swap, &mut args, move |a| {
backup.restore_first_arg(a)
});
// Restore the original reference
backup.restore_first_arg(args);
let mut this = Dynamic::NULL;
result
};
// Restore the original source
global.source = orig_source;
return result.map(|r| (r, false));
self.call_script_fn(
global, caches, lib, level, scope, &mut this, func, args, true, pos,
)
}
.map(|r| (r, false));
}
}
@ -705,10 +688,10 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
this_ptr: &mut Dynamic,
arg_expr: &Expr,
) -> RhaiResultOf<(Dynamic, Position)> {
// Literal values
@ -723,17 +706,14 @@ impl Engine {
// Do not match function exit for arguments
#[cfg(feature = "debugging")]
let reset_debugger = global.debugger.clear_status_if(|status| {
let reset = global.debugger.clear_status_if(|status| {
matches!(status, crate::eval::DebuggerStatus::FunctionExit(..))
});
let result = self.eval_expr(global, caches, lib, level, scope, this_ptr, arg_expr);
// Restore function exit status
#[cfg(feature = "debugging")]
global.debugger.reset_status(reset_debugger);
let global = &mut *RestoreOnDrop::lock(global, move |g| g.debugger.reset_status(reset));
result.map(|r| (r, arg_expr.start_position()))
self.eval_expr(global, caches, lib, level, scope, this_ptr, arg_expr)
.map(|r| (r, arg_expr.start_position()))
}
/// Call a dot method.
@ -742,7 +722,7 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
level: usize,
fn_name: &str,
mut hash: FnCallHashes,
@ -967,10 +947,10 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
this_ptr: &mut Dynamic,
fn_name: &str,
op_token: Option<&Token>,
first_arg: Option<&Expr>,
@ -1101,7 +1081,7 @@ impl Engine {
false
} else {
let hash_script = calc_fn_hash(None, &fn_name, num_params as usize);
self.has_script_fn(Some(global), caches, lib, hash_script)
self.has_script_fn(global, caches, lib, hash_script)
}
.into());
}
@ -1258,10 +1238,10 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
this_ptr: &mut Dynamic,
namespace: &crate::ast::Namespace,
fn_name: &str,
args_expr: &[Expr],
@ -1390,15 +1370,14 @@ impl Engine {
Some(f) if f.is_script() => {
let fn_def = f.get_script_fn_def().expect("script-defined function");
let new_scope = &mut Scope::new();
let mut this = Dynamic::NULL;
let orig_source = mem::replace(&mut global.source, module.id_raw().cloned());
let global = &mut *RestoreOnDrop::lock(global, move |g| g.source = orig_source);
let result = self.call_script_fn(
global, caches, lib, level, new_scope, &mut None, fn_def, &mut args, true, pos,
);
global.source = orig_source;
result
self.call_script_fn(
global, caches, lib, level, new_scope, &mut this, fn_def, &mut args, true, pos,
)
}
Some(f) if f.is_plugin_fn() => {
@ -1442,7 +1421,7 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
level: usize,
scope: &mut Scope,
script: &str,
@ -1487,10 +1466,10 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
this_ptr: &mut Dynamic,
expr: &FnCallExpr,
pos: Position,
) -> RhaiResult {

2
src/func/mod.rs
View File

@ -22,6 +22,8 @@ pub use callable_function::CallableFunction;
#[cfg(not(feature = "no_function"))]
pub use func::Func;
pub use hashing::{calc_fn_hash, calc_fn_hash_full, calc_var_hash, get_hasher, StraightHashMap};
#[cfg(feature = "internals")]
pub use native::NativeCallContextStore;
pub use native::{
locked_read, locked_write, shared_get_mut, shared_make_mut, shared_take, shared_take_or_clone,
shared_try_take, FnAny, FnPlugin, IteratorFn, Locked, NativeCallContext, SendSync, Shared,

88
src/func/native.rs
View File

@ -8,7 +8,7 @@ use crate::tokenizer::{is_valid_function_name, Token, TokenizeState};
use crate::types::dynamic::Variant;
use crate::{
calc_fn_hash, Dynamic, Engine, EvalContext, FuncArgs, Module, Position, RhaiResult,
RhaiResultOf, StaticVec, VarDefInfo, ERR,
RhaiResultOf, SharedModule, StaticVec, VarDefInfo, ERR,
};
use std::any::type_name;
#[cfg(feature = "no_std")]
@ -72,22 +72,51 @@ pub struct NativeCallContext<'a> {
/// Function source, if any.
source: Option<&'a str>,
/// The current [`GlobalRuntimeState`], if any.
global: Option<&'a GlobalRuntimeState<'a>>,
global: Option<&'a GlobalRuntimeState>,
/// The current stack of loaded [modules][Module].
lib: &'a [&'a Module],
lib: &'a [SharedModule],
/// [Position] of the function call.
pos: Position,
/// The current nesting level of function calls.
level: usize,
}
/// _(internals)_ Context of a native Rust function call.
/// Exported under the `internals` feature only.
#[cfg(feature = "internals")]
#[derive(Debug, Clone)]
pub struct NativeCallContextStore {
/// Name of function called.
pub fn_name: String,
/// Function source, if any.
pub source: Option<String>,
/// The current [`GlobalRuntimeState`], if any.
pub global: GlobalRuntimeState,
/// The current stack of loaded [modules][Module].
pub lib: StaticVec<SharedModule>,
/// [Position] of the function call.
pub pos: Position,
/// The current nesting level of function calls.
pub level: usize,
}
#[cfg(feature = "internals")]
impl NativeCallContextStore {
/// Create a [`NativeCallContext`] from a [`NativeCallContextClone`].
#[inline(always)]
#[must_use]
pub fn create_context<'a>(&'a self, engine: &'a Engine) -> NativeCallContext<'a> {
NativeCallContext::from_stored_data(engine, self)
}
}
impl<'a>
From<(
&'a Engine,
&'a str,
Option<&'a str>,
&'a GlobalRuntimeState<'a>,
&'a [&Module],
&'a GlobalRuntimeState,
&'a [SharedModule],
Position,
usize,
)> for NativeCallContext<'a>
@ -99,7 +128,7 @@ impl<'a>
&'a str,
Option<&'a str>,
&'a GlobalRuntimeState,
&'a [&Module],
&'a [SharedModule],
Position,
usize,
),
@ -116,9 +145,9 @@ impl<'a>
}
}
impl<'a> From<(&'a Engine, &'a str, &'a [&'a Module])> for NativeCallContext<'a> {
impl<'a> From<(&'a Engine, &'a str, &'a [SharedModule])> for NativeCallContext<'a> {
#[inline(always)]
fn from(value: (&'a Engine, &'a str, &'a [&Module])) -> Self {
fn from(value: (&'a Engine, &'a str, &'a [SharedModule])) -> Self {
Self {
engine: value.0,
fn_name: value.1,
@ -140,7 +169,7 @@ impl<'a> NativeCallContext<'a> {
)]
#[inline(always)]
#[must_use]
pub fn new(engine: &'a Engine, fn_name: &'a str, lib: &'a [&Module]) -> Self {
pub fn new(engine: &'a Engine, fn_name: &'a str, lib: &'a [SharedModule]) -> Self {
Self {
engine,
fn_name,
@ -164,7 +193,7 @@ impl<'a> NativeCallContext<'a> {
fn_name: &'a str,
source: Option<&'a str>,
global: &'a GlobalRuntimeState,
lib: &'a [&Module],
lib: &'a [SharedModule],
pos: Position,
level: usize,
) -> Self {
@ -178,6 +207,39 @@ impl<'a> NativeCallContext<'a> {
level,
}
}
/// _(internals)_ Create a [`NativeCallContext`] from a [`NativeCallContextClone`].
/// Exported under the `internals` feature only.
#[cfg(feature = "internals")]
#[inline]
#[must_use]
pub fn from_stored_data(engine: &'a Engine, context: &'a NativeCallContextStore) -> Self {
Self {
engine,
fn_name: &context.fn_name,
source: context.source.as_ref().map(String::as_str),
global: Some(&context.global),
lib: &context.lib,
pos: context.pos,
level: context.level,
}
}
/// _(internals)_ Store this [`NativeCallContext`] into a [`NativeCallContextClone`].
/// Exported under the `internals` feature only.
#[cfg(feature = "internals")]
#[inline]
#[must_use]
pub fn store_data(&self) -> NativeCallContextStore {
NativeCallContextStore {
fn_name: self.fn_name.to_string(),
source: self.source.map(|s| s.to_string()),
global: self.global.unwrap().clone(),
lib: self.lib.iter().cloned().collect(),
pos: self.pos,
level: self.level,
}
}
/// The current [`Engine`].
#[inline(always)]
#[must_use]
@ -229,7 +291,7 @@ impl<'a> NativeCallContext<'a> {
#[inline]
pub(crate) fn iter_imports_raw(
&self,
) -> impl Iterator<Item = (&crate::ImmutableString, &Shared<Module>)> {
) -> impl Iterator<Item = (&crate::ImmutableString, &SharedModule)> {
self.global.iter().flat_map(|&g| g.iter_imports_raw())
}
/// _(internals)_ The current [`GlobalRuntimeState`], if any.
@ -246,14 +308,14 @@ impl<'a> NativeCallContext<'a> {
/// in reverse order (i.e. parent namespaces are iterated after child namespaces).
#[inline]
pub fn iter_namespaces(&self) -> impl Iterator<Item = &Module> {
self.lib.iter().copied()
self.lib.iter().map(|m| m.as_ref())
}
/// _(internals)_ The current stack of namespaces containing definitions of all script-defined functions.
/// Exported under the `internals` feature only.
#[cfg(feature = "internals")]
#[inline(always)]
#[must_use]
pub const fn namespaces(&self) -> &[&Module] {
pub const fn namespaces(&self) -> &[SharedModule] {
self.lib
}
/// Call a function inside the call context with the provided arguments.

16
src/func/script.rs
View File

@ -4,7 +4,7 @@
use super::call::FnCallArgs;
use crate::ast::ScriptFnDef;
use crate::eval::{Caches, GlobalRuntimeState};
use crate::{Dynamic, Engine, Module, Position, RhaiError, RhaiResult, Scope, ERR};
use crate::{Dynamic, Engine, Position, RhaiError, RhaiResult, Scope, SharedModule, ERR};
use std::mem;
#[cfg(feature = "no_std")]
use std::prelude::v1::*;
@ -26,10 +26,10 @@ impl Engine {
&self,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
this_ptr: &mut Dynamic,
fn_def: &ScriptFnDef,
args: &mut FnCallArgs,
rewind_scope: bool,
@ -127,8 +127,8 @@ impl Engine {
lib
} else {
caches.push_fn_resolution_cache();
lib_merged.push(&**fn_lib);
lib_merged.extend(lib.iter().copied());
lib_merged.push(fn_lib.clone());
lib_merged.extend(lib.iter().cloned());
&lib_merged
},
Some(mem::replace(&mut global.constants, constants.clone())),
@ -228,9 +228,9 @@ impl Engine {
#[must_use]
pub(crate) fn has_script_fn(
&self,
_global: Option<&GlobalRuntimeState>,
_global: &GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
lib: &[SharedModule],
hash_script: u64,
) -> bool {
let cache = caches.fn_resolution_cache_mut();
@ -247,7 +247,7 @@ impl Engine {
#[cfg(not(feature = "no_module"))]
let result = result ||
// Then check imported modules
_global.map_or(false, |m| m.contains_qualified_fn(hash_script))
_global.contains_qualified_fn(hash_script)
// Then check sub-modules
|| self.global_sub_modules.values().any(|m| m.contains_qualified_fn(hash_script));

3
src/lib.rs
View File

@ -240,6 +240,9 @@ pub use func::Locked;
use func::{calc_fn_hash, calc_fn_hash_full, calc_var_hash};
/// A shared [`Module`].
type SharedModule = Shared<Module>;
pub use rhai_codegen::*;
pub use func::{plugin, FuncArgs};

10
src/module/mod.rs
View File

@ -10,7 +10,7 @@ use crate::func::{
use crate::types::{dynamic::Variant, BloomFilterU64, CustomTypesCollection};
use crate::{
calc_fn_hash, calc_fn_hash_full, Dynamic, Identifier, ImmutableString, NativeCallContext,
RhaiResultOf, Shared, SmartString, StaticVec,
RhaiResultOf, Shared, SharedModule, SmartString, StaticVec,
};
#[cfg(feature = "no_std")]
use std::prelude::v1::*;
@ -172,7 +172,7 @@ pub struct Module {
/// Custom types.
custom_types: Option<CustomTypesCollection>,
/// Sub-modules.
modules: Option<BTreeMap<Identifier, Shared<Module>>>,
modules: Option<BTreeMap<Identifier, SharedModule>>,
/// [`Module`] variables.
variables: Option<BTreeMap<Identifier, Dynamic>>,
/// Flattened collection of all [`Module`] variables, including those in sub-modules.
@ -754,7 +754,7 @@ impl Module {
#[cfg(not(feature = "no_module"))]
#[inline]
#[must_use]
pub(crate) fn get_sub_modules_mut(&mut self) -> &mut BTreeMap<Identifier, Shared<Module>> {
pub(crate) fn get_sub_modules_mut(&mut self) -> &mut BTreeMap<Identifier, SharedModule> {
// We must assume that the user has changed the sub-modules
// (otherwise why take a mutable reference?)
self.all_functions = None;
@ -822,7 +822,7 @@ impl Module {
pub fn set_sub_module(
&mut self,
name: impl Into<Identifier>,
sub_module: impl Into<Shared<Module>>,
sub_module: impl Into<SharedModule>,
) -> &mut Self {
self.modules
.get_or_insert_with(|| Default::default())
@ -1830,7 +1830,7 @@ impl Module {
/// Get an iterator to the sub-modules in the [`Module`].
#[inline]
pub fn iter_sub_modules(&self) -> impl Iterator<Item = (&str, &Shared<Module>)> {
pub fn iter_sub_modules(&self) -> impl Iterator<Item = (&str, &SharedModule)> {
self.modules
.iter()
.flat_map(|m| m.iter().map(|(k, m)| (k.as_str(), m)))

4
src/module/resolvers/collection.rs
View File

@ -1,5 +1,5 @@
use crate::{
Engine, Module, ModuleResolver, Position, RhaiResultOf, Shared, StaticVec, ERR,
Engine, ModuleResolver, Position, RhaiResultOf, SharedModule, StaticVec, ERR,
STATIC_VEC_INLINE_SIZE,
};
#[cfg(feature = "no_std")]
@ -138,7 +138,7 @@ impl ModuleResolver for ModuleResolversCollection {
source_path: Option<&str>,
path: &str,
pos: Position,
) -> RhaiResultOf<Shared<Module>> {
) -> RhaiResultOf<SharedModule> {
for resolver in &self.0 {
match resolver.resolve(engine, source_path, path, pos) {
Ok(module) => return Ok(module),

4
src/module/resolvers/dummy.rs
View File

@ -1,4 +1,4 @@
use crate::{Engine, Module, ModuleResolver, Position, RhaiResultOf, Shared, ERR};
use crate::{Engine, ModuleResolver, Position, RhaiResultOf, SharedModule, ERR};
#[cfg(feature = "no_std")]
use std::prelude::v1::*;
@ -45,7 +45,7 @@ impl ModuleResolver for DummyModuleResolver {
_: Option<&str>,
path: &str,
pos: Position,
) -> RhaiResultOf<Shared<Module>> {
) -> RhaiResultOf<SharedModule> {
Err(ERR::ErrorModuleNotFound(path.into(), pos).into())
}
}

13
src/module/resolvers/file.rs
View File

@ -4,7 +4,8 @@
use crate::eval::GlobalRuntimeState;
use crate::func::{locked_read, locked_write};
use crate::{
Engine, Identifier, Locked, Module, ModuleResolver, Position, RhaiResultOf, Scope, Shared, ERR,
Engine, Identifier, Locked, Module, ModuleResolver, Position, RhaiResultOf, Scope, Shared,
SharedModule, ERR,
};
use std::{
@ -51,7 +52,7 @@ pub struct FileModuleResolver {
extension: Identifier,
cache_enabled: bool,
scope: Scope<'static>,
cache: Locked<BTreeMap<PathBuf, Shared<Module>>>,
cache: Locked<BTreeMap<PathBuf, SharedModule>>,
}
impl Default for FileModuleResolver {
@ -258,7 +259,7 @@ impl FileModuleResolver {
/// The next time this path is resolved, the script file will be loaded once again.
#[inline]
#[must_use]
pub fn clear_cache_for_path(&mut self, path: impl AsRef<Path>) -> Option<Shared<Module>> {
pub fn clear_cache_for_path(&mut self, path: impl AsRef<Path>) -> Option<SharedModule> {
locked_write(&self.cache)
.remove_entry(path.as_ref())
.map(|(.., v)| v)
@ -293,7 +294,7 @@ impl FileModuleResolver {
source: Option<&str>,
path: &str,
pos: Position,
) -> Result<Shared<Module>, Box<crate::EvalAltResult>> {
) -> Result<SharedModule, Box<crate::EvalAltResult>> {
// Load relative paths from source if there is no base path specified
let source_path = global
.as_ref()
@ -344,7 +345,7 @@ impl ModuleResolver for FileModuleResolver {
global: &mut GlobalRuntimeState,
path: &str,
pos: Position,
) -> RhaiResultOf<Shared<Module>> {
) -> RhaiResultOf<SharedModule> {
self.impl_resolve(engine, Some(global), None, path, pos)
}
@ -355,7 +356,7 @@ impl ModuleResolver for FileModuleResolver {
source: Option<&str>,
path: &str,
pos: Position,
) -> RhaiResultOf<Shared<Module>> {
) -> RhaiResultOf<SharedModule> {
self.impl_resolve(engine, None, source, path, pos)
}

6
src/module/resolvers/mod.rs
View File

@ -1,6 +1,6 @@
use crate::eval::GlobalRuntimeState;
use crate::func::SendSync;
use crate::{Engine, Module, Position, RhaiResultOf, Shared, AST};
use crate::{Engine, Position, RhaiResultOf, SharedModule, AST};
#[cfg(feature = "no_std")]
use std::prelude::v1::*;
@ -25,7 +25,7 @@ pub trait ModuleResolver: SendSync {
source: Option<&str>,
path: &str,
pos: Position,
) -> RhaiResultOf<Shared<Module>>;
) -> RhaiResultOf<SharedModule>;
/// Resolve a module based on a path string, given a [`GlobalRuntimeState`].
///
@ -38,7 +38,7 @@ pub trait ModuleResolver: SendSync {
global: &mut GlobalRuntimeState,
path: &str,
pos: Position,
) -> RhaiResultOf<Shared<Module>> {
) -> RhaiResultOf<SharedModule> {
self.resolve(engine, global.source(), path, pos)
}

23
src/module/resolvers/stat.rs
View File

@ -1,5 +1,6 @@
use crate::{
Engine, Identifier, Module, ModuleResolver, Position, RhaiResultOf, Shared, SmartString, ERR,
Engine, Identifier, Module, ModuleResolver, Position, RhaiResultOf, SharedModule, SmartString,
ERR,
};
#[cfg(feature = "no_std")]
use std::prelude::v1::*;
@ -27,7 +28,7 @@ use std::{
/// engine.set_module_resolver(resolver);
/// ```
#[derive(Debug, Clone, Default)]
pub struct StaticModuleResolver(BTreeMap<Identifier, Shared<Module>>);
pub struct StaticModuleResolver(BTreeMap<Identifier, SharedModule>);
impl StaticModuleResolver {
/// Create a new [`StaticModuleResolver`].
@ -65,7 +66,7 @@ impl StaticModuleResolver {
}
/// Remove a [module][Module] given its path.
#[inline(always)]
pub fn remove(&mut self, path: &str) -> Option<Shared<Module>> {
pub fn remove(&mut self, path: &str) -> Option<SharedModule> {
self.0.remove(path)
}
/// Does the path exist?
@ -80,12 +81,12 @@ impl StaticModuleResolver {
}
/// Get an iterator of all the [modules][Module].
#[inline]
pub fn iter(&self) -> impl Iterator<Item = (&str, &Shared<Module>)> {
pub fn iter(&self) -> impl Iterator<Item = (&str, &SharedModule)> {
self.0.iter().map(|(k, v)| (k.as_str(), v))
}
/// Get a mutable iterator of all the [modules][Module].
#[inline]
pub fn iter_mut(&mut self) -> impl Iterator<Item = (&str, &mut Shared<Module>)> {
pub fn iter_mut(&mut self) -> impl Iterator<Item = (&str, &mut SharedModule)> {
self.0.iter_mut().map(|(k, v)| (k.as_str(), v))
}
/// Get an iterator of all the [module][Module] paths.
@ -95,7 +96,7 @@ impl StaticModuleResolver {
}
/// Get an iterator of all the [modules][Module].
#[inline(always)]
pub fn values(&self) -> impl Iterator<Item = &Shared<Module>> {
pub fn values(&self) -> impl Iterator<Item = &SharedModule> {
self.0.values()
}
/// Remove all [modules][Module].
@ -130,8 +131,8 @@ impl StaticModuleResolver {
}
impl IntoIterator for StaticModuleResolver {
type Item = (Identifier, Shared<Module>);
type IntoIter = IntoIter<SmartString, Shared<Module>>;
type Item = (Identifier, SharedModule);
type IntoIter = IntoIter<SmartString, SharedModule>;
#[inline(always)]
#[must_use]
@ -141,8 +142,8 @@ impl IntoIterator for StaticModuleResolver {
}
impl<'a> IntoIterator for &'a StaticModuleResolver {
type Item = (&'a Identifier, &'a Shared<Module>);
type IntoIter = Iter<'a, SmartString, Shared<Module>>;
type Item = (&'a Identifier, &'a SharedModule);
type IntoIter = Iter<'a, SmartString, SharedModule>;
#[inline(always)]
fn into_iter(self) -> Self::IntoIter {
@ -158,7 +159,7 @@ impl ModuleResolver for StaticModuleResolver {
_: Option<&str>,
path: &str,
pos: Position,
) -> RhaiResultOf<Shared<Module>> {
) -> RhaiResultOf<SharedModule> {
self.0
.get(path)
.cloned()

53
src/optimizer.rs
View File

@ -50,18 +50,18 @@ struct OptimizerState<'a> {
/// Has the [`AST`] been changed during this pass?
changed: bool,
/// Collection of constants to use for eager function evaluations.
variables: StaticVec<(Identifier, AccessMode, Option<Dynamic>)>,
variables: StaticVec<(Identifier, AccessMode, Dynamic)>,
/// Activate constants propagation?
propagate_constants: bool,
/// An [`Engine`] instance for eager function evaluation.
engine: &'a Engine,
/// The global runtime state.
global: GlobalRuntimeState<'a>,
global: GlobalRuntimeState,
/// Function resolution caches.
caches: Caches<'a>,
caches: Caches,
/// [Module][crate::Module] containing script-defined functions.
#[cfg(not(feature = "no_function"))]
lib: &'a [&'a crate::Module],
lib: &'a [crate::SharedModule],
/// Optimization level.
optimization_level: OptimizationLevel,
}
@ -71,7 +71,7 @@ impl<'a> OptimizerState<'a> {
#[inline(always)]
pub fn new(
engine: &'a Engine,
#[cfg(not(feature = "no_function"))] lib: &'a [&'a crate::Module],
#[cfg(not(feature = "no_function"))] lib: &'a [crate::SharedModule],
optimization_level: OptimizationLevel,
) -> Self {
Self {
@ -108,12 +108,7 @@ impl<'a> OptimizerState<'a> {
}
/// Add a new variable to the list.
#[inline(always)]
pub fn push_var(
&mut self,
name: impl Into<Identifier>,
access: AccessMode,
value: Option<Dynamic>,
) {
pub fn push_var(&mut self, name: impl Into<Identifier>, access: AccessMode, value: Dynamic) {
self.variables.push((name.into(), access, value));
}
/// Look up a constant from the list.
@ -127,7 +122,8 @@ impl<'a> OptimizerState<'a> {
if n == name {
return match access {
AccessMode::ReadWrite => None,
AccessMode::ReadOnly => value.as_ref(),
AccessMode::ReadOnly if value.is_null() => None,
AccessMode::ReadOnly => Some(value),
};
}
}
@ -141,7 +137,7 @@ impl<'a> OptimizerState<'a> {
fn_name: &str,
op_token: Option<&Token>,
arg_values: &mut [Dynamic],
) -> Option<Dynamic> {
) -> Dynamic {
#[cfg(not(feature = "no_function"))]
let lib = self.lib;
#[cfg(feature = "no_function")]
@ -160,8 +156,7 @@ impl<'a> OptimizerState<'a> {
false,
Position::NONE,
)
.ok()
.map(|(v, ..)| v)
.map_or(Dynamic::NULL, |(v, ..)| v)
}
}
@ -271,13 +266,13 @@ fn optimize_stmt_block(
state.push_var(
x.0.as_str(),
AccessMode::ReadOnly,
x.1.get_literal_value(),
x.1.get_literal_value().unwrap_or(Dynamic::NULL),
);
}
} else {
// Add variables into the state
optimize_expr(&mut x.1, state, false);
state.push_var(x.0.as_str(), AccessMode::ReadWrite, None);
state.push_var(x.0.as_str(), AccessMode::ReadWrite, Dynamic::NULL);
}
}
// Optimize the statement
@ -1189,7 +1184,7 @@ fn optimize_expr(expr: &mut Expr, state: &mut OptimizerState, _chaining: bool) {
=> {
// First search for script-defined functions (can override built-in)
#[cfg(not(feature = "no_function"))]
let has_script_fn = !x.hashes.is_native_only() && state.lib.iter().find_map(|&m| m.get_script_fn(&x.name, x.args.len())).is_some();
let has_script_fn = !x.hashes.is_native_only() && state.lib.iter().find_map(|m| m.get_script_fn(&x.name, x.args.len())).is_some();
#[cfg(feature = "no_function")]
let has_script_fn = false;
@ -1197,13 +1192,13 @@ fn optimize_expr(expr: &mut Expr, state: &mut OptimizerState, _chaining: bool) {
let arg_values = &mut x.args.iter().map(Expr::get_literal_value).collect::<Option<StaticVec<_>>>().unwrap();
let result = match x.name.as_str() {
KEYWORD_TYPE_OF if arg_values.len() == 1 => Some(state.engine.map_type_name(arg_values[0].type_name()).into()),
KEYWORD_TYPE_OF if arg_values.len() == 1 => state.engine.map_type_name(arg_values[0].type_name()).into(),
#[cfg(not(feature = "no_closure"))]
crate::engine::KEYWORD_IS_SHARED if arg_values.len() == 1 => Some(Dynamic::FALSE),
crate::engine::KEYWORD_IS_SHARED if arg_values.len() == 1 => Dynamic::FALSE,
_ => state.call_fn_with_constant_arguments(&x.name, x.op_token.as_ref(), arg_values)
};
if let Some(result) = result {
if !result.is_null() {
state.set_dirty();
*expr = Expr::from_dynamic(result, *pos);
return;
@ -1263,7 +1258,7 @@ fn optimize_top_level(
statements: StmtBlockContainer,
engine: &Engine,
scope: &Scope,
#[cfg(not(feature = "no_function"))] lib: &[&crate::Module],
#[cfg(not(feature = "no_function"))] lib: &[crate::SharedModule],
optimization_level: OptimizationLevel,
) -> StmtBlockContainer {
let mut statements = statements;
@ -1289,15 +1284,15 @@ fn optimize_top_level(
.rev()
.flat_map(|m| m.iter_var())
{
state.push_var(name, AccessMode::ReadOnly, Some(value.clone()));
state.push_var(name, AccessMode::ReadOnly, value.clone());
}
// Add constants and variables from the scope
for (name, constant, value) in scope.iter() {
if constant {
state.push_var(name, AccessMode::ReadOnly, Some(value));
state.push_var(name, AccessMode::ReadOnly, value);
} else {
state.push_var(name, AccessMode::ReadWrite, None);
state.push_var(name, AccessMode::ReadWrite, Dynamic::NULL);
}
}
@ -1317,7 +1312,7 @@ pub fn optimize_into_ast(
let mut statements = statements;
#[cfg(not(feature = "no_function"))]
let lib = {
let lib: crate::Shared<_> = {
let mut module = crate::Module::new();
if optimization_level != OptimizationLevel::None {
@ -1338,7 +1333,7 @@ pub fn optimize_into_ast(
});
}
let lib2 = &[&lib2];
let lib2 = &[lib2.into()];
for fn_def in functions {
let mut fn_def = crate::func::shared_take_or_clone(fn_def);
@ -1356,7 +1351,7 @@ pub fn optimize_into_ast(
}
}
module
module.into()
};
statements.shrink_to_fit();
@ -1369,7 +1364,7 @@ pub fn optimize_into_ast(
engine,
scope,
#[cfg(not(feature = "no_function"))]
&[&lib],
&[lib.clone()],
optimization_level,
),
},

4
src/packages/mod.rs
View File

@ -1,6 +1,6 @@
//! Module containing all built-in _packages_ available to Rhai, plus facilities to define custom packages.
use crate::{Engine, Module, Shared};
use crate::{Engine, Module, SharedModule};
pub(crate) mod arithmetic;
pub(crate) mod array_basic;
@ -99,7 +99,7 @@ pub trait Package {
/// Get a reference to a shared module from this package.
#[must_use]
fn as_shared_module(&self) -> Shared<Module>;
fn as_shared_module(&self) -> SharedModule;
}
/// Macro that makes it easy to define a _package_ (which is basically a shared [module][Module])

12
src/parser.rs
View File

@ -8,7 +8,7 @@ use crate::ast::{
SwitchCasesCollection, TryCatchBlock,
};
use crate::engine::{Precedence, KEYWORD_THIS, OP_CONTAINS};
use crate::eval::GlobalRuntimeState;
use crate::eval::{Caches, GlobalRuntimeState};
use crate::func::{hashing::get_hasher, StraightHashMap};
use crate::tokenizer::{
is_keyword_function, is_valid_function_name, is_valid_identifier, Token, TokenStream,
@ -55,7 +55,7 @@ pub struct ParseState<'e> {
/// External [scope][Scope] with constants.
pub scope: &'e Scope<'e>,
/// Global runtime state.
pub global: GlobalRuntimeState<'e>,
pub global: GlobalRuntimeState,
/// Encapsulates a local stack with variable names to simulate an actual runtime scope.
pub stack: Scope<'e>,
/// Size of the local variables stack upon entry of the current block scope.
@ -2906,15 +2906,17 @@ impl Engine {
nesting_level: level,
will_shadow,
};
let mut this_ptr = None;
let caches = &mut Caches::new();
let mut this = Dynamic::NULL;
let context = EvalContext::new(
self,
&mut state.global,
None,
caches,
&[],
level,
&mut state.stack,
&mut this_ptr,
&mut this,
);
match filter(false, info, context) {

2
src/serde/de.rs
View File

@ -125,6 +125,8 @@ impl<'de> Deserializer<'de> for DynamicDeserializer<'de> {
fn deserialize_any<V: Visitor<'de>>(self, visitor: V) -> RhaiResultOf<V::Value> {
match self.0 .0 {
Union::Null => unreachable!(),
Union::Unit(..) => self.deserialize_unit(visitor),
Union::Bool(..) => self.deserialize_bool(visitor),
Union::Str(..) => self.deserialize_str(visitor),

2
src/serde/serialize.rs
View File

@ -15,6 +15,8 @@ use crate::types::dynamic::Variant;
impl Serialize for Dynamic {
fn serialize<S: Serializer>(&self, ser: S) -> Result<S::Ok, S::Error> {
match self.0 {
Union::Null => unreachable!(),
Union::Unit(..) => ser.serialize_unit(),
Union::Bool(x, ..) => ser.serialize_bool(x),
Union::Str(ref s, ..) => ser.serialize_str(s.as_str()),

37
src/types/dynamic.rs
View File

@ -55,6 +55,9 @@ pub struct Dynamic(pub(crate) Union);
///
/// Most variants are boxed to reduce the size.
pub enum Union {
/// An error value which should not exist.
Null,
/// The Unit value - ().
Unit((), Tag, AccessMode),
/// A boolean value.
@ -178,6 +181,8 @@ impl Dynamic {
#[must_use]
pub const fn tag(&self) -> Tag {
match self.0 {
Union::Null => unreachable!(),
Union::Unit(_, tag, _)
| Union::Bool(_, tag, _)
| Union::Str(_, tag, _)
@ -203,6 +208,8 @@ impl Dynamic {
/// Attach arbitrary data to this [`Dynamic`].
pub fn set_tag(&mut self, value: Tag) -> &mut Self {
match self.0 {
Union::Null => unreachable!(),
Union::Unit(_, ref mut tag, _)
| Union::Bool(_, ref mut tag, _)
| Union::Str(_, ref mut tag, _)
@ -226,6 +233,12 @@ impl Dynamic {
}
self
}
/// Is this [`Dynamic`] null?
#[inline(always)]
#[must_use]
pub(crate) const fn is_null(&self) -> bool {
matches!(self.0, Union::Null)
}
/// Does this [`Dynamic`] hold a variant data type instead of one of the supported system
/// primitive types?
#[inline(always)]
@ -307,6 +320,8 @@ impl Dynamic {
#[must_use]
pub fn type_id(&self) -> TypeId {
match self.0 {
Union::Null => unreachable!(),
Union::Unit(..) => TypeId::of::<()>(),
Union::Bool(..) => TypeId::of::<bool>(),
Union::Str(..) => TypeId::of::<ImmutableString>(),
@ -341,6 +356,8 @@ impl Dynamic {
#[must_use]
pub fn type_name(&self) -> &'static str {
match self.0 {
Union::Null => unreachable!(),
Union::Unit(..) => "()",
Union::Bool(..) => "bool",
Union::Str(..) => "string",
@ -385,6 +402,8 @@ impl Hash for Dynamic {
mem::discriminant(&self.0).hash(state);
match self.0 {
Union::Null => unreachable!(),
Union::Unit(..) => (),
Union::Bool(ref b, ..) => b.hash(state),
Union::Str(ref s, ..) => s.hash(state),
@ -416,6 +435,8 @@ impl Hash for Dynamic {
impl fmt::Display for Dynamic {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self.0 {
Union::Null => unreachable!(),
Union::Unit(..) => Ok(()),
Union::Bool(ref v, ..) => fmt::Display::fmt(v, f),
Union::Str(ref v, ..) => fmt::Display::fmt(v, f),
@ -509,6 +530,8 @@ impl fmt::Debug for Dynamic {
#[inline(never)]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self.0 {
Union::Null => unreachable!(),
Union::Unit(ref v, ..) => fmt::Debug::fmt(v, f),
Union::Bool(ref v, ..) => fmt::Debug::fmt(v, f),
Union::Str(ref v, ..) => fmt::Debug::fmt(v, f),
@ -619,6 +642,8 @@ impl Clone for Dynamic {
/// The cloned copy is marked read-write even if the original is read-only.
fn clone(&self) -> Self {
match self.0 {
Union::Null => unreachable!(),
Union::Unit(v, tag, ..) => Self(Union::Unit(v, tag, ReadWrite)),
Union::Bool(v, tag, ..) => Self(Union::Bool(v, tag, ReadWrite)),
Union::Str(ref v, tag, ..) => Self(Union::Str(v.clone(), tag, ReadWrite)),
@ -666,6 +691,9 @@ use std::f32::consts as FloatConstants;
use std::f64::consts as FloatConstants;
impl Dynamic {
/// A [`Dynamic`] containing a `null`.
pub(crate) const NULL: Self = Self(Union::Null);
/// A [`Dynamic`] containing a `()`.
pub const UNIT: Self = Self(Union::Unit((), DEFAULT_TAG_VALUE, ReadWrite));
/// A [`Dynamic`] containing a `true`.
@ -888,6 +916,8 @@ impl Dynamic {
#[must_use]
pub(crate) const fn access_mode(&self) -> AccessMode {
match self.0 {
Union::Null => unreachable!(),
Union::Unit(.., access)
| Union::Bool(.., access)
| Union::Str(.., access)
@ -913,6 +943,8 @@ impl Dynamic {
/// Set the [`AccessMode`] for this [`Dynamic`].
pub(crate) fn set_access_mode(&mut self, typ: AccessMode) -> &mut Self {
match self.0 {
Union::Null => unreachable!(),
Union::Unit(.., ref mut access)
| Union::Bool(.., ref mut access)
| Union::Str(.., ref mut access)
@ -1107,6 +1139,7 @@ impl Dynamic {
let _access = self.access_mode();
match self.0 {
Union::Null => unreachable!(),
Union::Shared(..) => self,
_ => Self(Union::Shared(
crate::Locked::new(self).into(),
@ -1151,6 +1184,8 @@ impl Dynamic {
reify!(self, |v: T| return Some(v));
match self.0 {
Union::Null => unreachable!(),
Union::Int(v, ..) => reify!(v => Option<T>),
#[cfg(not(feature = "no_float"))]
Union::Float(v, ..) => reify!(*v => Option<T>),
@ -1485,6 +1520,7 @@ impl Dynamic {
}
match self.0 {
Union::Null => unreachable!(),
Union::Variant(ref v, ..) => (***v).as_any().downcast_ref::<T>(),
#[cfg(not(feature = "no_closure"))]
Union::Shared(..) => None,
@ -1583,6 +1619,7 @@ impl Dynamic {
}
match self.0 {
Union::Null => unreachable!(),
Union::Variant(ref mut v, ..) => (***v).as_any_mut().downcast_mut::<T>(),
#[cfg(not(feature = "no_closure"))]
Union::Shared(..) => None,

13
src/types/fn_ptr.rs
View File

@ -3,8 +3,8 @@
use crate::tokenizer::is_valid_function_name;
use crate::types::dynamic::Variant;
use crate::{
Dynamic, Engine, FuncArgs, ImmutableString, Module, NativeCallContext, Position, RhaiError,
RhaiResult, RhaiResultOf, StaticVec, AST, ERR,
Dynamic, Engine, FuncArgs, ImmutableString, NativeCallContext, Position, RhaiError, RhaiResult,
RhaiResultOf, SharedModule, StaticVec, AST, ERR,
};
#[cfg(feature = "no_std")]
use std::prelude::v1::*;
@ -150,15 +150,16 @@ impl FnPtr {
let mut arg_values = crate::StaticVec::new_const();
args.parse(&mut arg_values);
let lib = [
let lib: &[SharedModule] = &[
#[cfg(not(feature = "no_function"))]
_ast.as_ref(),
AsRef::<SharedModule>::as_ref(ast).clone(),
];
let lib = if lib.first().map_or(true, |m: &&Module| m.is_empty()) {
&lib[0..0]
let lib = if lib.first().map_or(true, |m| m.is_empty()) {
&[][..]
} else {
&lib
};
#[allow(deprecated)]
let ctx = NativeCallContext::new(engine, self.fn_name(), lib);

69
src/types/interner.rs
View File

@ -1,3 +1,5 @@
//! A strings interner type.
use super::BloomFilterU64;
use crate::func::{hashing::get_hasher, StraightHashMap};
use crate::ImmutableString;
@ -20,10 +22,8 @@ pub const MAX_INTERNED_STRINGS: usize = 1024;
/// Maximum length of strings interned.
pub const MAX_STRING_LEN: usize = 24;
/// _(internals)_ A factory of identifiers from text strings.
/// _(internals)_ A cache for interned strings.
/// Exported under the `internals` feature only.
///
/// Normal identifiers, property getters and setters are interned separately.
pub struct StringsInterner<'a> {
/// Maximum number of strings interned.
pub capacity: usize,
@ -103,43 +103,48 @@ impl StringsInterner<'_> {
if value.strong_count() > 1 {
return value;
}
e.insert(value).clone()
}
};
// If the interner is over capacity, remove the longest entry that has the lowest count
if self.cache.len() > self.capacity {
// Throttle: leave some buffer to grow when shrinking the cache.
// We leave at least two entries, one for the empty string, and one for the string
// that has just been inserted.
let max = if self.capacity < 5 {
2
} else {
self.capacity - 3
};
while self.cache.len() > max {
let (_, _, n) = self
.cache
.iter()
.fold((0, usize::MAX, 0), |(x, c, n), (&k, v)| {
if k != hash
&& (v.strong_count() < c || (v.strong_count() == c && v.len() > x))
{
(v.len(), v.strong_count(), k)
} else {
(x, c, n)
}
});
self.cache.remove(&n);
}
}
// Throttle the cache upon exit
self.throttle_cache(hash);
result
}
/// If the interner is over capacity, remove the longest entry that has the lowest count
fn throttle_cache(&mut self, hash: u64) {
if self.cache.len() <= self.capacity {
return;
}
// Leave some buffer to grow when shrinking the cache.
// We leave at least two entries, one for the empty string, and one for the string
// that has just been inserted.
let max = if self.capacity < 5 {
2
} else {
self.capacity - 3
};
while self.cache.len() > max {
let (_, _, n) = self
.cache
.iter()
.fold((0, usize::MAX, 0), |(x, c, n), (&k, v)| {
if k != hash && (v.strong_count() < c || (v.strong_count() == c && v.len() > x))
{
(v.len(), v.strong_count(), k)
} else {
(x, c, n)
}
});
self.cache.remove(&n);
}
}
/// Number of strings interned.
#[inline(always)]
#[must_use]

2
src/types/mod.rs
View File

@ -8,6 +8,7 @@ pub mod fn_ptr;
pub mod immutable_string;
pub mod interner;
pub mod parse_error;
pub mod restore;
pub mod scope;
pub mod variant;
@ -21,5 +22,6 @@ pub use fn_ptr::FnPtr;
pub use immutable_string::ImmutableString;
pub use interner::StringsInterner;
pub use parse_error::{LexError, ParseError, ParseErrorType};
pub use restore::RestoreOnDrop;
pub use scope::Scope;
pub use variant::Variant;

65
src/types/restore.rs Normal file
View File

@ -0,0 +1,65 @@
//! Facility to run state restoration logic at the end of scope.
use std::ops::{Deref, DerefMut};
#[cfg(feature = "no_std")]
use std::prelude::v1::*;
/// Run custom restoration logic upon the end of scope.
#[must_use]
pub struct RestoreOnDrop<'a, T, R: FnOnce(&mut T)> {
value: &'a mut T,
restore: Option<R>,
}
impl<'a, T, R: FnOnce(&mut T)> RestoreOnDrop<'a, T, R> {
/// Create a new [`RestoreOnDrop`] that locks a mutable reference and runs restoration logic at
/// the end of scope only when `need_restore` is `true`.
///
/// Beware that the end of scope means the end of its lifetime, not necessarily waiting until
/// the current block scope is exited.
#[inline(always)]
pub fn lock_if(need_restore: bool, value: &'a mut T, restore: R) -> Self {
Self {
value,
restore: if need_restore { Some(restore) } else { None },
}
}
/// Create a new [`RestoreOnDrop`] that locks a mutable reference and runs restoration logic at
/// the end of scope.
///
/// Beware that the end of scope means the end of its lifetime, not necessarily waiting until
/// the current block scope is exited.
#[inline(always)]
pub fn lock(value: &'a mut T, restore: R) -> Self {
Self {
value,
restore: Some(restore),
}
}
}
impl<'a, T, R: FnOnce(&mut T)> Drop for RestoreOnDrop<'a, T, R> {
#[inline(always)]
fn drop(&mut self) {
if let Some(restore) = self.restore.take() {
restore(self.value);
}
}
}
impl<'a, T, R: FnOnce(&mut T)> Deref for RestoreOnDrop<'a, T, R> {
type Target = T;
#[inline(always)]
fn deref(&self) -> &Self::Target {
self.value
}
}
impl<'a, T, R: FnOnce(&mut T)> DerefMut for RestoreOnDrop<'a, T, R> {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
self.value
}
}

41
tests/modules.rs
View File

@ -2,7 +2,7 @@
use rhai::{
module_resolvers::{DummyModuleResolver, StaticModuleResolver},
Dynamic, Engine, EvalAltResult, FnNamespace, FnPtr, ImmutableString, Module, NativeCallContext,
ParseError, ParseErrorType, Scope, Shared, INT,
ParseError, ParseErrorType, Scope, INT,
};
#[test]
@ -546,44 +546,13 @@ fn test_module_context() -> Result<(), Box<EvalAltResult>> {
engine.register_fn(
"calc",
|context: NativeCallContext, fp: FnPtr| -> Result<INT, Box<EvalAltResult>> {
// Store fields for later use
let engine = context.engine();
let fn_name = context.fn_name().to_string();
let source = context.source().map(|s| s.to_string());
let global = context.global_runtime_state().unwrap().clone();
let pos = context.position();
let call_level = context.call_level();
// Store the paths of the stack of call modules up to this point
let modules_list: Vec<String> = context
.iter_namespaces()
.map(|m| m.id().unwrap_or("testing"))
.filter(|id| !id.is_empty())
.map(|id| id.to_string())
.collect();
// Store context for later use - requires the 'internals' feature
let context_data = context.store_data();
// Recreate the 'NativeCallContext' - requires the 'internals' feature
let mut libraries = Vec::<Shared<Module>>::new();
for path in modules_list {
// Recreate the stack of call modules by resolving each path with
// the module resolver.
let module = engine.module_resolver().resolve(engine, None, &path, pos)?;
libraries.push(module);
}
let lib: Vec<&Module> = libraries.iter().map(|m| m.as_ref()).collect();
let new_context = NativeCallContext::new_with_all_fields(
engine,
&fn_name,
source.as_ref().map(String::as_str),
&global,
&lib,
pos,
call_level,
);
// Recreate the 'NativeCallContext'
let new_context = context_data.create_context(engine);
fp.call_within_context(&new_context, (41 as INT,))
},

0
unreachable!() Normal file
View File