use crate::any::{Dynamic, Union};
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::result::EvalAltResult;
use crate::scope::{EntryType as ScopeEntryType, Scope};
use crate::token::Position;
use crate::stdlib::{
any::TypeId,
boxed::Box,
collections::HashMap,
format,
hash::{Hash, Hasher},
iter::once,
mem,
ops::{Deref, DerefMut},
rc::Rc,
string::{String, ToString},
sync::Arc,
vec::Vec,
};
#[cfg(not(feature = "no_std"))]
use crate::stdlib::collections::hash_map::DefaultHasher;
#[cfg(feature = "no_std")]
use ahash::AHasher;
pub type Array = Vec<Dynamic>;
pub type Map = HashMap<String, Dynamic>;
pub type FnCallArgs<'a> = [&'a mut Dynamic];
#[cfg(feature = "sync")]
pub type FnAny =
dyn Fn(&mut FnCallArgs, Position) -> Result<Dynamic, Box<EvalAltResult>> + Send + Sync;
#[cfg(not(feature = "sync"))]
pub type FnAny = dyn Fn(&mut FnCallArgs, Position) -> Result<Dynamic, Box<EvalAltResult>>;
#[cfg(feature = "sync")]
pub type IteratorFn = dyn Fn(Dynamic) -> Box<dyn Iterator<Item = Dynamic>> + Send + Sync;
#[cfg(not(feature = "sync"))]
pub type IteratorFn = dyn Fn(Dynamic) -> Box<dyn Iterator<Item = Dynamic>>;
#[cfg(debug_assertions)]
pub const MAX_CALL_STACK_DEPTH: usize = 28;
#[cfg(not(debug_assertions))]
pub const MAX_CALL_STACK_DEPTH: usize = 256;
#[cfg(not(feature = "only_i32"))]
#[cfg(not(feature = "only_i64"))]
const FUNCTIONS_COUNT: usize = 512;
#[cfg(any(feature = "only_i32", feature = "only_i64"))]
const FUNCTIONS_COUNT: usize = 256;
pub const KEYWORD_PRINT: &str = "print";
pub const KEYWORD_DEBUG: &str = "debug";
pub const KEYWORD_TYPE_OF: &str = "type_of";
pub const KEYWORD_EVAL: &str = "eval";
pub const FUNC_TO_STRING: &str = "to_string";
pub const FUNC_GETTER: &str = "get$";
pub const FUNC_SETTER: &str = "set$";
enum Target<'a> {
Ref(&'a mut Dynamic),
Value(Box<Dynamic>),
StringChar(Box<(&'a mut Dynamic, usize, Dynamic)>),
}
impl Target<'_> {
pub fn into_dynamic(self) -> Dynamic {
match self {
Target::Ref(r) => r.clone(),
Target::Value(v) => *v,
Target::StringChar(s) => s.2,
}
}
pub fn set_value(&mut self, new_val: Dynamic, pos: Position) -> Result<(), Box<EvalAltResult>> {
match self {
Target::Ref(r) => **r = new_val,
Target::Value(_) => {
return Err(Box::new(EvalAltResult::ErrorAssignmentToUnknownLHS(pos)))
}
Target::StringChar(x) => match x.0 {
Dynamic(Union::Str(s)) => {
let new_ch = new_val
.as_char()
.map_err(|_| EvalAltResult::ErrorCharMismatch(pos))?;
let mut chars: Vec<char> = s.chars().collect();
let ch = *chars.get(x.1).expect("string index out of bounds");
if ch != new_ch {
chars[x.1] = new_ch;
s.clear();
chars.iter().for_each(|&ch| s.push(ch));
}
}
_ => panic!("should be String"),
},
}
Ok(())
}
}
impl<'a> From<&'a mut Dynamic> for Target<'a> {
fn from(value: &'a mut Dynamic) -> Self {
Self::Ref(value)
}
}
impl<T: Into<Dynamic>> From<T> for Target<'_> {
fn from(value: T) -> Self {
Self::Value(Box::new(value.into()))
}
}
struct StaticVec {
len: usize,
list: [Dynamic; 4],
more: Vec<Dynamic>,
}
impl StaticVec {
pub fn new() -> Self {
Self {
len: 0,
list: [().into(), ().into(), ().into(), ().into()],
more: Vec::new(),
}
}
pub fn push<T: Into<Dynamic>>(&mut self, value: T) {
if self.len >= self.list.len() {
self.more.push(value.into());
} else {
self.list[self.len] = value.into();
}
self.len += 1;
}
pub fn pop(&mut self) -> Dynamic {
let result = if self.len <= 0 {
panic!("nothing to pop!")
} else if self.len <= self.list.len() {
mem::replace(self.list.get_mut(self.len - 1).unwrap(), ().into())
} else {
self.more.pop().unwrap()
};
self.len -= 1;
result
}
}
#[derive(Debug, Clone, Copy)]
pub struct State {
pub always_search: bool,
}
impl State {
pub fn new() -> Self {
Self {
always_search: false,
}
}
}
#[derive(Debug, Clone)]
pub struct FunctionsLib(
#[cfg(feature = "sync")] HashMap<u64, Arc<FnDef>>,
#[cfg(not(feature = "sync"))] HashMap<u64, Rc<FnDef>>,
);
impl FunctionsLib {
pub fn new() -> Self {
FunctionsLib(HashMap::new())
}
pub fn from_vec(vec: Vec<FnDef>) -> Self {
FunctionsLib(
vec.into_iter()
.map(|f| {
let hash = calc_fn_def(&f.name, f.params.len());
#[cfg(feature = "sync")]
{
(hash, Arc::new(f))
}
#[cfg(not(feature = "sync"))]
{
(hash, Rc::new(f))
}
})
.collect(),
)
}
pub fn has_function(&self, name: &str, params: usize) -> bool {
self.contains_key(&calc_fn_def(name, params))
}
pub fn get_function(&self, name: &str, params: usize) -> Option<&FnDef> {
self.get(&calc_fn_def(name, params)).map(|f| f.as_ref())
}
pub fn merge(&self, other: &Self) -> Self {
if self.is_empty() {
other.clone()
} else if other.is_empty() {
self.clone()
} else {
let mut functions = self.clone();
functions.extend(other.iter().map(|(hash, fn_def)| (*hash, fn_def.clone())));
functions
}
}
}
impl Deref for FunctionsLib {
#[cfg(feature = "sync")]
type Target = HashMap<u64, Arc<FnDef>>;
#[cfg(not(feature = "sync"))]
type Target = HashMap<u64, Rc<FnDef>>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl DerefMut for FunctionsLib {
#[cfg(feature = "sync")]
fn deref_mut(&mut self) -> &mut HashMap<u64, Arc<FnDef>> {
&mut self.0
}
#[cfg(not(feature = "sync"))]
fn deref_mut(&mut self) -> &mut HashMap<u64, Rc<FnDef>> {
&mut self.0
}
}
pub struct Engine {
pub(crate) packages: Vec<PackageLibrary>,
pub(crate) functions: HashMap<u64, Box<FnAny>>,
pub(crate) type_iterators: HashMap<TypeId, Box<IteratorFn>>,
pub(crate) type_names: HashMap<String, String>,
#[cfg(feature = "sync")]
pub(crate) print: Box<dyn Fn(&str) + Send + Sync + 'static>,
#[cfg(not(feature = "sync"))]
pub(crate) print: Box<dyn Fn(&str) + 'static>,
#[cfg(feature = "sync")]
pub(crate) debug: Box<dyn Fn(&str) + Send + Sync + 'static>,
#[cfg(not(feature = "sync"))]
pub(crate) debug: Box<dyn Fn(&str) + 'static>,
pub(crate) optimization_level: OptimizationLevel,
pub(crate) max_call_stack_depth: usize,
}
impl Default for Engine {
fn default() -> Self {
let mut engine = Self {
packages: Vec::new(),
functions: HashMap::with_capacity(FUNCTIONS_COUNT),
type_iterators: HashMap::new(),
type_names: HashMap::new(),
print: Box::new(default_print),
debug: Box::new(default_print),
#[cfg(feature = "no_optimize")]
optimization_level: OptimizationLevel::None,
#[cfg(not(feature = "no_optimize"))]
#[cfg(not(feature = "optimize_full"))]
optimization_level: OptimizationLevel::Simple,
#[cfg(not(feature = "no_optimize"))]
#[cfg(feature = "optimize_full")]
optimization_level: OptimizationLevel::Full,
max_call_stack_depth: MAX_CALL_STACK_DEPTH,
};
#[cfg(feature = "no_stdlib")]
engine.load_package(CorePackage::new().get());
#[cfg(not(feature = "no_stdlib"))]
engine.load_package(StandardPackage::new().get());
engine
}
}
pub fn make_getter(id: &str) -> String {
format!("{}{}", FUNC_GETTER, id)
}
fn extract_prop_from_getter(fn_name: &str) -> Option<&str> {
#[cfg(not(feature = "no_object"))]
{
if fn_name.starts_with(FUNC_GETTER) {
Some(&fn_name[FUNC_GETTER.len()..])
} else {
None
}
}
#[cfg(feature = "no_object")]
{
None
}
}
pub fn make_setter(id: &str) -> String {
format!("{}{}", FUNC_SETTER, id)
}
fn extract_prop_from_setter(fn_name: &str) -> Option<&str> {
#[cfg(not(feature = "no_object"))]
{
if fn_name.starts_with(FUNC_SETTER) {
Some(&fn_name[FUNC_SETTER.len()..])
} else {
None
}
}
#[cfg(feature = "no_object")]
{
None
}
}
pub fn calc_fn_spec(fn_name: &str, params: impl Iterator<Item = TypeId>) -> u64 {
#[cfg(feature = "no_std")]
let mut s: AHasher = Default::default();
#[cfg(not(feature = "no_std"))]
let mut s = DefaultHasher::new();
s.write(fn_name.as_bytes());
params.for_each(|t| t.hash(&mut s));
s.finish()
}
pub(crate) fn calc_fn_def(fn_name: &str, params: usize) -> u64 {
#[cfg(feature = "no_std")]
let mut s: AHasher = Default::default();
#[cfg(not(feature = "no_std"))]
let mut s = DefaultHasher::new();
s.write(fn_name.as_bytes());
s.write_usize(params);
s.finish()
}
fn default_print(s: &str) {
#[cfg(not(feature = "no_std"))]
println!("{}", s);
}
fn search_scope<'a>(
scope: &'a mut Scope,
name: &str,
begin: Position,
) -> Result<(&'a mut Dynamic, ScopeEntryType), Box<EvalAltResult>> {
let (index, _) = scope
.get(name)
.ok_or_else(|| Box::new(EvalAltResult::ErrorVariableNotFound(name.into(), begin)))?;
Ok(scope.get_mut(index))
}
impl Engine {
pub fn new() -> Self {
Default::default()
}
pub fn new_raw() -> Self {
Self {
packages: Vec::new(),
functions: HashMap::with_capacity(FUNCTIONS_COUNT / 2),
type_iterators: HashMap::new(),
type_names: HashMap::new(),
print: Box::new(|_| {}),
debug: Box::new(|_| {}),
#[cfg(feature = "no_optimize")]
optimization_level: OptimizationLevel::None,
#[cfg(not(feature = "no_optimize"))]
#[cfg(not(feature = "optimize_full"))]
optimization_level: OptimizationLevel::Simple,
#[cfg(not(feature = "no_optimize"))]
#[cfg(feature = "optimize_full")]
optimization_level: OptimizationLevel::Full,
max_call_stack_depth: MAX_CALL_STACK_DEPTH,
}
}
pub fn load_package(&mut self, package: PackageLibrary) {
self.packages.insert(0, package);
}
#[cfg(not(feature = "no_optimize"))]
pub fn set_optimization_level(&mut self, optimization_level: OptimizationLevel) {
self.optimization_level = optimization_level
}
pub fn set_max_call_levels(&mut self, levels: usize) {
self.max_call_stack_depth = levels
}
pub(crate) fn call_fn_raw(
&self,
scope: Option<&mut Scope>,
fn_lib: &FunctionsLib,
fn_name: &str,
args: &mut FnCallArgs,
def_val: Option<&Dynamic>,
pos: Position,
level: usize,
) -> Result<Dynamic, Box<EvalAltResult>> {
if level > self.max_call_stack_depth {
return Err(Box::new(EvalAltResult::ErrorStackOverflow(pos)));
}
if let Some(fn_def) = fn_lib.get_function(fn_name, args.len()) {
return self.call_fn_from_lib(scope, fn_lib, fn_def, args, pos, level);
}
let fn_spec = calc_fn_hash(fn_name, args.iter().map(|a| a.type_id()));
if let Some(func) = self.functions.get(&fn_spec).or_else(|| {
self.packages
.iter()
.find(|pkg| pkg.functions.contains_key(&fn_spec))
.and_then(|pkg| pkg.functions.get(&fn_spec))
}) {
let result = func(args, pos)?;
return Ok(match fn_name {
KEYWORD_PRINT => (self.print)(result.as_str().map_err(|type_name| {
Box::new(EvalAltResult::ErrorMismatchOutputType(
type_name.into(),
pos,
))
})?)
.into(),
KEYWORD_DEBUG => (self.debug)(result.as_str().map_err(|type_name| {
Box::new(EvalAltResult::ErrorMismatchOutputType(
type_name.into(),
pos,
))
})?)
.into(),
_ => result,
});
}
if let Some(prop) = extract_prop_from_getter(fn_name) {
return Err(Box::new(EvalAltResult::ErrorDotExpr(
format!("- property '{}' unknown or write-only", prop),
pos,
)));
}
if let Some(prop) = extract_prop_from_setter(fn_name) {
return Err(Box::new(EvalAltResult::ErrorDotExpr(
format!("- property '{}' unknown or read-only", prop),
pos,
)));
}
if let Some(val) = def_val {
return Ok(val.clone());
}
let types_list: Vec<_> = args
.iter()
.map(|name| self.map_type_name(name.type_name()))
.collect();
Err(Box::new(EvalAltResult::ErrorFunctionNotFound(
format!("{} ({})", fn_name, types_list.join(", ")),
pos,
)))
}
pub(crate) fn call_fn_from_lib(
&self,
scope: Option<&mut Scope>,
fn_lib: &FunctionsLib,
fn_def: &FnDef,
args: &mut FnCallArgs,
pos: Position,
level: usize,
) -> Result<Dynamic, Box<EvalAltResult>> {
match scope {
Some(scope) if scope.len() > 0 => {
let scope_len = scope.len();
let mut state = State::new();
scope.extend(
fn_def
.params
.iter()
.zip(args.into_iter().map(|v| v.clone()))
.map(|(name, value)| (name.clone(), ScopeEntryType::Normal, value)),
);
let result = self
.eval_stmt(scope, &mut state, fn_lib, &fn_def.body, level + 1)
.or_else(|err| match *err {
EvalAltResult::Return(x, _) => Ok(x),
_ => Err(EvalAltResult::set_position(err, pos)),
});
scope.rewind(scope_len);
return result;
}
_ => {
let mut scope = Scope::new();
let mut state = State::new();
scope.extend(
fn_def
.params
.iter()
.zip(args.into_iter().map(|v| v.clone()))
.map(|(name, value)| (name, ScopeEntryType::Normal, value)),
);
return self
.eval_stmt(&mut scope, &mut state, fn_lib, &fn_def.body, level + 1)
.or_else(|err| match *err {
EvalAltResult::Return(x, _) => Ok(x),
_ => Err(EvalAltResult::set_position(err, pos)),
});
}
}
}
fn has_override(&self, fn_lib: &FunctionsLib, name: &str) -> bool {
let hash = calc_fn_hash(name, once(TypeId::of::<String>()));
self.functions.contains_key(&hash)
|| self.packages.iter().any(|p| p.functions.contains_key(&hash))
|| fn_lib.has_function(name, 1)
}
fn exec_fn_call(
&self,
fn_lib: &FunctionsLib,
fn_name: &str,
args: &mut [&mut Dynamic],
def_val: Option<&Dynamic>,
pos: Position,
level: usize,
) -> Result<Dynamic, Box<EvalAltResult>> {
match fn_name {
KEYWORD_TYPE_OF if args.len() == 1 && !self.has_override(fn_lib, KEYWORD_TYPE_OF) => {
Ok(self.map_type_name(args[0].type_name()).to_string().into())
}
KEYWORD_EVAL if 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,
)))
}
_ => self.call_fn_raw(None, fn_lib, fn_name, args, def_val, pos, level),
}
}
fn eval_script_expr(
&self,
scope: &mut Scope,
fn_lib: &FunctionsLib,
script: &Dynamic,
pos: Position,
) -> Result<Dynamic, Box<EvalAltResult>> {
let script = script
.as_str()
.map_err(|type_name| EvalAltResult::ErrorMismatchOutputType(type_name.into(), pos))?;
let mut ast = self.compile_with_scope_and_optimization_level(
&Scope::new(),
script,
OptimizationLevel::None,
)?;
if ast.1.len() > 0 {
return Err(Box::new(EvalAltResult::ErrorParsing(
ParseErrorType::WrongFnDefinition.into_err(pos),
)));
}
#[cfg(feature = "sync")]
{
ast.1 = Arc::new(fn_lib.clone());
}
#[cfg(not(feature = "sync"))]
{
ast.1 = Rc::new(fn_lib.clone());
}
self.eval_ast_with_scope_raw(scope, &ast)
.map_err(|err| EvalAltResult::set_position(err, pos))
}
fn eval_dot_index_chain_helper(
&self,
fn_lib: &FunctionsLib,
mut target: Target,
rhs: &Expr,
idx_values: &mut StaticVec,
is_index: bool,
op_pos: Position,
level: usize,
mut new_val: Option<Dynamic>,
) -> Result<(Dynamic, bool), Box<EvalAltResult>> {
let obj = match target {
Target::Ref(r) => r,
Target::Value(ref mut r) => r.as_mut(),
Target::StringChar(ref mut x) => &mut x.2,
};
let mut idx_val = idx_values.pop();
if is_index {
match rhs {
Expr::Dot(idx, idx_rhs, pos) |
Expr::Index(idx, idx_rhs, pos) => {
let is_index = matches!(rhs, Expr::Index(_,_,_));
let indexed_val = self.get_indexed_mut(obj, idx_val, idx.position(), op_pos, false)?;
self.eval_dot_index_chain_helper(
fn_lib, indexed_val, idx_rhs.as_ref(), idx_values, is_index, *pos, level, new_val
)
}
_ if new_val.is_some() => {
let mut indexed_val = self.get_indexed_mut(obj, idx_val, rhs.position(), op_pos, true)?;
indexed_val.set_value(new_val.unwrap(), rhs.position())?;
Ok((().into(), true))
}
_ => self
.get_indexed_mut(obj, idx_val, rhs.position(), op_pos, false)
.map(|v| (v.into_dynamic(), false))
}
} else {
match rhs {
Expr::FunctionCall(fn_name, _, def_val, pos) => {
let mut args: Vec<_> = once(obj)
.chain(idx_val.downcast_mut::<Array>().unwrap().iter_mut())
.collect();
let def_val = def_val.as_deref();
self.exec_fn_call(fn_lib, fn_name, &mut args, def_val, *pos, 0).map(|v| (v, true))
}
Expr::Property(id, pos) if obj.is::<Map>() && new_val.is_some() => {
let mut indexed_val =
self.get_indexed_mut(obj, id.to_string().into(), *pos, op_pos, true)?;
indexed_val.set_value(new_val.unwrap(), rhs.position())?;
Ok((().into(), true))
}
Expr::Property(id, pos) if obj.is::<Map>() => {
let indexed_val =
self.get_indexed_mut(obj, id.to_string().into(), *pos, op_pos, false)?;
Ok((indexed_val.into_dynamic(), false))
}
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))
}
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))
}
Expr::Index(dot_lhs, dot_rhs, pos) |
Expr::Dot(dot_lhs, dot_rhs, pos) if obj.is::<Map>() => {
let is_index = matches!(rhs, Expr::Index(_,_,_));
let indexed_val = if let Expr::Property(id, pos) = dot_lhs.as_ref() {
self.get_indexed_mut(obj, id.to_string().into(), *pos, op_pos, false)?
} else {
return Err(Box::new(EvalAltResult::ErrorDotExpr(
"".to_string(),
rhs.position(),
)));
};
self.eval_dot_index_chain_helper(
fn_lib, indexed_val, dot_rhs, idx_values, is_index, *pos, level, new_val
)
}
Expr::Index(dot_lhs, dot_rhs, pos) |
Expr::Dot(dot_lhs, dot_rhs, pos) => {
let is_index = matches!(rhs, Expr::Index(_,_,_));
let mut buf: Dynamic = ().into();
let mut args = [obj, &mut buf];
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)?
} else {
return Err(Box::new(EvalAltResult::ErrorDotExpr(
"".to_string(),
rhs.position(),
)));
});
let (result, changed) = self.eval_dot_index_chain_helper(
fn_lib, indexed_val.into(), dot_rhs, idx_values, is_index, *pos, level, new_val
)?;
if changed {
if let Expr::Property(id, pos) = dot_lhs.as_ref() {
let fn_name = make_setter(id);
args[1] = indexed_val;
self.exec_fn_call(fn_lib, &fn_name, &mut args, None, *pos, 0)?;
}
}
Ok((result, changed))
}
_ => Err(Box::new(EvalAltResult::ErrorDotExpr(
"".to_string(),
rhs.position(),
))),
}
}
}
fn eval_dot_index_chain(
&self,
scope: &mut Scope,
state: &mut State,
fn_lib: &FunctionsLib,
dot_lhs: &Expr,
dot_rhs: &Expr,
is_index: bool,
op_pos: Position,
level: usize,
new_val: Option<Dynamic>,
) -> Result<Dynamic, Box<EvalAltResult>> {
let idx_values = &mut StaticVec::new();
self.eval_indexed_chain(scope, state, fn_lib, dot_rhs, idx_values, 0, level)?;
match dot_lhs {
Expr::Variable(id, index, pos) => {
let (target, typ) = match index {
Some(i) if !state.always_search => scope.get_mut(scope.len() - i.get()),
_ => search_scope(scope, id, *pos)?,
};
match typ {
ScopeEntryType::Constant if new_val.is_some() => {
return Err(Box::new(EvalAltResult::ErrorAssignmentToConstant(
id.to_string(),
*pos,
)));
}
_ => (),
}
self.eval_dot_index_chain_helper(
fn_lib,
target.into(),
dot_rhs,
idx_values,
is_index,
op_pos,
level,
new_val,
)
.map(|(v, _)| v)
}
expr if new_val.is_some() => {
return Err(Box::new(EvalAltResult::ErrorAssignmentToUnknownLHS(
expr.position(),
)));
}
expr => {
let val = self.eval_expr(scope, state, fn_lib, expr, level)?;
self.eval_dot_index_chain_helper(
fn_lib,
val.into(),
dot_rhs,
idx_values,
is_index,
op_pos,
level,
new_val,
)
.map(|(v, _)| v)
}
}
}
fn eval_indexed_chain(
&self,
scope: &mut Scope,
state: &mut State,
fn_lib: &FunctionsLib,
expr: &Expr,
idx_values: &mut StaticVec,
size: usize,
level: usize,
) -> Result<(), Box<EvalAltResult>> {
match expr {
Expr::FunctionCall(_, arg_exprs, _, _) => {
let arg_values = arg_exprs
.iter()
.map(|arg_expr| self.eval_expr(scope, state, fn_lib, arg_expr, level))
.collect::<Result<Vec<_>, _>>()?;
idx_values.push(arg_values)
}
Expr::Property(_, _) => idx_values.push(()),
Expr::Index(lhs, rhs, _) | Expr::Dot(lhs, rhs, _) => {
let lhs_val = match lhs.as_ref() {
Expr::Property(_, _) => ().into(),
_ => self.eval_expr(scope, state, fn_lib, lhs, level)?,
};
self.eval_indexed_chain(scope, state, fn_lib, rhs, idx_values, size, level)?;
idx_values.push(lhs_val);
}
_ => idx_values.push(self.eval_expr(scope, state, fn_lib, expr, level)?),
}
Ok(())
}
fn get_indexed_mut<'a>(
&self,
val: &'a mut Dynamic,
idx: Dynamic,
idx_pos: Position,
op_pos: Position,
create: bool,
) -> Result<Target<'a>, Box<EvalAltResult>> {
let type_name = self.map_type_name(val.type_name());
match val {
Dynamic(Union::Array(arr)) => {
let index = idx
.as_int()
.map_err(|_| EvalAltResult::ErrorNumericIndexExpr(idx_pos))?;
let arr_len = arr.len();
if index >= 0 {
arr.get_mut(index as usize)
.map(Target::from)
.ok_or_else(|| {
Box::new(EvalAltResult::ErrorArrayBounds(arr_len, index, idx_pos))
})
} else {
Err(Box::new(EvalAltResult::ErrorArrayBounds(
arr_len, index, idx_pos,
)))
}
}
Dynamic(Union::Map(map)) => {
let index = idx
.take_string()
.map_err(|_| EvalAltResult::ErrorStringIndexExpr(idx_pos))?;
Ok(if create {
map.entry(index).or_insert(().into()).into()
} else {
map.get_mut(&index)
.map(Target::from)
.unwrap_or_else(|| Target::from(()))
})
}
Dynamic(Union::Str(s)) => {
let index = idx
.as_int()
.map_err(|_| EvalAltResult::ErrorNumericIndexExpr(idx_pos))?;
let num_chars = s.chars().count();
if index >= 0 {
let index = index as usize;
let ch = s.chars().nth(index).unwrap();
Ok(Target::StringChar(Box::new((val, index, ch.into()))))
} else {
Err(Box::new(EvalAltResult::ErrorStringBounds(
num_chars, index, idx_pos,
)))
}
}
_ => Err(Box::new(EvalAltResult::ErrorIndexingType(
type_name.to_string(),
op_pos,
))),
}
}
fn eval_in_expr(
&self,
scope: &mut Scope,
state: &mut State,
fn_lib: &FunctionsLib,
lhs: &Expr,
rhs: &Expr,
level: usize,
) -> Result<Dynamic, Box<EvalAltResult>> {
let mut lhs_value = self.eval_expr(scope, state, fn_lib, lhs, level)?;
let rhs_value = self.eval_expr(scope, state, fn_lib, rhs, level)?;
match rhs_value {
Dynamic(Union::Array(mut rhs_value)) => {
let def_value = false.into();
let mut result = false;
for value in rhs_value.iter_mut() {
let args = &mut [&mut lhs_value, value];
let def_value = Some(&def_value);
if self
.call_fn_raw(None, fn_lib, "==", args, def_value, rhs.position(), level)?
.as_bool()
.unwrap_or(false)
{
result = true;
break;
}
}
Ok(result.into())
}
Dynamic(Union::Map(rhs_value)) => {
match lhs_value {
Dynamic(Union::Str(s)) => Ok(rhs_value.contains_key(s.as_ref()).into()),
Dynamic(Union::Char(c)) => Ok(rhs_value.contains_key(&c.to_string()).into()),
_ => Err(Box::new(EvalAltResult::ErrorInExpr(lhs.position()))),
}
}
Dynamic(Union::Str(rhs_value)) => {
match lhs_value {
Dynamic(Union::Str(s)) => Ok(rhs_value.contains(s.as_ref()).into()),
Dynamic(Union::Char(c)) => Ok(rhs_value.contains(c).into()),
_ => Err(Box::new(EvalAltResult::ErrorInExpr(lhs.position()))),
}
}
_ => Err(Box::new(EvalAltResult::ErrorInExpr(rhs.position()))),
}
}
fn eval_expr(
&self,
scope: &mut Scope,
state: &mut State,
fn_lib: &FunctionsLib,
expr: &Expr,
level: usize,
) -> Result<Dynamic, Box<EvalAltResult>> {
match expr {
Expr::IntegerConstant(i, _) => Ok((*i).into()),
#[cfg(not(feature = "no_float"))]
Expr::FloatConstant(f, _) => Ok((*f).into()),
Expr::StringConstant(s, _) => Ok(s.to_string().into()),
Expr::CharConstant(c, _) => Ok((*c).into()),
Expr::Variable(_, Some(index), _) if !state.always_search => {
Ok(scope.get_mut(scope.len() - index.get()).0.clone())
}
Expr::Variable(id, _, pos) => search_scope(scope, id, *pos).map(|(v, _)| v.clone()),
Expr::Property(_, _) => panic!("unexpected property."),
Expr::Stmt(stmt, _) => self.eval_stmt(scope, state, fn_lib, stmt, level),
Expr::Assignment(lhs, rhs, op_pos) => {
let rhs_val = self.eval_expr(scope, state, fn_lib, rhs, level)?;
match lhs.as_ref() {
Expr::Variable(name, _, pos) => match scope.get(name) {
None => {
return Err(Box::new(EvalAltResult::ErrorVariableNotFound(
name.to_string(),
*pos,
)))
}
Some((index, ScopeEntryType::Normal)) => {
*scope.get_mut(index).0 = rhs_val.clone();
Ok(rhs_val)
}
Some((_, ScopeEntryType::Constant)) => Err(Box::new(
EvalAltResult::ErrorAssignmentToConstant(name.to_string(), *op_pos),
)),
},
#[cfg(not(feature = "no_index"))]
Expr::Index(idx_lhs, idx_expr, op_pos) => {
let new_val = Some(rhs_val);
self.eval_dot_index_chain(
scope, state, fn_lib, idx_lhs, idx_expr, true, *op_pos, level, new_val,
)
}
#[cfg(not(feature = "no_object"))]
Expr::Dot(dot_lhs, dot_rhs, _) => {
let new_val = Some(rhs_val);
self.eval_dot_index_chain(
scope, state, fn_lib, dot_lhs, dot_rhs, false, *op_pos, level, new_val,
)
}
expr if expr.is_constant() => {
Err(Box::new(EvalAltResult::ErrorAssignmentToConstant(
expr.get_constant_str(),
lhs.position(),
)))
}
_ => Err(Box::new(EvalAltResult::ErrorAssignmentToUnknownLHS(
lhs.position(),
))),
}
}
#[cfg(not(feature = "no_index"))]
Expr::Index(lhs, idx_expr, op_pos) => self.eval_dot_index_chain(
scope, state, fn_lib, lhs, idx_expr, true, *op_pos, level, None,
),
#[cfg(not(feature = "no_object"))]
Expr::Dot(lhs, dot_rhs, op_pos) => self.eval_dot_index_chain(
scope, state, fn_lib, lhs, dot_rhs, false, *op_pos, level, None,
),
#[cfg(not(feature = "no_index"))]
Expr::Array(contents, _) => {
let mut arr = Array::new();
contents.into_iter().try_for_each(|item| {
self.eval_expr(scope, state, fn_lib, item, level)
.map(|val| arr.push(val))
})?;
Ok(Dynamic(Union::Array(Box::new(arr))))
}
#[cfg(not(feature = "no_object"))]
Expr::Map(contents, _) => {
let mut map = Map::new();
contents.into_iter().try_for_each(|(key, expr, _)| {
self.eval_expr(scope, state, fn_lib, &expr, level)
.map(|val| {
map.insert(key.clone(), val);
})
})?;
Ok(Dynamic(Union::Map(Box::new(map))))
}
Expr::FunctionCall(fn_name, arg_exprs, def_val, pos) => {
let mut arg_values = arg_exprs
.iter()
.map(|expr| self.eval_expr(scope, state, fn_lib, expr, level))
.collect::<Result<Vec<_>, _>>()?;
let mut args: Vec<_> = arg_values.iter_mut().collect();
if fn_name == KEYWORD_EVAL
&& args.len() == 1
&& !self.has_override(fn_lib, KEYWORD_EVAL)
{
let prev_len = scope.len();
let result =
self.eval_script_expr(scope, fn_lib, args[0], arg_exprs[0].position());
if scope.len() != prev_len {
state.always_search = true;
}
return result;
}
let def_val = def_val.as_deref();
self.exec_fn_call(fn_lib, fn_name, &mut args, def_val, *pos, level)
}
Expr::In(lhs, rhs, _) => {
self.eval_in_expr(scope, state, fn_lib, lhs.as_ref(), rhs.as_ref(), level)
}
Expr::And(lhs, rhs, _) => Ok((self
.eval_expr(scope, state, fn_lib, lhs.as_ref(), level)?
.as_bool()
.map_err(|_| {
EvalAltResult::ErrorBooleanArgMismatch("AND".into(), lhs.position())
})?
&&
self
.eval_expr(scope, state, fn_lib, rhs.as_ref(), level)?
.as_bool()
.map_err(|_| {
EvalAltResult::ErrorBooleanArgMismatch("AND".into(), rhs.position())
})?)
.into()),
Expr::Or(lhs, rhs, _) => Ok((self
.eval_expr(scope, state, fn_lib, lhs.as_ref(), level)?
.as_bool()
.map_err(|_| {
EvalAltResult::ErrorBooleanArgMismatch("OR".into(), lhs.position())
})?
||
self
.eval_expr(scope, state, fn_lib, rhs.as_ref(), level)?
.as_bool()
.map_err(|_| {
EvalAltResult::ErrorBooleanArgMismatch("OR".into(), rhs.position())
})?)
.into()),
Expr::True(_) => Ok(true.into()),
Expr::False(_) => Ok(false.into()),
Expr::Unit(_) => Ok(().into()),
_ => panic!("should not appear: {:?}", expr),
}
}
pub(crate) fn eval_stmt(
&self,
scope: &mut Scope,
state: &mut State,
fn_lib: &FunctionsLib,
stmt: &Stmt,
level: usize,
) -> Result<Dynamic, Box<EvalAltResult>> {
match stmt {
Stmt::Noop(_) => Ok(().into()),
Stmt::Expr(expr) => {
let result = self.eval_expr(scope, state, fn_lib, expr, level)?;
Ok(if let Expr::Assignment(_, _, _) = *expr.as_ref() {
().into()
} else {
result
})
}
Stmt::Block(block, _) => {
let prev_len = scope.len();
let result = block.iter().try_fold(().into(), |_, stmt| {
self.eval_stmt(scope, state, fn_lib, stmt, level)
});
scope.rewind(prev_len);
state.always_search = false;
result
}
Stmt::IfThenElse(guard, if_body, else_body) => self
.eval_expr(scope, state, fn_lib, guard, level)?
.as_bool()
.map_err(|_| Box::new(EvalAltResult::ErrorLogicGuard(guard.position())))
.and_then(|guard_val| {
if guard_val {
self.eval_stmt(scope, state, fn_lib, if_body, level)
} else if let Some(stmt) = else_body {
self.eval_stmt(scope, state, fn_lib, stmt.as_ref(), level)
} else {
Ok(().into())
}
}),
Stmt::While(guard, body) => loop {
match self
.eval_expr(scope, state, fn_lib, guard, level)?
.as_bool()
{
Ok(true) => match self.eval_stmt(scope, state, fn_lib, body, level) {
Ok(_) => (),
Err(err) => match *err {
EvalAltResult::ErrorLoopBreak(false, _) => (),
EvalAltResult::ErrorLoopBreak(true, _) => return Ok(().into()),
_ => return Err(err),
},
},
Ok(false) => return Ok(().into()),
Err(_) => {
return Err(Box::new(EvalAltResult::ErrorLogicGuard(guard.position())))
}
}
},
Stmt::Loop(body) => loop {
match self.eval_stmt(scope, state, fn_lib, body, level) {
Ok(_) => (),
Err(err) => match *err {
EvalAltResult::ErrorLoopBreak(false, _) => (),
EvalAltResult::ErrorLoopBreak(true, _) => return Ok(().into()),
_ => return Err(err),
},
}
},
Stmt::For(name, expr, body) => {
let arr = self.eval_expr(scope, state, fn_lib, expr, level)?;
let tid = arr.type_id();
if let Some(iter_fn) = self.type_iterators.get(&tid).or_else(|| {
self.packages
.iter()
.find(|pkg| pkg.type_iterators.contains_key(&tid))
.and_then(|pkg| pkg.type_iterators.get(&tid))
}) {
scope.push(name.clone(), ());
let index = scope.len() - 1;
for a in iter_fn(arr) {
*scope.get_mut(index).0 = a;
match self.eval_stmt(scope, state, fn_lib, body, level) {
Ok(_) => (),
Err(err) => match *err {
EvalAltResult::ErrorLoopBreak(false, _) => (),
EvalAltResult::ErrorLoopBreak(true, _) => break,
_ => return Err(err),
},
}
}
scope.rewind(scope.len() - 1);
Ok(().into())
} else {
Err(Box::new(EvalAltResult::ErrorFor(expr.position())))
}
}
Stmt::Continue(pos) => Err(Box::new(EvalAltResult::ErrorLoopBreak(false, *pos))),
Stmt::Break(pos) => Err(Box::new(EvalAltResult::ErrorLoopBreak(true, *pos))),
Stmt::ReturnWithVal(None, ReturnType::Return, pos) => {
Err(Box::new(EvalAltResult::Return(().into(), *pos)))
}
Stmt::ReturnWithVal(Some(a), ReturnType::Return, pos) => Err(Box::new(
EvalAltResult::Return(self.eval_expr(scope, state, fn_lib, a, level)?, *pos),
)),
Stmt::ReturnWithVal(None, ReturnType::Exception, pos) => {
Err(Box::new(EvalAltResult::ErrorRuntime("".into(), *pos)))
}
Stmt::ReturnWithVal(Some(a), ReturnType::Exception, pos) => {
let val = self.eval_expr(scope, state, fn_lib, a, level)?;
Err(Box::new(EvalAltResult::ErrorRuntime(
val.take_string().unwrap_or_else(|_| "".to_string()),
*pos,
)))
}
Stmt::Let(name, Some(expr), _) => {
let val = self.eval_expr(scope, state, fn_lib, expr, level)?;
scope.push_dynamic_value(name.clone(), ScopeEntryType::Normal, val, false);
Ok(().into())
}
Stmt::Let(name, None, _) => {
scope.push(name.clone(), ());
Ok(().into())
}
Stmt::Const(name, expr, _) if expr.is_constant() => {
let val = self.eval_expr(scope, state, fn_lib, expr, level)?;
scope.push_dynamic_value(name.clone(), ScopeEntryType::Constant, val, true);
Ok(().into())
}
Stmt::Const(_, _, _) => panic!("constant expression not constant!"),
}
}
pub(crate) fn map_type_name<'a>(&'a self, name: &'a str) -> &'a str {
self.type_names
.get(name)
.map(String::as_str)
.unwrap_or(name)
}
}