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

Minor cleanup.

Browse Source
This commit is contained in:
Stephen Chung 2022-12-09 20:42:55 +08:00
parent 30ff208104
commit f15a9a7c9c
9 changed files with 41 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/api/call_fn.rs
View File

@ -18,9 +18,9 @@ use std::{
#[non_exhaustive]
#[must_use]
pub struct CallFnOptions<'t> {
/// A value for binding to the `this` pointer (if any).
/// A value for binding to the `this` pointer (if any). Default [`None`].
pub this_ptr: Option<&'t mut Dynamic>,
/// The custom state of this evaluation run (if any), overrides [`Engine::default_tag`].
/// The custom state of this evaluation run (if any), overrides [`Engine::default_tag`]. Default [`None`].
pub tag: Option<Dynamic>,
/// Evaluate the [`AST`] to load necessary modules before calling the function? Default `true`.
pub eval_ast: bool,
@ -172,13 +172,13 @@ impl Engine {
args.parse(&mut arg_values);
self._call_fn(
options,
scope,
&mut GlobalRuntimeState::new(self),
&mut Caches::new(),
ast,
name.as_ref(),
arg_values.as_mut(),
options,
)
.and_then(|result| {
// Bail out early if the return type needs no cast
@ -207,13 +207,13 @@ impl Engine {
#[inline(always)]
pub(crate) fn _call_fn(
&self,
options: CallFnOptions,
scope: &mut Scope,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
ast: &AST,
name: &str,
arg_values: &mut [Dynamic],
options: CallFnOptions,
) -> RhaiResult {
let statements = ast.statements();

2
src/api/deprecated.rs
View File

@ -167,13 +167,13 @@ impl Engine {
};
self._call_fn(
options,
scope,
&mut crate::eval::GlobalRuntimeState::new(self),
&mut crate::eval::Caches::new(),
ast,
name.as_ref(),
arg_values.as_mut(),
options,
)
}
/// Register a custom fallible function with the [`Engine`].

4
src/api/eval.rs
View File

@ -250,9 +250,9 @@ impl Engine {
#[cfg(feature = "debugging")]
if self.is_debugger_registered() {
global.debugger_mut().status = crate::eval::DebuggerStatus::Terminate;
let mut this = Dynamic::NULL;
let mut this_ptr = Dynamic::NULL;
let node = &crate::ast::Stmt::Noop(Position::NONE);
self.run_debugger(global, caches, scope, &mut this, node)?;
self.run_debugger(global, caches, scope, &mut this_ptr, node)?;
}
Ok(r)
})

8
src/api/options.rs
View File

@ -22,7 +22,7 @@ bitflags! {
/// Is looping allowed?
const LOOPING = 0b_0000_0010_0000;
/// Is variables shadowing allowed?
const SHADOW = 0b_0000_0100_0000;
const SHADOWING = 0b_0000_0100_0000;
/// Strict variables mode?
const STRICT_VAR = 0b_0000_1000_0000;
/// Raise error if an object map property does not exist?
@ -43,7 +43,7 @@ impl LangOptions {
| Self::SWITCH_EXPR
| Self::STMT_EXPR
| Self::LOOPING
| Self::SHADOW
| Self::SHADOWING
| Self::FAST_OPS
| {
#[cfg(not(feature = "no_function"))]
@ -148,12 +148,12 @@ impl Engine {
#[inline(always)]
#[must_use]
pub const fn allow_shadowing(&self) -> bool {
self.options.contains(LangOptions::SHADOW)
self.options.contains(LangOptions::SHADOWING)
}
/// Set whether variables shadowing is allowed.
#[inline(always)]
pub fn set_allow_shadowing(&mut self, enable: bool) -> &mut Self {
self.options.set(LangOptions::SHADOW, enable);
self.options.set(LangOptions::SHADOWING, enable);
self
}
/// Is strict variables mode enabled?

4
src/api/run.rs
View File

@ -131,9 +131,9 @@ impl Engine {
#[cfg(feature = "debugging")]
if self.is_debugger_registered() {
global.debugger_mut().status = crate::eval::DebuggerStatus::Terminate;
let mut this = crate::Dynamic::NULL;
let mut this_ptr = crate::Dynamic::NULL;
let node = &crate::ast::Stmt::Noop(crate::Position::NONE);
self.run_debugger(global, caches, scope, &mut this, node)?;
self.run_debugger(global, caches, scope, &mut this_ptr, node)?;
}
Ok(())
})

16
src/eval/chaining.rs
View File

@ -392,13 +392,19 @@ impl Engine {
self.run_debugger(global, caches, scope, this_ptr, lhs)?;
self.track_operation(global, *var_pos)?;
let mut target = self.search_namespace(global, caches, scope, this_ptr, lhs)?;
let obj_ptr = &mut target;
let mut this = Dynamic::NULL;
let target = &mut self.search_namespace(global, caches, scope, this_ptr, lhs)?;
let mut this_ptr = Dynamic::NULL;
self.eval_dot_index_chain_raw(
global, caches, &mut this, lhs, expr, obj_ptr, rhs, idx_values, new_val,
global,
caches,
&mut this_ptr,
lhs,
expr,
target,
rhs,
idx_values,
new_val,
)
}
// {expr}.??? = ??? or {expr}[???] = ???

4
src/eval/stmt.rs
View File

@ -882,9 +882,9 @@ impl Engine {
scope: &mut Scope,
statements: &[Stmt],
) -> RhaiResult {
let mut this = Dynamic::NULL;
let mut this_ptr = Dynamic::NULL;
self.eval_stmt_block(global, caches, scope, &mut this, statements, false)
self.eval_stmt_block(global, caches, scope, &mut this_ptr, statements, false)
.or_else(|err| match *err {
ERR::Return(out, ..) => Ok(out),
ERR::LoopBreak(..) => {

28
src/func/call.rs
View File

@ -429,7 +429,7 @@ impl Engine {
};
if trigger {
let scope = &mut Scope::new();
let mut this = Dynamic::NULL;
let mut this_ptr = Dynamic::NULL;
let node = crate::ast::Stmt::Noop(pos);
let node = (&node).into();
let event = match _result {
@ -438,7 +438,7 @@ impl Engine {
};
if let Err(err) =
self.run_debugger_raw(global, caches, scope, &mut this, node, event)
self.run_debugger_raw(global, caches, scope, &mut this_ptr, node, event)
{
_result = Err(err);
}
@ -681,9 +681,9 @@ impl Engine {
auto_restore!(args = (_args) if swap => move |a| backup.restore_first_arg(a));
let mut this = Dynamic::NULL;
let mut this_ptr = Dynamic::NULL;
self.call_script_fn(global, caches, scope, &mut this, func, args, true, pos)
self.call_script_fn(global, caches, scope, &mut this_ptr, func, args, true, pos)
}
.map(|r| (r, false));
}
@ -1248,7 +1248,7 @@ impl Engine {
pos: Position,
) -> RhaiResult {
let mut arg_values = FnArgsVec::with_capacity(args_expr.len());
let mut args = FnArgsVec::with_capacity(args_expr.len());
let args = &mut FnArgsVec::with_capacity(args_expr.len());
let mut first_arg_value = None;
if args_expr.is_empty() {
@ -1366,16 +1366,14 @@ impl Engine {
match func {
#[cfg(not(feature = "no_function"))]
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 f = f.get_script_fn_def().expect("script-defined function");
let scope = &mut Scope::new();
let mut this_ptr = Dynamic::NULL;
let orig_source = mem::replace(&mut global.source, module.id_raw().cloned());
auto_restore!(global => move |g| g.source = orig_source);
self.call_script_fn(
global, caches, new_scope, &mut this, fn_def, &mut args, true, pos,
)
self.call_script_fn(global, caches, scope, &mut this_ptr, f, args, true, pos)
}
Some(f) if f.is_plugin_fn() => {
@ -1388,7 +1386,7 @@ impl Engine {
if !f.is_pure() && !args.is_empty() && args[0].is_read_only() {
Err(ERR::ErrorNonPureMethodCallOnConstant(fn_name.to_string(), pos).into())
} else {
f.call(context, &mut args)
f.call(context, args)
.and_then(|r| self.check_data_size(r, pos))
}
}
@ -1400,19 +1398,19 @@ impl Engine {
} else {
None
};
func(context, &mut args).and_then(|r| self.check_data_size(r, pos))
func(context, args).and_then(|r| self.check_data_size(r, pos))
}
Some(f) => unreachable!("unknown function type: {:?}", f),
None => {
let sig = if namespace.is_empty() {
self.gen_fn_call_signature(fn_name, &args)
self.gen_fn_call_signature(fn_name, args)
} else {
format!(
"{namespace}{}{}",
crate::tokenizer::Token::DoubleColon.literal_syntax(),
self.gen_fn_call_signature(fn_name, &args)
self.gen_fn_call_signature(fn_name, args)
)
};

5
src/parser.rs
View File

@ -2890,9 +2890,8 @@ impl Engine {
will_shadow,
};
let caches = &mut Caches::new();
let mut this = Dynamic::NULL;
let context = EvalContext::new(self, global, caches, stack, &mut this);
let mut this_ptr = Dynamic::NULL;
let context = EvalContext::new(self, global, caches, stack, &mut this_ptr);
match filter(false, info, context) {
Ok(true) => (),