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

Rename sub-scope/SubScope to module.

Browse Source
This commit is contained in:
Stephen Chung 2020-05-05 10:39:12 +08:00
parent 64036f69ca
commit 143861747d
10 changed files with 162 additions and 201 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.toml
View File

@ -28,7 +28,7 @@ no_float = [] # no floating-point
no_function = [] # no script-defined functions
no_object = [] # no custom objects
no_optimize = [] # no script optimizer
no_import = [] # no modules
no_module = [] # no modules
only_i32 = [] # set INT=i32 (useful for 32-bit systems)
only_i64 = [] # set INT=i64 (default) and disable support for all other integer types
sync = [] # restrict to only types that implement Send + Sync

4
README.md
View File

@ -70,7 +70,7 @@ Optional features
| `no_object` | Disable support for custom types and objects. |
| `no_float` | Disable floating-point numbers and math if not needed. |
| `no_optimize` | Disable the script optimizer. |
| `no_import` | Disable modules. |
| `no_module` | Disable modules. |
| `only_i32` | Set the system integer type to `i32` and disable all other integer types. `INT` is set to `i32`. |
| `only_i64` | Set the system integer type to `i64` and disable all other integer types. `INT` is set to `i64`. |
| `no_std` | Build for `no-std`. Notice that additional dependencies will be pulled in to replace `std` features. |
@ -86,7 +86,7 @@ Excluding unneeded functionalities can result in smaller, faster builds as well
[`no_function`]: #optional-features
[`no_object`]: #optional-features
[`no_optimize`]: #optional-features
[`no_import`]: #optional-features
[`no_module`]: #optional-features
[`only_i32`]: #optional-features
[`only_i64`]: #optional-features
[`no_std`]: #optional-features

22
src/any.rs
View File

@ -1,6 +1,6 @@
//! Helper module which defines the `Any` trait to to allow dynamic value handling.
use crate::engine::{Array, Map, SubScope};
use crate::engine::{Array, Map, Module};
use crate::parser::INT;
#[cfg(not(feature = "no_float"))]
@ -135,7 +135,7 @@ pub enum Union {
Float(FLOAT),
Array(Box<Array>),
Map(Box<Map>),
SubScope(Box<SubScope>),
Module(Box<Module>),
Variant(Box<Box<dyn Variant>>),
}
@ -166,7 +166,7 @@ impl Dynamic {
Union::Float(_) => TypeId::of::<FLOAT>(),
Union::Array(_) => TypeId::of::<Array>(),
Union::Map(_) => TypeId::of::<Map>(),
Union::SubScope(_) => TypeId::of::<SubScope>(),
Union::Module(_) => TypeId::of::<Module>(),
Union::Variant(value) => (***value).type_id(),
}
}
@ -183,7 +183,7 @@ impl Dynamic {
Union::Float(_) => type_name::<FLOAT>(),
Union::Array(_) => "array",
Union::Map(_) => "map",
Union::SubScope(_) => "sub-scope",
Union::Module(_) => "sub-scope",
#[cfg(not(feature = "no_std"))]
Union::Variant(value) if value.is::<Instant>() => "timestamp",
@ -204,7 +204,7 @@ impl fmt::Display for Dynamic {
Union::Float(value) => write!(f, "{}", value),
Union::Array(value) => write!(f, "{:?}", value),
Union::Map(value) => write!(f, "#{:?}", value),
Union::SubScope(value) => write!(f, "#{:?}", value),
Union::Module(value) => write!(f, "#{:?}", value),
Union::Variant(_) => write!(f, "?"),
}
}
@ -222,7 +222,7 @@ impl fmt::Debug for Dynamic {
Union::Float(value) => write!(f, "{:?}", value),
Union::Array(value) => write!(f, "{:?}", value),
Union::Map(value) => write!(f, "#{:?}", value),
Union::SubScope(value) => write!(f, "#{:?}", value),
Union::Module(value) => write!(f, "#{:?}", value),
Union::Variant(_) => write!(f, "<dynamic>"),
}
}
@ -240,7 +240,7 @@ impl Clone for Dynamic {
Union::Float(value) => Self(Union::Float(value)),
Union::Array(ref value) => Self(Union::Array(value.clone())),
Union::Map(ref value) => Self(Union::Map(value.clone())),
Union::SubScope(ref value) => Self(Union::SubScope(value.clone())),
Union::Module(ref value) => Self(Union::Module(value.clone())),
Union::Variant(ref value) => (***value).clone_into_dynamic(),
}
}
@ -369,7 +369,7 @@ impl Dynamic {
Union::Float(ref value) => (value as &dyn Any).downcast_ref::<T>().cloned(),
Union::Array(value) => cast_box::<_, T>(value).ok(),
Union::Map(value) => cast_box::<_, T>(value).ok(),
Union::SubScope(value) => cast_box::<_, T>(value).ok(),
Union::Module(value) => cast_box::<_, T>(value).ok(),
Union::Variant(value) => value.as_any().downcast_ref::<T>().cloned(),
}
}
@ -407,7 +407,7 @@ impl Dynamic {
Union::Float(ref value) => (value as &dyn Any).downcast_ref::<T>().unwrap().clone(),
Union::Array(value) => cast_box::<_, T>(value).unwrap(),
Union::Map(value) => cast_box::<_, T>(value).unwrap(),
Union::SubScope(value) => cast_box::<_, T>(value).unwrap(),
Union::Module(value) => cast_box::<_, T>(value).unwrap(),
Union::Variant(value) => value.as_any().downcast_ref::<T>().unwrap().clone(),
}
}
@ -430,7 +430,7 @@ impl Dynamic {
Union::Float(value) => (value as &dyn Any).downcast_ref::<T>(),
Union::Array(value) => (value.as_ref() as &dyn Any).downcast_ref::<T>(),
Union::Map(value) => (value.as_ref() as &dyn Any).downcast_ref::<T>(),
Union::SubScope(value) => (value.as_ref() as &dyn Any).downcast_ref::<T>(),
Union::Module(value) => (value.as_ref() as &dyn Any).downcast_ref::<T>(),
Union::Variant(value) => value.as_ref().as_ref().as_any().downcast_ref::<T>(),
}
}
@ -453,7 +453,7 @@ impl Dynamic {
Union::Float(value) => (value as &mut dyn Any).downcast_mut::<T>(),
Union::Array(value) => (value.as_mut() as &mut dyn Any).downcast_mut::<T>(),
Union::Map(value) => (value.as_mut() as &mut dyn Any).downcast_mut::<T>(),
Union::SubScope(value) => (value.as_mut() as &mut dyn Any).downcast_mut::<T>(),
Union::Module(value) => (value.as_mut() as &mut dyn Any).downcast_mut::<T>(),
Union::Variant(value) => value.as_mut().as_mut_any().downcast_mut::<T>(),
}
}

186
src/engine.rs
View File

@ -5,7 +5,7 @@ use crate::calc_fn_hash;
use crate::error::ParseErrorType;
use crate::optimize::OptimizationLevel;
use crate::packages::{CorePackage, Package, PackageLibrary, StandardPackage};
use crate::parser::{Expr, FnDef, ReturnType, Stmt};
use crate::parser::{Expr, FnDef, ModuleRef, ReturnType, Stmt};
use crate::result::EvalAltResult;
use crate::scope::{EntryType as ScopeEntryType, Scope};
use crate::token::Position;
@ -42,27 +42,27 @@ pub type Array = Vec<Dynamic>;
/// Not available under the `no_object` feature.
pub type Map = HashMap<String, Dynamic>;
/// A sub-scope - basically an imported module namespace.
/// An imported module.
///
/// Not available under the `no_import` feature.
/// Not available under the `no_module` feature.
#[derive(Debug, Clone)]
pub struct SubScope(HashMap<String, Dynamic>);
pub struct Module(HashMap<String, Dynamic>);
impl SubScope {
/// Create a new sub-scope.
impl Module {
/// Create a new module.
pub fn new() -> Self {
Self(HashMap::new())
}
}
impl Deref for SubScope {
impl Deref for Module {
type Target = HashMap<String, Dynamic>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl DerefMut for SubScope {
impl DerefMut for Module {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
@ -500,67 +500,61 @@ fn default_print(s: &str) {
}
/// Search for a variable within the scope
fn search_scope_variables<'a>(
fn search_scope<'a>(
scope: &'a mut Scope,
name: &str,
modules: &Option<Box<StaticVec<(String, Position)>>>,
index: Option<NonZeroUsize>,
pos: Position,
) -> Result<(&'a mut Dynamic, ScopeEntryType), Box<EvalAltResult>> {
let index = if let Some(index) = index {
scope.len() - index.get()
if let Some(modules) = modules {
let (id, root_pos) = modules.get(0); // First module
let mut module = if let Some(index) = index {
scope
.get_mut(scope.len() - index.get())
.0
.downcast_mut::<Module>()
.unwrap()
} else {
scope
.find_module(id)
.ok_or_else(|| Box::new(EvalAltResult::ErrorModuleNotFound(id.into(), *root_pos)))?
};
for x in 1..modules.len() {
let (id, id_pos) = modules.get(x);
module = module
.get_mut(id)
.and_then(|v| v.downcast_mut::<Module>())
.ok_or_else(|| Box::new(EvalAltResult::ErrorModuleNotFound(id.into(), *id_pos)))?;
}
let result = module
.get_mut(name)
.map(|v| (v, ScopeEntryType::Constant))
.ok_or_else(|| Box::new(EvalAltResult::ErrorVariableNotFound(name.into(), pos)))?;
if result.0.is::<Module>() {
Err(Box::new(EvalAltResult::ErrorVariableNotFound(
name.into(),
pos,
)))
} else {
Ok(result)
}
} else {
scope
.get_index(name)
.ok_or_else(|| Box::new(EvalAltResult::ErrorVariableNotFound(name.into(), pos)))?
.0
};
let index = if let Some(index) = index {
scope.len() - index.get()
} else {
scope
.get_index(name)
.ok_or_else(|| Box::new(EvalAltResult::ErrorVariableNotFound(name.into(), pos)))?
.0
};
Ok(scope.get_mut(index))
}
/// Search for a sub-scope within the scope
fn search_scope_modules<'a>(
scope: &'a mut Scope,
name: &str,
modules: &Box<StaticVec<(String, Position)>>,
index: Option<NonZeroUsize>,
pos: Position,
) -> Result<(&'a mut Dynamic, ScopeEntryType), Box<EvalAltResult>> {
let (id, root_pos) = modules.get(0); // First module
let mut sub_scope = if let Some(index) = index {
scope
.get_mut(scope.len() - index.get())
.0
.downcast_mut::<SubScope>()
.unwrap()
} else {
scope
.find_sub_scope(id)
.ok_or_else(|| Box::new(EvalAltResult::ErrorModuleNotFound(id.into(), *root_pos)))?
};
for x in 1..modules.len() {
let (id, id_pos) = modules.get(x);
sub_scope = sub_scope
.get_mut(id)
.and_then(|v| v.downcast_mut::<SubScope>())
.ok_or_else(|| Box::new(EvalAltResult::ErrorModuleNotFound(id.into(), *id_pos)))?;
}
let result = sub_scope
.get_mut(name)
.map(|v| (v, ScopeEntryType::Constant))
.ok_or_else(|| Box::new(EvalAltResult::ErrorVariableNotFound(name.into(), pos)))?;
if result.0.is::<SubScope>() {
Err(Box::new(EvalAltResult::ErrorVariableNotFound(
name.into(),
pos,
)))
} else {
Ok(result)
Ok(scope.get_mut(index))
}
}
@ -620,11 +614,13 @@ impl Engine {
}
/// Universal method for calling functions either registered with the `Engine` or written in Rhai
// TODO - handle moduled function call
pub(crate) fn call_fn_raw(
&self,
scope: Option<&mut Scope>,
fn_lib: &FunctionsLib,
fn_name: &str,
modules: &ModuleRef,
args: &mut FnCallArgs,
def_val: Option<&Dynamic>,
pos: Position,
@ -794,6 +790,7 @@ impl Engine {
&self,
fn_lib: &FunctionsLib,
fn_name: &str,
modules: &ModuleRef,
args: &mut FnCallArgs,
def_val: Option<&Dynamic>,
pos: Position,
@ -801,12 +798,20 @@ impl Engine {
) -> Result<Dynamic, Box<EvalAltResult>> {
match fn_name {
// type_of
KEYWORD_TYPE_OF if args.len() == 1 && !self.has_override(fn_lib, KEYWORD_TYPE_OF) => {
KEYWORD_TYPE_OF
if modules.is_none()
&& args.len() == 1
&& !self.has_override(fn_lib, KEYWORD_TYPE_OF) =>
{
Ok(self.map_type_name(args[0].type_name()).to_string().into())
}
// eval - reaching this point it must be a method-style call
KEYWORD_EVAL if args.len() == 1 && !self.has_override(fn_lib, KEYWORD_EVAL) => {
KEYWORD_EVAL
if modules.is_none()
&& args.len() == 1
&& !self.has_override(fn_lib, KEYWORD_EVAL) =>
{
Err(Box::new(EvalAltResult::ErrorRuntime(
"'eval' should not be called in method style. Try eval(...);".into(),
pos,
@ -814,7 +819,7 @@ impl Engine {
}
// Normal method call
_ => self.call_fn_raw(None, fn_lib, fn_name, args, def_val, pos, level),
_ => self.call_fn_raw(None, fn_lib, fn_name, modules, args, def_val, pos, level),
}
}
@ -915,7 +920,7 @@ impl Engine {
let def_val = def_val.as_deref();
// A function call is assumed to have side effects, so the value is changed
// TODO - Remove assumption of side effects by checking whether the first parameter is &mut
self.exec_fn_call(fn_lib, fn_name, &mut args, def_val, *pos, 0).map(|v| (v, true))
self.exec_fn_call(fn_lib, fn_name, &None, &mut args, def_val, *pos, 0).map(|v| (v, true))
}
// xxx.module::fn_name(...) - syntax error
Expr::FnCall(_,_,_,_,_) => unreachable!(),
@ -936,13 +941,13 @@ impl Engine {
Expr::Property(id, pos) if new_val.is_some() => {
let fn_name = make_setter(id);
let mut args = [obj, new_val.as_mut().unwrap()];
self.exec_fn_call(fn_lib, &fn_name, &mut args, None, *pos, 0).map(|v| (v, true))
self.exec_fn_call(fn_lib, &fn_name, &None, &mut args, None, *pos, 0).map(|v| (v, true))
}
// xxx.id
Expr::Property(id, pos) => {
let fn_name = make_getter(id);
let mut args = [obj];
self.exec_fn_call(fn_lib, &fn_name, &mut args, None, *pos, 0).map(|v| (v, false))
self.exec_fn_call(fn_lib, &fn_name, &None, &mut args, None, *pos, 0).map(|v| (v, false))
}
// {xxx:map}.idx_lhs[idx_expr]
Expr::Index(dot_lhs, dot_rhs, pos) |
@ -972,7 +977,7 @@ impl Engine {
let indexed_val = &mut (if let Expr::Property(id, pos) = dot_lhs.as_ref() {
let fn_name = make_getter(id);
self.exec_fn_call(fn_lib, &fn_name, &mut args[..1], None, *pos, 0)?
self.exec_fn_call(fn_lib, &fn_name, &None, &mut args[..1], None, *pos, 0)?
} else {
// Syntax error
return Err(Box::new(EvalAltResult::ErrorDotExpr(
@ -990,7 +995,7 @@ impl Engine {
let fn_name = make_setter(id);
// Re-use args because the first &mut parameter will not be consumed
args[1] = indexed_val;
self.exec_fn_call(fn_lib, &fn_name, &mut args, None, *pos, 0).or_else(|err| match *err {
self.exec_fn_call(fn_lib, &fn_name, &None, &mut args, None, *pos, 0).or_else(|err| match *err {
// If there is no setter, no need to feed it back because the property is read-only
EvalAltResult::ErrorDotExpr(_,_) => Ok(Default::default()),
err => Err(Box::new(err))
@ -1030,16 +1035,11 @@ impl Engine {
// id.??? or id[???]
Expr::Variable(id, modules, index, pos) => {
let index = if state.always_search { None } else { *index };
let (target, typ) = if let Some(modules) = modules {
search_scope_modules(scope, id, modules, index, *pos)?
} else {
search_scope_variables(scope, id, index, *pos)?
};
let (target, typ) = search_scope(scope, id, modules, index, *pos)?;
// Constants cannot be modified
match typ {
ScopeEntryType::SubScope => unreachable!(),
ScopeEntryType::Module => unreachable!(),
ScopeEntryType::Constant if new_val.is_some() => {
return Err(Box::new(EvalAltResult::ErrorAssignmentToConstant(
id.to_string(),
@ -1223,9 +1223,10 @@ impl Engine {
for value in rhs_value.iter_mut() {
let args = &mut [&mut lhs_value, value];
let def_value = Some(&def_value);
let pos = rhs.position();
if self
.call_fn_raw(None, fn_lib, "==", args, def_value, rhs.position(), level)?
.call_fn_raw(None, fn_lib, "==", &None, args, def_value, pos, level)?
.as_bool()
.unwrap_or(false)
{
@ -1268,13 +1269,7 @@ impl Engine {
Expr::CharConstant(c, _) => Ok((*c).into()),
Expr::Variable(id, modules, index, pos) => {
let index = if state.always_search { None } else { *index };
let val = if let Some(modules) = modules {
search_scope_modules(scope, id, modules, index, *pos)?
} else {
search_scope_variables(scope, id, index, *pos)?
};
let val = search_scope(scope, id, modules, index, *pos)?;
Ok(val.0.clone())
}
Expr::Property(_, _) => unreachable!(),
@ -1290,13 +1285,7 @@ impl Engine {
// name = rhs
Expr::Variable(name, modules, index, pos) => {
let index = if state.always_search { None } else { *index };
let val = if let Some(modules) = modules {
search_scope_modules(scope, name, modules, index, *pos)?
} else {
search_scope_variables(scope, name, index, *pos)?
};
match val {
match search_scope(scope, name, modules, index, *pos)? {
(_, ScopeEntryType::Constant) => Err(Box::new(
EvalAltResult::ErrorAssignmentToConstant(name.to_string(), *op_pos),
)),
@ -1304,8 +1293,8 @@ impl Engine {
*value_ptr = rhs_val;
Ok(Default::default())
}
// End variable cannot be a sub-scope
(_, ScopeEntryType::SubScope) => unreachable!(),
// End variable cannot be a module
(_, ScopeEntryType::Module) => unreachable!(),
}
}
// idx_lhs[idx_expr] = rhs
@ -1369,7 +1358,6 @@ impl Engine {
.collect::<Result<HashMap<_, _>, _>>()?,
)))),
// TODO - handle moduled function call
Expr::FnCall(fn_name, modules, arg_exprs, def_val, pos) => {
let mut arg_values = arg_exprs
.iter()
@ -1380,6 +1368,7 @@ impl Engine {
// eval - only in function call style
if fn_name.as_ref() == KEYWORD_EVAL
&& modules.is_none()
&& args.len() == 1
&& !self.has_override(fn_lib, KEYWORD_EVAL)
{
@ -1399,7 +1388,8 @@ impl Engine {
}
// Normal function call - except for eval (handled above)
self.exec_fn_call(fn_lib, fn_name, &mut args, def_val.as_deref(), *pos, level)
let def_value = def_val.as_deref();
self.exec_fn_call(fn_lib, fn_name, modules, &mut args, def_value, *pos, level)
}
Expr::In(lhs, rhs, _) => {
@ -1634,13 +1624,13 @@ impl Engine {
.eval_expr(scope, state, fn_lib, expr, level)?
.try_cast::<String>()
{
let mut module = SubScope::new();
let mut module = Module::new();
module.insert("kitty".to_string(), "foo".to_string().into());
module.insert("path".to_string(), path.into());
// TODO - avoid copying module name in inner block?
let mod_name = name.as_ref().clone();
scope.push_sub_scope(mod_name, module);
scope.push_module(mod_name, module);
Ok(Default::default())
} else {
Err(Box::new(EvalAltResult::ErrorImportExpr(expr.position())))

3
src/lib.rs
View File

@ -103,9 +103,6 @@ pub use engine::Array;
#[cfg(not(feature = "no_object"))]
pub use engine::Map;
#[cfg(not(feature = "no_import"))]
pub use engine::SubScope;
#[cfg(not(feature = "no_float"))]
pub use parser::FLOAT;

14
src/optimize.rs
View File

@ -231,6 +231,8 @@ fn optimize_stmt<'a>(stmt: Stmt, state: &mut State<'a>, preserve_result: bool) -
}
// let id;
Stmt::Let(_, None, _) => stmt,
// import expr as id;
Stmt::Import(expr, id, pos) => Stmt::Import(Box::new(optimize_expr(*expr, state)), id, pos),
// { block }
Stmt::Block(block, pos) => {
let orig_len = block.len(); // Original number of statements in the block, for change detection
@ -260,7 +262,7 @@ fn optimize_stmt<'a>(stmt: Stmt, state: &mut State<'a>, preserve_result: bool) -
result.push(stmt);
}
// Remove all let statements at the end of a block - the new variables will go away anyway.
// Remove all let/import statements at the end of a block - the new variables will go away anyway.
// But be careful only remove ones that have no initial values or have values that are pure expressions,
// otherwise there may be side effects.
let mut removed = false;
@ -268,7 +270,8 @@ fn optimize_stmt<'a>(stmt: Stmt, state: &mut State<'a>, preserve_result: bool) -
while let Some(expr) = result.pop() {
match expr {
Stmt::Let(_, None, _) => removed = true,
Stmt::Let(_, Some(val_expr), _) if val_expr.is_pure() => removed = true,
Stmt::Let(_, Some(val_expr), _) => removed = val_expr.is_pure(),
Stmt::Import(expr, _, _) => removed = expr.is_pure(),
_ => {
result.push(expr);
break;
@ -323,6 +326,8 @@ fn optimize_stmt<'a>(stmt: Stmt, state: &mut State<'a>, preserve_result: bool) -
state.set_dirty();
Stmt::Noop(pos)
}
// Only one let/import statement - leave it alone
[Stmt::Let(_, _, _)] | [Stmt::Import(_, _, _)] => Stmt::Block(result, pos),
// Only one statement - promote
[_] => {
state.set_dirty();
@ -666,7 +671,10 @@ fn optimize<'a>(
_ => {
// Keep all variable declarations at this level
// and always keep the last return value
let keep = matches!(stmt, Stmt::Let(_, _, _)) || i == num_statements - 1;
let keep = match stmt {
Stmt::Let(_, _, _) | Stmt::Import(_, _, _) => true,
_ => i == num_statements - 1,
};
optimize_stmt(stmt, &mut state, keep)
}
}

29
src/parser.rs
View File

@ -42,6 +42,8 @@ pub type FLOAT = f64;
type PERR = ParseErrorType;
pub type ModuleRef = Option<Box<StaticVec<(String, Position)>>>;
/// Compiled AST (abstract syntax tree) of a Rhai script.
///
/// Currently, `AST` is neither `Send` nor `Sync`. Turn on the `sync` feature to make it `Send + Sync`.
@ -204,7 +206,7 @@ impl Stack {
.enumerate()
.find(|(_, (n, typ))| match typ {
ScopeEntryType::Normal | ScopeEntryType::Constant => *n == name,
ScopeEntryType::SubScope => false,
ScopeEntryType::Module => false,
})
.and_then(|(i, _)| NonZeroUsize::new(i + 1))
}
@ -218,7 +220,7 @@ impl Stack {
.rev()
.enumerate()
.find(|(_, (n, typ))| match typ {
ScopeEntryType::SubScope => *n == name,
ScopeEntryType::Module => *n == name,
ScopeEntryType::Normal | ScopeEntryType::Constant => false,
})
.and_then(|(i, _)| NonZeroUsize::new(i + 1))
@ -344,12 +346,7 @@ pub enum Expr {
/// String constant.
StringConstant(String, Position),
/// Variable access - (variable name, optional modules, optional index, position)
Variable(
Box<String>,
Option<Box<StaticVec<(String, Position)>>>,
Option<NonZeroUsize>,
Position,
),
Variable(Box<String>, ModuleRef, Option<NonZeroUsize>, Position),
/// Property access.
Property(String, Position),
/// { stmt }
@ -359,7 +356,7 @@ pub enum Expr {
/// and the function names are predictable, so no need to allocate a new `String`.
FnCall(
Box<Cow<'static, str>>,
Option<Box<StaticVec<(String, Position)>>>,
ModuleRef,
Box<Vec<Expr>>,
Option<Box<Dynamic>>,
Position,
@ -575,12 +572,12 @@ impl Expr {
Self::Variable(_, None, _, _) => match token {
Token::LeftBracket | Token::LeftParen => true,
#[cfg(not(feature = "no_import"))]
#[cfg(not(feature = "no_module"))]
Token::DoubleColon => true,
_ => false,
},
Self::Variable(_, _, _, _) => match token {
#[cfg(not(feature = "no_import"))]
#[cfg(not(feature = "no_module"))]
Token::DoubleColon => true,
_ => false,
},
@ -659,7 +656,7 @@ fn parse_call_expr<'a>(
input: &mut Peekable<TokenIterator<'a>>,
stack: &mut Stack,
id: String,
modules: Option<Box<StaticVec<(String, Position)>>>,
modules: ModuleRef,
begin: Position,
allow_stmt_expr: bool,
) -> Result<Expr, Box<ParseError>> {
@ -1071,7 +1068,7 @@ fn parse_primary<'a>(
parse_call_expr(input, stack, id, None, pos, allow_stmt_expr)?
}
// module access
#[cfg(not(feature = "no_import"))]
#[cfg(not(feature = "no_module"))]
(Expr::Variable(id, mut modules, mut index, pos), Token::DoubleColon) => {
match input.next().unwrap() {
(Token::Identifier(id2), pos2) => {
@ -1790,7 +1787,7 @@ fn parse_let<'a>(
Err(PERR::ForbiddenConstantExpr(name).into_err(init_value.position()))
}
// Variable cannot be a sub-scope
ScopeEntryType::SubScope => unreachable!(),
ScopeEntryType::Module => unreachable!(),
}
} else {
// let name
@ -1799,7 +1796,7 @@ fn parse_let<'a>(
}
/// Parse an import statement.
#[cfg(not(feature = "no_import"))]
#[cfg(not(feature = "no_module"))]
fn parse_import<'a>(
input: &mut Peekable<TokenIterator<'a>>,
stack: &mut Stack,
@ -1829,7 +1826,7 @@ fn parse_import<'a>(
(_, pos) => return Err(PERR::VariableExpected.into_err(pos)),
};
stack.push((name.clone(), ScopeEntryType::SubScope));
stack.push((name.clone(), ScopeEntryType::Module));
Ok(Stmt::Import(Box::new(expr), Box::new(name), pos))
}

63
src/scope.rs
View File

@ -1,7 +1,7 @@
//! Module that defines the `Scope` type representing a function call-stack scope.
use crate::any::{Dynamic, Union, Variant};
use crate::engine::SubScope;
use crate::engine::Module;
use crate::parser::{map_dynamic_to_expr, Expr};
use crate::token::Position;
@ -14,8 +14,9 @@ pub enum EntryType {
Normal,
/// Immutable constant value.
Constant,
/// Name of a sub-scope, allowing member access with the :: operator.
SubScope,
/// Name of a module, allowing member access with the :: operator.
/// This is for internal use only.
Module,
}
/// An entry in the Scope.
@ -168,30 +169,14 @@ impl<'a> Scope<'a> {
self.push_dynamic_value(name, EntryType::Normal, value, false);
}
/// Add (push) a new sub-scope to the Scope.
/// Add (push) a new module to the Scope.
///
/// Sub-scopes are used for accessing members in modules and plugins under a namespace.
///
/// # Examples
///
/// ```
/// use rhai::{Scope, SubScope};
///
/// let mut my_scope = Scope::new();
///
/// let mut sub_scope = SubScope::new();
/// sub_scope.insert("x".to_string(), 42_i64.into());
///
/// my_scope.push_sub_scope("my_plugin", sub_scope);
///
/// let s = my_scope.find_sub_scope("my_plugin").unwrap();
/// assert_eq!(*s.get("x").unwrap().downcast_ref::<i64>().unwrap(), 42);
/// ```
pub fn push_sub_scope<K: Into<Cow<'a, str>>>(&mut self, name: K, value: SubScope) {
/// Modules are used for accessing member variables, functions and plugins under a namespace.
pub(crate) fn push_module<K: Into<Cow<'a, str>>>(&mut self, name: K, value: Module) {
self.push_dynamic_value(
name,
EntryType::SubScope,
Dynamic(Union::SubScope(Box::new(value))),
EntryType::Module,
Dynamic(Union::Module(Box::new(value))),
true,
);
}
@ -295,8 +280,6 @@ impl<'a> Scope<'a> {
/// Does the scope contain the entry?
///
/// Sub-scopes are ignored.
///
/// # Examples
///
/// ```
@ -314,13 +297,13 @@ impl<'a> Scope<'a> {
.rev() // Always search a Scope in reverse order
.any(|Entry { name: key, typ, .. }| match typ {
EntryType::Normal | EntryType::Constant => name == key,
EntryType::SubScope => false,
EntryType::Module => false,
})
}
/// Find an entry in the Scope, starting from the last.
///
/// Sub-scopes are ignored.
/// modules are ignored.
pub(crate) fn get_index(&self, name: &str) -> Option<(usize, EntryType)> {
self.0
.iter()
@ -334,18 +317,18 @@ impl<'a> Scope<'a> {
None
}
}
EntryType::SubScope => None,
EntryType::Module => None,
})
}
/// Find a sub-scope in the Scope, starting from the last.
pub(crate) fn get_sub_scope_index(&self, name: &str) -> Option<usize> {
/// Find a module in the Scope, starting from the last.
pub(crate) fn get_module_index(&self, name: &str) -> Option<usize> {
self.0
.iter()
.enumerate()
.rev() // Always search a Scope in reverse order
.find_map(|(index, Entry { name: key, typ, .. })| match typ {
EntryType::SubScope => {
EntryType::Module => {
if name == key {
Some(index)
} else {
@ -356,15 +339,15 @@ impl<'a> Scope<'a> {
})
}
/// Find a sub-scope in the Scope, starting from the last entry.
pub fn find_sub_scope(&mut self, name: &str) -> Option<&mut SubScope> {
let index = self.get_sub_scope_index(name)?;
self.get_mut(index).0.downcast_mut::<SubScope>()
/// Find a module in the Scope, starting from the last entry.
pub fn find_module(&mut self, name: &str) -> Option<&mut Module> {
let index = self.get_module_index(name)?;
self.get_mut(index).0.downcast_mut::<Module>()
}
/// Get the value of an entry in the Scope, starting from the last.
///
/// Sub-scopes are ignored.
/// modules are ignored.
///
/// # Examples
///
@ -382,7 +365,7 @@ impl<'a> Scope<'a> {
.rev()
.find(|Entry { name: key, typ, .. }| match typ {
EntryType::Normal | EntryType::Constant => name == key,
EntryType::SubScope => false,
EntryType::Module => false,
})
.and_then(|Entry { value, .. }| value.downcast_ref::<T>().cloned())
}
@ -415,8 +398,8 @@ impl<'a> Scope<'a> {
Some((index, EntryType::Normal)) => {
self.0.get_mut(index).unwrap().value = Dynamic::from(value)
}
// Sub-scopes cannot be modified
Some((_, EntryType::SubScope)) => unreachable!(),
// modules cannot be modified
Some((_, EntryType::Module)) => unreachable!(),
}
}

24
src/token.rs
View File

@ -153,7 +153,7 @@ pub enum Token {
RightShift,
SemiColon,
Colon,
#[cfg(not(feature = "no_import"))]
#[cfg(not(feature = "no_module"))]
DoubleColon,
Comma,
Period,
@ -199,11 +199,11 @@ pub enum Token {
XOrAssign,
ModuloAssign,
PowerOfAssign,
#[cfg(not(feature = "no_import"))]
#[cfg(not(feature = "no_module"))]
Import,
#[cfg(not(feature = "no_import"))]
#[cfg(not(feature = "no_module"))]
Export,
#[cfg(not(feature = "no_import"))]
#[cfg(not(feature = "no_module"))]
As,
LexError(Box<LexError>),
EOF,
@ -238,7 +238,7 @@ impl Token {
Divide => "/",
SemiColon => ";",
Colon => ":",
#[cfg(not(feature = "no_import"))]
#[cfg(not(feature = "no_module"))]
DoubleColon => "::",
Comma => ",",
Period => ".",
@ -288,11 +288,11 @@ impl Token {
ModuloAssign => "%=",
PowerOf => "~",
PowerOfAssign => "~=",
#[cfg(not(feature = "no_import"))]
#[cfg(not(feature = "no_module"))]
Import => "import",
#[cfg(not(feature = "no_import"))]
#[cfg(not(feature = "no_module"))]
Export => "export",
#[cfg(not(feature = "no_import"))]
#[cfg(not(feature = "no_module"))]
As => "as",
EOF => "{EOF}",
_ => panic!("operator should be match in outer scope"),
@ -763,11 +763,11 @@ impl<'a> TokenIterator<'a> {
"for" => Token::For,
"in" => Token::In,
#[cfg(not(feature = "no_import"))]
#[cfg(not(feature = "no_module"))]
"import" => Token::Import,
#[cfg(not(feature = "no_import"))]
#[cfg(not(feature = "no_module"))]
"export" => Token::Export,
#[cfg(not(feature = "no_import"))]
#[cfg(not(feature = "no_module"))]
"as" => Token::As,
#[cfg(not(feature = "no_function"))]
@ -924,7 +924,7 @@ impl<'a> TokenIterator<'a> {
}
('=', _) => return Some((Token::Equals, pos)),
#[cfg(not(feature = "no_import"))]
#[cfg(not(feature = "no_module"))]
(':', ':') => {
self.eat_next();
return Some((Token::DoubleColon, pos));

16
tests/modules.rs
View File

@ -1,15 +1 @@
use rhai::{EvalAltResult, Scope, SubScope, INT};
#[test]
#[cfg(not(feature = "no_import"))]
fn test_sub_scope() {
let mut my_scope = Scope::new();
let mut sub_scope = SubScope::new();
sub_scope.insert("x".to_string(), (42 as INT).into());
my_scope.push_sub_scope("my_plugin", sub_scope);
let s = my_scope.find_sub_scope("my_plugin").unwrap();
assert_eq!(*s.get("x").unwrap().downcast_ref::<INT>().unwrap(), 42);
}
use rhai::{EvalAltResult, Scope, INT};