2017-12-20 12:16:14 +01:00
|
|
|
use std::any::TypeId;
|
|
|
|
use std::cmp::{PartialEq, PartialOrd};
|
2016-02-29 22:43:45 +01:00
|
|
|
use std::collections::HashMap;
|
|
|
|
use std::error::Error;
|
2020-03-01 06:30:22 +01:00
|
|
|
use std::sync::Arc;
|
2016-02-29 22:43:45 +01:00
|
|
|
|
2020-02-25 08:02:27 +01:00
|
|
|
use crate::any::{Any, AnyExt, Dynamic, Variant};
|
2019-09-18 12:21:07 +02:00
|
|
|
use crate::call::FunArgs;
|
2020-03-01 10:37:47 +01:00
|
|
|
use crate::fn_register::RegisterFn;
|
2020-03-02 07:28:42 +01:00
|
|
|
use crate::parser::{Expr, FnDef, ParseError, Stmt};
|
2020-02-23 15:48:46 +01:00
|
|
|
|
2020-02-25 08:02:27 +01:00
|
|
|
pub type Array = Vec<Dynamic>;
|
|
|
|
pub type FnCallArgs<'a> = Vec<&'a mut Variant>;
|
2016-02-29 22:43:45 +01:00
|
|
|
|
2020-03-02 09:29:50 +01:00
|
|
|
#[derive(Debug)]
|
2016-03-03 15:31:42 +01:00
|
|
|
pub enum EvalAltResult {
|
2020-03-02 05:08:03 +01:00
|
|
|
ErrorParsing(ParseError),
|
2018-07-16 13:01:11 +02:00
|
|
|
ErrorFunctionNotFound(String),
|
2020-03-02 05:08:03 +01:00
|
|
|
ErrorFunctionArgsMismatch(String, usize),
|
|
|
|
ErrorBooleanArgMismatch(String),
|
2020-03-01 06:30:22 +01:00
|
|
|
ErrorArrayBounds(usize, i64),
|
|
|
|
ErrorStringBounds(usize, i64),
|
|
|
|
ErrorIndexing,
|
|
|
|
ErrorIndexExpr,
|
|
|
|
ErrorIfGuard,
|
|
|
|
ErrorFor,
|
2016-03-10 20:21:36 +01:00
|
|
|
ErrorVariableNotFound(String),
|
|
|
|
ErrorAssignmentToUnknownLHS,
|
2018-07-22 11:43:21 +02:00
|
|
|
ErrorMismatchOutputType(String),
|
2020-03-02 09:29:50 +01:00
|
|
|
ErrorCantOpenScriptFile(String, std::io::Error),
|
2020-03-01 06:30:22 +01:00
|
|
|
ErrorDotExpr,
|
2020-03-02 05:08:03 +01:00
|
|
|
ErrorArithmetic(String),
|
2016-03-03 15:31:42 +01:00
|
|
|
LoopBreak,
|
2020-02-25 08:02:27 +01:00
|
|
|
Return(Dynamic),
|
2016-02-29 22:43:45 +01:00
|
|
|
}
|
|
|
|
|
2018-07-16 13:01:11 +02:00
|
|
|
impl EvalAltResult {
|
|
|
|
fn as_str(&self) -> Option<&str> {
|
2020-02-29 10:10:51 +01:00
|
|
|
Some(match self {
|
2020-03-02 09:29:50 +01:00
|
|
|
Self::ErrorVariableNotFound(s)
|
2020-03-02 05:08:03 +01:00
|
|
|
| Self::ErrorFunctionNotFound(s)
|
|
|
|
| Self::ErrorMismatchOutputType(s)
|
|
|
|
| Self::ErrorArithmetic(s) => s,
|
2020-02-24 16:25:52 +01:00
|
|
|
_ => return None,
|
|
|
|
})
|
2018-07-16 13:01:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-20 21:09:53 +01:00
|
|
|
impl PartialEq for EvalAltResult {
|
|
|
|
fn eq(&self, other: &Self) -> bool {
|
|
|
|
use EvalAltResult::*;
|
|
|
|
|
|
|
|
match (self, other) {
|
2020-03-02 05:08:03 +01:00
|
|
|
(ErrorParsing(a), ErrorParsing(b)) => a == b,
|
|
|
|
(ErrorFunctionNotFound(a), ErrorFunctionNotFound(b)) => a == b,
|
|
|
|
(ErrorFunctionArgsMismatch(f1, n1), ErrorFunctionArgsMismatch(f2, n2)) => {
|
|
|
|
f1 == f2 && *n1 == *n2
|
|
|
|
}
|
|
|
|
(ErrorBooleanArgMismatch(a), ErrorBooleanArgMismatch(b)) => a == b,
|
2020-03-01 06:30:22 +01:00
|
|
|
(ErrorIndexExpr, ErrorIndexExpr) => true,
|
|
|
|
(ErrorIndexing, ErrorIndexing) => true,
|
|
|
|
(ErrorArrayBounds(max1, index1), ErrorArrayBounds(max2, index2)) => {
|
2020-02-23 06:59:50 +01:00
|
|
|
max1 == max2 && index1 == index2
|
|
|
|
}
|
2020-03-01 06:30:22 +01:00
|
|
|
(ErrorStringBounds(max1, index1), ErrorStringBounds(max2, index2)) => {
|
|
|
|
max1 == max2 && index1 == index2
|
|
|
|
}
|
|
|
|
(ErrorIfGuard, ErrorIfGuard) => true,
|
|
|
|
(ErrorFor, ErrorFor) => true,
|
2020-03-02 05:08:03 +01:00
|
|
|
(ErrorVariableNotFound(a), ErrorVariableNotFound(b)) => a == b,
|
2020-02-29 10:10:51 +01:00
|
|
|
(ErrorAssignmentToUnknownLHS, ErrorAssignmentToUnknownLHS) => true,
|
2020-03-02 05:08:03 +01:00
|
|
|
(ErrorMismatchOutputType(a), ErrorMismatchOutputType(b)) => a == b,
|
2020-03-02 09:29:50 +01:00
|
|
|
(ErrorCantOpenScriptFile(a, _), ErrorCantOpenScriptFile(b, _)) => a == b,
|
2020-03-01 06:30:22 +01:00
|
|
|
(ErrorDotExpr, ErrorDotExpr) => true,
|
2020-03-02 05:08:03 +01:00
|
|
|
(ErrorArithmetic(a), ErrorArithmetic(b)) => a == b,
|
2020-02-29 10:10:51 +01:00
|
|
|
(LoopBreak, LoopBreak) => true,
|
2017-12-20 21:09:53 +01:00
|
|
|
_ => false,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-03 15:31:42 +01:00
|
|
|
impl Error for EvalAltResult {
|
2016-02-29 22:43:45 +01:00
|
|
|
fn description(&self) -> &str {
|
2020-02-29 10:10:51 +01:00
|
|
|
match self {
|
2020-03-02 05:08:03 +01:00
|
|
|
Self::ErrorParsing(p) => p.description(),
|
2020-03-01 06:30:22 +01:00
|
|
|
Self::ErrorFunctionNotFound(_) => "Function not found",
|
2020-03-02 05:08:03 +01:00
|
|
|
Self::ErrorFunctionArgsMismatch(_, _) => "Function call with wrong number of arguments",
|
|
|
|
Self::ErrorBooleanArgMismatch(_) => "Boolean operator expects boolean operands",
|
2020-03-01 06:30:22 +01:00
|
|
|
Self::ErrorIndexExpr => "Indexing into an array or string expects an integer index",
|
|
|
|
Self::ErrorIndexing => "Indexing can only be performed on an array or a string",
|
2020-03-02 05:08:03 +01:00
|
|
|
Self::ErrorArrayBounds(_, index) if *index < 0 => {
|
2020-02-23 06:59:50 +01:00
|
|
|
"Array access expects non-negative index"
|
|
|
|
}
|
2020-03-02 05:08:03 +01:00
|
|
|
Self::ErrorArrayBounds(max, _) if *max == 0 => "Access of empty array",
|
2020-03-01 06:30:22 +01:00
|
|
|
Self::ErrorArrayBounds(_, _) => "Array index out of bounds",
|
2020-03-02 05:08:03 +01:00
|
|
|
Self::ErrorStringBounds(_, index) if *index < 0 => {
|
2020-03-01 06:30:22 +01:00
|
|
|
"Indexing a string expects a non-negative index"
|
2020-02-29 10:10:51 +01:00
|
|
|
}
|
2020-03-02 05:08:03 +01:00
|
|
|
Self::ErrorStringBounds(max, _) if *max == 0 => "Indexing of empty string",
|
2020-03-01 06:30:22 +01:00
|
|
|
Self::ErrorStringBounds(_, _) => "String index out of bounds",
|
|
|
|
Self::ErrorIfGuard => "If guards expect boolean expression",
|
|
|
|
Self::ErrorFor => "For loops expect array",
|
|
|
|
Self::ErrorVariableNotFound(_) => "Variable not found",
|
|
|
|
Self::ErrorAssignmentToUnknownLHS => {
|
2020-02-24 16:25:52 +01:00
|
|
|
"Assignment to an unsupported left-hand side expression"
|
2016-04-17 04:32:18 +02:00
|
|
|
}
|
2020-03-01 06:30:22 +01:00
|
|
|
Self::ErrorMismatchOutputType(_) => "Output type is incorrect",
|
2020-03-02 09:29:50 +01:00
|
|
|
Self::ErrorCantOpenScriptFile(_, _) => "Cannot open script file",
|
2020-03-01 06:30:22 +01:00
|
|
|
Self::ErrorDotExpr => "Malformed dot expression",
|
2020-03-02 05:08:03 +01:00
|
|
|
Self::ErrorArithmetic(_) => "Arithmetic error",
|
2020-03-01 06:30:22 +01:00
|
|
|
Self::LoopBreak => "[Not Error] Breaks out of loop",
|
|
|
|
Self::Return(_) => "[Not Error] Function returns value",
|
2016-02-29 22:43:45 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-18 12:21:07 +02:00
|
|
|
fn cause(&self) -> Option<&dyn Error> {
|
2016-02-29 22:43:45 +01:00
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-01 17:11:00 +01:00
|
|
|
impl std::fmt::Display for EvalAltResult {
|
|
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
2018-07-16 13:01:11 +02:00
|
|
|
if let Some(s) = self.as_str() {
|
|
|
|
write!(f, "{}: {}", self.description(), s)
|
|
|
|
} else {
|
2020-02-23 06:59:50 +01:00
|
|
|
match self {
|
2020-03-02 09:29:50 +01:00
|
|
|
Self::ErrorCantOpenScriptFile(filename, err) => {
|
|
|
|
write!(f, "Cannot open script file '{}': {}", filename, err)
|
|
|
|
}
|
|
|
|
Self::ErrorParsing(p) => write!(f, "Syntax error: {}", p),
|
|
|
|
Self::ErrorFunctionArgsMismatch(fun, n) => {
|
2020-03-02 05:08:03 +01:00
|
|
|
write!(f, "Function '{}' expects {} argument(s)", fun, n)
|
|
|
|
}
|
2020-03-02 09:29:50 +01:00
|
|
|
Self::ErrorBooleanArgMismatch(op) => {
|
2020-03-02 05:08:03 +01:00
|
|
|
write!(f, "Boolean {} operator expects boolean operands", op)
|
|
|
|
}
|
2020-03-02 09:29:50 +01:00
|
|
|
Self::ErrorArrayBounds(_, index) if *index < 0 => {
|
2020-03-01 06:30:22 +01:00
|
|
|
write!(f, "{}: {} < 0", self.description(), index)
|
|
|
|
}
|
2020-03-02 09:29:50 +01:00
|
|
|
Self::ErrorArrayBounds(max, _) if *max == 0 => write!(f, "{}", self.description()),
|
|
|
|
Self::ErrorArrayBounds(max, index) => {
|
2020-03-01 06:30:22 +01:00
|
|
|
write!(f, "{} (max {}): {}", self.description(), max - 1, index)
|
|
|
|
}
|
2020-03-02 09:29:50 +01:00
|
|
|
Self::ErrorStringBounds(_, index) if *index < 0 => {
|
2020-02-23 06:59:50 +01:00
|
|
|
write!(f, "{}: {} < 0", self.description(), index)
|
|
|
|
}
|
2020-03-02 09:29:50 +01:00
|
|
|
Self::ErrorStringBounds(max, _) if *max == 0 => write!(f, "{}", self.description()),
|
|
|
|
Self::ErrorStringBounds(max, index) => {
|
2020-02-23 06:59:50 +01:00
|
|
|
write!(f, "{} (max {}): {}", self.description(), max - 1, index)
|
|
|
|
}
|
2020-02-23 15:48:46 +01:00
|
|
|
err => write!(f, "{}", err.description()),
|
2020-02-23 06:59:50 +01:00
|
|
|
}
|
2018-07-16 13:01:11 +02:00
|
|
|
}
|
2016-02-29 22:43:45 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-20 12:16:14 +01:00
|
|
|
#[derive(Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
|
|
|
|
pub struct FnSpec {
|
2020-03-02 07:28:42 +01:00
|
|
|
pub ident: String,
|
|
|
|
pub args: Option<Vec<TypeId>>,
|
2016-03-02 02:45:02 +01:00
|
|
|
}
|
|
|
|
|
2020-02-25 08:02:27 +01:00
|
|
|
type IteratorFn = dyn Fn(&Dynamic) -> Box<dyn Iterator<Item = Dynamic>>;
|
2020-02-23 15:48:46 +01:00
|
|
|
|
2017-10-30 16:08:44 +01:00
|
|
|
/// Rhai's engine type. This is what you use to run Rhai scripts
|
|
|
|
///
|
|
|
|
/// ```rust
|
|
|
|
/// extern crate rhai;
|
|
|
|
/// use rhai::Engine;
|
|
|
|
///
|
|
|
|
/// fn main() {
|
|
|
|
/// let mut engine = Engine::new();
|
|
|
|
///
|
|
|
|
/// if let Ok(result) = engine.eval::<i64>("40 + 2") {
|
|
|
|
/// println!("Answer: {}", result); // prints 42
|
|
|
|
/// }
|
|
|
|
/// }
|
|
|
|
/// ```
|
2016-02-29 22:43:45 +01:00
|
|
|
pub struct Engine {
|
2020-03-02 07:28:42 +01:00
|
|
|
/// A hashmap containing all compiled functions known to the engine
|
|
|
|
fns: HashMap<FnSpec, Arc<FnIntExt>>,
|
|
|
|
/// A hashmap containing all script-defined functions
|
|
|
|
pub(crate) script_fns: HashMap<FnSpec, Arc<FnIntExt>>,
|
|
|
|
/// A hashmap containing all iterators known to the engine
|
|
|
|
type_iterators: HashMap<TypeId, Arc<IteratorFn>>,
|
|
|
|
|
|
|
|
pub(crate) on_print: Box<dyn Fn(&str)>,
|
|
|
|
pub(crate) on_debug: Box<dyn Fn(&str)>,
|
2017-12-20 12:16:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
pub enum FnIntExt {
|
|
|
|
Ext(Box<FnAny>),
|
|
|
|
Int(FnDef),
|
2016-02-29 22:43:45 +01:00
|
|
|
}
|
|
|
|
|
2020-02-25 08:02:27 +01:00
|
|
|
pub type FnAny = dyn Fn(FnCallArgs) -> Result<Dynamic, EvalAltResult>;
|
2017-12-20 12:16:14 +01:00
|
|
|
|
2017-10-30 16:08:44 +01:00
|
|
|
/// A type containing information about current scope.
|
|
|
|
/// Useful for keeping state between `Engine` runs
|
|
|
|
///
|
|
|
|
/// ```rust
|
|
|
|
/// use rhai::{Engine, Scope};
|
|
|
|
///
|
|
|
|
/// let mut engine = Engine::new();
|
|
|
|
/// let mut my_scope = Scope::new();
|
|
|
|
///
|
|
|
|
/// assert!(engine.eval_with_scope::<()>(&mut my_scope, "let x = 5;").is_ok());
|
|
|
|
/// assert_eq!(engine.eval_with_scope::<i64>(&mut my_scope, "x + 1").unwrap(), 6);
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// Between runs, `Engine` only remembers functions when not using own `Scope`.
|
2020-02-25 08:02:27 +01:00
|
|
|
pub type Scope = Vec<(String, Dynamic)>;
|
2016-03-02 02:45:02 +01:00
|
|
|
|
2016-02-29 22:43:45 +01:00
|
|
|
impl Engine {
|
2017-12-20 22:16:53 +01:00
|
|
|
pub fn call_fn<'a, I, A, T>(&self, ident: I, args: A) -> Result<T, EvalAltResult>
|
|
|
|
where
|
|
|
|
I: Into<String>,
|
|
|
|
A: FunArgs<'a>,
|
|
|
|
T: Any + Clone,
|
|
|
|
{
|
2020-03-02 07:28:42 +01:00
|
|
|
self.call_fn_raw(ident.into(), args.into_vec(), None)
|
2017-12-20 22:16:53 +01:00
|
|
|
.and_then(|b| {
|
|
|
|
b.downcast()
|
|
|
|
.map(|b| *b)
|
2019-09-30 19:57:21 +02:00
|
|
|
.map_err(|a| EvalAltResult::ErrorMismatchOutputType((*a).type_name()))
|
2017-12-20 22:16:53 +01:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2017-10-30 16:08:44 +01:00
|
|
|
/// Universal method for calling functions, that are either
|
|
|
|
/// registered with the `Engine` or written in Rhai
|
2020-03-02 07:28:42 +01:00
|
|
|
fn call_fn_raw(
|
|
|
|
&self,
|
|
|
|
ident: String,
|
|
|
|
args: FnCallArgs,
|
|
|
|
def_value: Option<&Dynamic>,
|
|
|
|
) -> Result<Dynamic, EvalAltResult> {
|
2018-02-09 22:27:41 +01:00
|
|
|
debug_println!(
|
2017-12-20 21:09:53 +01:00
|
|
|
"Trying to call function {:?} with args {:?}",
|
|
|
|
ident,
|
2020-02-23 15:48:46 +01:00
|
|
|
args.iter()
|
|
|
|
.map(|x| Any::type_name(&**x))
|
|
|
|
.collect::<Vec<_>>()
|
2017-12-20 21:09:53 +01:00
|
|
|
);
|
|
|
|
|
2020-03-02 08:19:41 +01:00
|
|
|
let mut spec = FnSpec {
|
2017-12-20 14:35:44 +01:00
|
|
|
ident: ident.clone(),
|
2020-03-02 08:19:41 +01:00
|
|
|
args: None,
|
2017-12-20 12:16:14 +01:00
|
|
|
};
|
2016-03-03 15:31:42 +01:00
|
|
|
|
2020-03-02 07:28:42 +01:00
|
|
|
// First search in script-defined functions (can override built-in),
|
2020-03-02 08:19:41 +01:00
|
|
|
// then in built-in's
|
|
|
|
let fn_def = self.script_fns.get(&spec).or_else(|| {
|
|
|
|
spec.args = Some(args.iter().map(|a| Any::type_id(&**a)).collect());
|
|
|
|
self.fns.get(&spec)
|
|
|
|
});
|
2020-03-02 07:28:42 +01:00
|
|
|
|
|
|
|
if let Some(f) = fn_def {
|
|
|
|
match **f {
|
2020-02-25 03:40:48 +01:00
|
|
|
FnIntExt::Ext(ref f) => {
|
|
|
|
let r = f(args);
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-02-25 03:40:48 +01:00
|
|
|
if r.is_err() {
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
let callback = match ident.as_str() {
|
|
|
|
"print" => &self.on_print,
|
|
|
|
"debug" => &self.on_debug,
|
|
|
|
_ => return r,
|
|
|
|
};
|
|
|
|
|
|
|
|
Ok(Box::new(callback(
|
|
|
|
r.unwrap()
|
|
|
|
.downcast::<String>()
|
|
|
|
.map(|x| *x)
|
|
|
|
.unwrap_or("error: not a string".into())
|
|
|
|
.as_str(),
|
|
|
|
)))
|
|
|
|
}
|
2017-12-20 21:09:53 +01:00
|
|
|
FnIntExt::Int(ref f) => {
|
|
|
|
let mut scope = Scope::new();
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2017-12-20 21:09:53 +01:00
|
|
|
scope.extend(
|
|
|
|
f.params
|
|
|
|
.iter()
|
|
|
|
.cloned()
|
2020-02-25 08:02:27 +01:00
|
|
|
.zip(args.iter().map(|x| (&**x).into_dynamic())),
|
2017-12-20 21:09:53 +01:00
|
|
|
);
|
|
|
|
|
|
|
|
match self.eval_stmt(&mut scope, &*f.body) {
|
|
|
|
Err(EvalAltResult::Return(x)) => Ok(x),
|
|
|
|
other => other,
|
|
|
|
}
|
|
|
|
}
|
2020-03-02 07:28:42 +01:00
|
|
|
}
|
|
|
|
} else if let Some(val) = def_value {
|
|
|
|
// Return default value
|
|
|
|
Ok(val.clone())
|
|
|
|
} else {
|
|
|
|
let type_names = args
|
|
|
|
.iter()
|
|
|
|
.map(|x| (*(&**x).into_dynamic()).type_name())
|
|
|
|
.collect::<Vec<_>>();
|
|
|
|
|
|
|
|
Err(EvalAltResult::ErrorFunctionNotFound(format!(
|
|
|
|
"{} ({})",
|
|
|
|
ident,
|
|
|
|
type_names.join(", ")
|
|
|
|
)))
|
|
|
|
}
|
2017-12-20 12:16:14 +01:00
|
|
|
}
|
2016-03-03 15:31:42 +01:00
|
|
|
|
2020-03-01 10:37:47 +01:00
|
|
|
pub(crate) fn register_fn_raw(
|
|
|
|
&mut self,
|
|
|
|
ident: String,
|
|
|
|
args: Option<Vec<TypeId>>,
|
|
|
|
f: Box<FnAny>,
|
|
|
|
) {
|
2018-02-09 22:27:41 +01:00
|
|
|
debug_println!("Register; {:?} with args {:?}", ident, args);
|
2017-12-20 21:09:53 +01:00
|
|
|
|
2017-12-20 14:35:44 +01:00
|
|
|
let spec = FnSpec { ident, args };
|
2016-03-03 15:31:42 +01:00
|
|
|
|
2017-12-31 19:58:50 +01:00
|
|
|
self.fns.insert(spec, Arc::new(FnIntExt::Ext(f)));
|
2016-03-02 16:49:24 +01:00
|
|
|
}
|
|
|
|
|
2017-10-30 16:08:44 +01:00
|
|
|
/// Register a type for use with Engine. Keep in mind that
|
|
|
|
/// your type must implement Clone.
|
2017-12-20 12:16:14 +01:00
|
|
|
pub fn register_type<T: Any>(&mut self) {
|
|
|
|
// currently a no-op, exists for future extensibility
|
2016-02-29 22:43:45 +01:00
|
|
|
}
|
|
|
|
|
2020-02-23 15:48:46 +01:00
|
|
|
/// Register an iterator adapter for a type.
|
|
|
|
pub fn register_iterator<T: Any, F>(&mut self, f: F)
|
|
|
|
where
|
2020-03-01 12:26:57 +01:00
|
|
|
F: Fn(&Dynamic) -> Box<dyn Iterator<Item = Dynamic>> + 'static,
|
2020-02-23 15:48:46 +01:00
|
|
|
{
|
|
|
|
self.type_iterators.insert(TypeId::of::<T>(), Arc::new(f));
|
|
|
|
}
|
|
|
|
|
2017-10-30 16:08:44 +01:00
|
|
|
/// Register a get function for a member of a registered type
|
2020-03-01 12:26:57 +01:00
|
|
|
pub fn register_get<T: Any + Clone, U: Any + Clone>(
|
|
|
|
&mut self,
|
|
|
|
name: &str,
|
|
|
|
get_fn: impl Fn(&mut T) -> U + 'static,
|
|
|
|
) {
|
2016-04-14 03:01:08 +02:00
|
|
|
let get_name = "get$".to_string() + name;
|
2016-03-17 13:45:48 +01:00
|
|
|
self.register_fn(&get_name, get_fn);
|
|
|
|
}
|
|
|
|
|
2017-10-30 16:08:44 +01:00
|
|
|
/// Register a set function for a member of a registered type
|
2020-03-01 12:26:57 +01:00
|
|
|
pub fn register_set<T: Any + Clone, U: Any + Clone>(
|
|
|
|
&mut self,
|
|
|
|
name: &str,
|
|
|
|
set_fn: impl Fn(&mut T, U) -> () + 'static,
|
|
|
|
) {
|
2016-04-14 03:01:08 +02:00
|
|
|
let set_name = "set$".to_string() + name;
|
2016-03-17 13:45:48 +01:00
|
|
|
self.register_fn(&set_name, set_fn);
|
|
|
|
}
|
|
|
|
|
2017-10-30 16:08:44 +01:00
|
|
|
/// Shorthand for registering both getters and setters
|
2020-03-01 12:26:57 +01:00
|
|
|
pub fn register_get_set<T: Any + Clone, U: Any + Clone>(
|
2017-12-20 12:16:14 +01:00
|
|
|
&mut self,
|
|
|
|
name: &str,
|
2020-03-01 12:26:57 +01:00
|
|
|
get_fn: impl Fn(&mut T) -> U + 'static,
|
|
|
|
set_fn: impl Fn(&mut T, U) -> () + 'static,
|
|
|
|
) {
|
2016-03-17 13:45:48 +01:00
|
|
|
self.register_get(name, get_fn);
|
|
|
|
self.register_set(name, set_fn);
|
|
|
|
}
|
|
|
|
|
2017-12-20 12:16:14 +01:00
|
|
|
fn get_dot_val_helper(
|
|
|
|
&self,
|
|
|
|
scope: &mut Scope,
|
2020-02-25 08:02:27 +01:00
|
|
|
this_ptr: &mut Variant,
|
2017-12-20 12:16:14 +01:00
|
|
|
dot_rhs: &Expr,
|
2020-02-25 08:02:27 +01:00
|
|
|
) -> Result<Dynamic, EvalAltResult> {
|
2017-12-20 12:16:14 +01:00
|
|
|
use std::iter::once;
|
|
|
|
|
2020-02-29 10:10:51 +01:00
|
|
|
match dot_rhs {
|
2020-03-02 07:28:42 +01:00
|
|
|
Expr::FunctionCall(fn_name, args, def_value) => {
|
2020-02-23 15:48:46 +01:00
|
|
|
let mut args: Array = args
|
2019-09-18 12:21:07 +02:00
|
|
|
.iter()
|
2017-12-20 12:16:14 +01:00
|
|
|
.map(|arg| self.eval_expr(scope, arg))
|
|
|
|
.collect::<Result<Vec<_>, _>>()?;
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2017-12-20 22:16:53 +01:00
|
|
|
let args = once(this_ptr)
|
|
|
|
.chain(args.iter_mut().map(|b| b.as_mut()))
|
|
|
|
.collect();
|
2017-12-20 12:16:14 +01:00
|
|
|
|
2020-03-02 07:28:42 +01:00
|
|
|
self.call_fn_raw(fn_name.into(), args, def_value.as_ref())
|
2016-03-07 21:39:02 +01:00
|
|
|
}
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-02-29 10:10:51 +01:00
|
|
|
Expr::Identifier(id) => {
|
2016-03-07 21:39:02 +01:00
|
|
|
let get_fn_name = "get$".to_string() + id;
|
2017-12-20 12:16:14 +01:00
|
|
|
|
2020-03-02 07:28:42 +01:00
|
|
|
self.call_fn_raw(get_fn_name, vec![this_ptr], None)
|
2016-03-07 21:39:02 +01:00
|
|
|
}
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-02-29 10:10:51 +01:00
|
|
|
Expr::Index(id, idx_raw) => {
|
2020-03-01 06:30:22 +01:00
|
|
|
let idx = self
|
|
|
|
.eval_expr(scope, idx_raw)?
|
|
|
|
.downcast_ref::<i64>()
|
|
|
|
.map(|i| *i)
|
|
|
|
.ok_or(EvalAltResult::ErrorIndexExpr)?;
|
|
|
|
|
2016-03-26 21:32:20 +01:00
|
|
|
let get_fn_name = "get$".to_string() + id;
|
2016-04-14 03:01:08 +02:00
|
|
|
|
2020-03-02 07:28:42 +01:00
|
|
|
let mut val = self.call_fn_raw(get_fn_name, vec![this_ptr], None)?;
|
2017-12-20 12:16:14 +01:00
|
|
|
|
2020-03-01 06:30:22 +01:00
|
|
|
if let Some(arr) = (*val).downcast_mut() as Option<&mut Array> {
|
2020-03-01 17:11:00 +01:00
|
|
|
if idx >= 0 {
|
2020-03-01 06:30:22 +01:00
|
|
|
arr.get(idx as usize)
|
2020-02-23 06:59:50 +01:00
|
|
|
.cloned()
|
2020-03-01 06:30:22 +01:00
|
|
|
.ok_or_else(|| EvalAltResult::ErrorArrayBounds(arr.len(), idx))
|
2020-03-01 17:11:00 +01:00
|
|
|
} else {
|
|
|
|
Err(EvalAltResult::ErrorArrayBounds(arr.len(), idx))
|
2020-03-01 06:30:22 +01:00
|
|
|
}
|
|
|
|
} else if let Some(s) = (*val).downcast_mut() as Option<&mut String> {
|
2020-03-01 17:11:00 +01:00
|
|
|
if idx >= 0 {
|
2020-03-01 06:30:22 +01:00
|
|
|
s.chars()
|
|
|
|
.nth(idx as usize)
|
|
|
|
.map(|ch| Box::new(ch) as Dynamic)
|
|
|
|
.ok_or_else(|| EvalAltResult::ErrorStringBounds(s.chars().count(), idx))
|
2020-03-01 17:11:00 +01:00
|
|
|
} else {
|
|
|
|
Err(EvalAltResult::ErrorStringBounds(s.chars().count(), idx))
|
2020-03-01 06:30:22 +01:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
Err(EvalAltResult::ErrorIndexing)
|
|
|
|
}
|
2016-03-26 21:32:20 +01:00
|
|
|
}
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-02-29 10:10:51 +01:00
|
|
|
Expr::Dot(inner_lhs, inner_rhs) => match **inner_lhs {
|
2017-12-20 12:16:14 +01:00
|
|
|
Expr::Identifier(ref id) => {
|
|
|
|
let get_fn_name = "get$".to_string() + id;
|
2020-03-01 06:30:22 +01:00
|
|
|
let value = self
|
2020-03-02 07:28:42 +01:00
|
|
|
.call_fn_raw(get_fn_name, vec![this_ptr], None)
|
2020-03-01 06:30:22 +01:00
|
|
|
.and_then(|mut v| self.get_dot_val_helper(scope, v.as_mut(), inner_rhs))?;
|
|
|
|
|
|
|
|
// TODO - Should propagate changes back in this scenario:
|
|
|
|
//
|
|
|
|
// fn update(p) { p = something_else; }
|
|
|
|
// obj.prop.update();
|
|
|
|
//
|
|
|
|
// Right now, a copy of the object's property value is mutated, but not propagated
|
|
|
|
// back to the property via $set.
|
|
|
|
|
|
|
|
Ok(value)
|
|
|
|
}
|
|
|
|
Expr::Index(_, _) => {
|
|
|
|
// TODO - Handle Expr::Index for these scenarios:
|
|
|
|
//
|
|
|
|
// let x = obj.prop[2].x;
|
|
|
|
// obj.prop[3] = 42;
|
|
|
|
//
|
|
|
|
Err(EvalAltResult::ErrorDotExpr)
|
2016-03-10 20:21:36 +01:00
|
|
|
}
|
2020-03-01 06:30:22 +01:00
|
|
|
_ => Err(EvalAltResult::ErrorDotExpr),
|
2017-12-20 12:16:14 +01:00
|
|
|
},
|
2020-03-01 06:30:22 +01:00
|
|
|
_ => Err(EvalAltResult::ErrorDotExpr),
|
2016-03-07 21:39:02 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-01 12:26:57 +01:00
|
|
|
fn search_scope<'a, T>(
|
2017-12-20 17:37:12 +01:00
|
|
|
scope: &'a mut Scope,
|
|
|
|
id: &str,
|
2020-03-01 12:26:57 +01:00
|
|
|
map: impl FnOnce(&'a mut Variant) -> Result<T, EvalAltResult>,
|
|
|
|
) -> Result<(usize, T), EvalAltResult> {
|
2017-12-20 17:37:12 +01:00
|
|
|
scope
|
|
|
|
.iter_mut()
|
|
|
|
.enumerate()
|
|
|
|
.rev()
|
2020-02-29 10:10:51 +01:00
|
|
|
.find(|&(_, &mut (ref name, _))| id == name)
|
2020-03-02 07:28:42 +01:00
|
|
|
.ok_or_else(|| EvalAltResult::ErrorVariableNotFound(id.into()))
|
2017-12-20 21:52:26 +01:00
|
|
|
.and_then(move |(idx, &mut (_, ref mut val))| map(val.as_mut()).map(|val| (idx, val)))
|
2017-12-20 17:37:12 +01:00
|
|
|
}
|
|
|
|
|
2020-03-01 06:30:22 +01:00
|
|
|
fn indexed_value(
|
2017-12-20 21:09:53 +01:00
|
|
|
&self,
|
|
|
|
scope: &mut Scope,
|
|
|
|
id: &str,
|
|
|
|
idx: &Expr,
|
2020-03-01 06:30:22 +01:00
|
|
|
) -> Result<(bool, usize, usize, Dynamic), EvalAltResult> {
|
|
|
|
let idx = *self
|
2019-09-18 12:21:07 +02:00
|
|
|
.eval_expr(scope, idx)?
|
2017-12-20 17:37:12 +01:00
|
|
|
.downcast::<i64>()
|
2020-03-01 06:30:22 +01:00
|
|
|
.map_err(|_| EvalAltResult::ErrorIndexExpr)?;
|
|
|
|
|
|
|
|
let mut is_array = false;
|
|
|
|
|
|
|
|
Self::search_scope(scope, id, |val| {
|
|
|
|
if let Some(arr) = (*val).downcast_mut() as Option<&mut Array> {
|
|
|
|
is_array = true;
|
|
|
|
|
2020-03-01 17:11:00 +01:00
|
|
|
if idx >= 0 {
|
2020-03-01 06:30:22 +01:00
|
|
|
arr.get(idx as usize)
|
2020-02-23 06:59:50 +01:00
|
|
|
.cloned()
|
2020-03-01 06:30:22 +01:00
|
|
|
.ok_or_else(|| EvalAltResult::ErrorArrayBounds(arr.len(), idx))
|
2020-03-01 17:11:00 +01:00
|
|
|
} else {
|
|
|
|
Err(EvalAltResult::ErrorArrayBounds(arr.len(), idx))
|
|
|
|
}
|
|
|
|
} else if let Some(s) = (*val).downcast_mut() as Option<&mut String> {
|
2020-03-01 06:30:22 +01:00
|
|
|
is_array = false;
|
|
|
|
|
2020-03-01 17:11:00 +01:00
|
|
|
if idx >= 0 {
|
2020-03-01 06:30:22 +01:00
|
|
|
s.chars()
|
|
|
|
.nth(idx as usize)
|
|
|
|
.map(|ch| Box::new(ch) as Dynamic)
|
|
|
|
.ok_or_else(|| EvalAltResult::ErrorStringBounds(s.chars().count(), idx))
|
2020-03-01 17:11:00 +01:00
|
|
|
} else {
|
|
|
|
Err(EvalAltResult::ErrorStringBounds(s.chars().count(), idx))
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
Err(EvalAltResult::ErrorIndexing)
|
2020-03-01 06:30:22 +01:00
|
|
|
}
|
|
|
|
})
|
|
|
|
.map(|(idx_sc, val)| (is_array, idx_sc, idx as usize, val))
|
|
|
|
}
|
|
|
|
|
|
|
|
fn str_replace_char(s: &mut String, idx: usize, new_ch: char) {
|
|
|
|
// The new character
|
|
|
|
let ch = s.chars().nth(idx).unwrap();
|
|
|
|
|
|
|
|
// See if changed - if so, update the String
|
|
|
|
if ch == new_ch {
|
|
|
|
return;
|
|
|
|
}
|
2017-12-20 17:37:12 +01:00
|
|
|
|
2020-03-01 06:30:22 +01:00
|
|
|
// Collect all the characters after the index
|
|
|
|
let mut chars: Vec<char> = s.chars().collect();
|
|
|
|
chars[idx] = new_ch;
|
2020-03-01 10:37:47 +01:00
|
|
|
s.clear();
|
2020-03-01 06:30:22 +01:00
|
|
|
chars.iter().for_each(|&ch| s.push(ch));
|
2017-12-20 17:37:12 +01:00
|
|
|
}
|
|
|
|
|
2017-12-20 12:16:14 +01:00
|
|
|
fn get_dot_val(
|
|
|
|
&self,
|
|
|
|
scope: &mut Scope,
|
|
|
|
dot_lhs: &Expr,
|
|
|
|
dot_rhs: &Expr,
|
2020-02-25 08:02:27 +01:00
|
|
|
) -> Result<Dynamic, EvalAltResult> {
|
2020-02-29 10:10:51 +01:00
|
|
|
match dot_lhs {
|
|
|
|
Expr::Identifier(id) => {
|
2020-02-25 08:02:27 +01:00
|
|
|
let (sc_idx, mut target) = Self::search_scope(scope, id, |x| Ok(x.into_dynamic()))?;
|
2017-12-20 21:52:26 +01:00
|
|
|
let value = self.get_dot_val_helper(scope, target.as_mut(), dot_rhs);
|
2017-12-20 17:37:12 +01:00
|
|
|
|
|
|
|
// In case the expression mutated `target`, we need to reassign it because
|
|
|
|
// of the above `clone`.
|
|
|
|
scope[sc_idx].1 = target;
|
|
|
|
|
|
|
|
value
|
2016-03-07 21:39:02 +01:00
|
|
|
}
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-02-29 10:10:51 +01:00
|
|
|
Expr::Index(id, idx_raw) => {
|
2020-03-01 06:30:22 +01:00
|
|
|
let (is_array, sc_idx, idx, mut target) = self.indexed_value(scope, id, idx_raw)?;
|
2017-12-20 21:52:26 +01:00
|
|
|
let value = self.get_dot_val_helper(scope, target.as_mut(), dot_rhs);
|
2017-12-20 17:37:12 +01:00
|
|
|
|
|
|
|
// In case the expression mutated `target`, we need to reassign it because
|
|
|
|
// of the above `clone`.
|
2020-03-01 06:30:22 +01:00
|
|
|
|
|
|
|
if is_array {
|
|
|
|
scope[sc_idx].1.downcast_mut::<Array>().unwrap()[idx] = target;
|
|
|
|
} else {
|
2020-03-01 17:11:00 +01:00
|
|
|
Self::str_replace_char(
|
|
|
|
scope[sc_idx].1.downcast_mut::<String>().unwrap(), // Root is a string
|
|
|
|
idx,
|
|
|
|
*target.downcast::<char>().unwrap(), // Target should be a char
|
|
|
|
);
|
2020-03-01 06:30:22 +01:00
|
|
|
}
|
2017-12-20 17:37:12 +01:00
|
|
|
|
|
|
|
value
|
2016-03-26 21:32:20 +01:00
|
|
|
}
|
2020-03-01 06:30:22 +01:00
|
|
|
_ => Err(EvalAltResult::ErrorDotExpr),
|
2016-03-07 21:39:02 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-20 12:16:14 +01:00
|
|
|
fn set_dot_val_helper(
|
|
|
|
&self,
|
2020-02-25 08:02:27 +01:00
|
|
|
this_ptr: &mut Variant,
|
2017-12-20 12:16:14 +01:00
|
|
|
dot_rhs: &Expr,
|
2020-02-25 08:02:27 +01:00
|
|
|
mut source_val: Dynamic,
|
|
|
|
) -> Result<Dynamic, EvalAltResult> {
|
2020-02-29 10:10:51 +01:00
|
|
|
match dot_rhs {
|
|
|
|
Expr::Identifier(id) => {
|
2016-03-07 21:39:02 +01:00
|
|
|
let set_fn_name = "set$".to_string() + id;
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-03-02 07:28:42 +01:00
|
|
|
self.call_fn_raw(set_fn_name, vec![this_ptr, source_val.as_mut()], None)
|
2016-03-07 21:39:02 +01:00
|
|
|
}
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-02-29 10:10:51 +01:00
|
|
|
Expr::Dot(inner_lhs, inner_rhs) => match **inner_lhs {
|
2017-12-20 12:16:14 +01:00
|
|
|
Expr::Identifier(ref id) => {
|
|
|
|
let get_fn_name = "get$".to_string() + id;
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-03-02 07:28:42 +01:00
|
|
|
self.call_fn_raw(get_fn_name, vec![this_ptr], None)
|
2017-12-20 21:09:53 +01:00
|
|
|
.and_then(|mut v| {
|
2017-12-20 21:52:26 +01:00
|
|
|
self.set_dot_val_helper(v.as_mut(), inner_rhs, source_val)
|
2017-12-20 21:09:53 +01:00
|
|
|
.map(|_| v) // Discard Ok return value
|
|
|
|
})
|
2017-12-20 12:16:14 +01:00
|
|
|
.and_then(|mut v| {
|
|
|
|
let set_fn_name = "set$".to_string() + id;
|
|
|
|
|
2020-03-02 07:28:42 +01:00
|
|
|
self.call_fn_raw(set_fn_name, vec![this_ptr, v.as_mut()], None)
|
2017-12-20 12:16:14 +01:00
|
|
|
})
|
2016-03-10 20:21:36 +01:00
|
|
|
}
|
2020-03-01 06:30:22 +01:00
|
|
|
_ => Err(EvalAltResult::ErrorDotExpr),
|
2017-12-20 12:16:14 +01:00
|
|
|
},
|
2020-03-01 06:30:22 +01:00
|
|
|
_ => Err(EvalAltResult::ErrorDotExpr),
|
2016-03-07 21:39:02 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-20 12:16:14 +01:00
|
|
|
fn set_dot_val(
|
|
|
|
&self,
|
|
|
|
scope: &mut Scope,
|
|
|
|
dot_lhs: &Expr,
|
|
|
|
dot_rhs: &Expr,
|
2020-02-25 08:02:27 +01:00
|
|
|
source_val: Dynamic,
|
|
|
|
) -> Result<Dynamic, EvalAltResult> {
|
2020-02-29 10:10:51 +01:00
|
|
|
match dot_lhs {
|
|
|
|
Expr::Identifier(id) => {
|
2020-02-25 08:02:27 +01:00
|
|
|
let (sc_idx, mut target) = Self::search_scope(scope, id, |x| Ok(x.into_dynamic()))?;
|
2017-12-20 21:52:26 +01:00
|
|
|
let value = self.set_dot_val_helper(target.as_mut(), dot_rhs, source_val);
|
2016-03-07 21:39:02 +01:00
|
|
|
|
2017-12-20 17:37:12 +01:00
|
|
|
// In case the expression mutated `target`, we need to reassign it because
|
|
|
|
// of the above `clone`.
|
|
|
|
scope[sc_idx].1 = target;
|
2016-03-07 21:39:02 +01:00
|
|
|
|
2017-12-20 17:37:12 +01:00
|
|
|
value
|
2016-03-07 21:39:02 +01:00
|
|
|
}
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-02-29 10:10:51 +01:00
|
|
|
Expr::Index(id, idx_raw) => {
|
2020-03-01 06:30:22 +01:00
|
|
|
let (is_array, sc_idx, idx, mut target) = self.indexed_value(scope, id, idx_raw)?;
|
2017-12-20 21:52:26 +01:00
|
|
|
let value = self.set_dot_val_helper(target.as_mut(), dot_rhs, source_val);
|
2016-04-14 03:01:08 +02:00
|
|
|
|
2017-12-20 17:37:12 +01:00
|
|
|
// In case the expression mutated `target`, we need to reassign it because
|
|
|
|
// of the above `clone`.
|
2020-03-01 06:30:22 +01:00
|
|
|
if is_array {
|
|
|
|
scope[sc_idx].1.downcast_mut::<Array>().unwrap()[idx] = target;
|
|
|
|
} else {
|
2020-03-01 17:11:00 +01:00
|
|
|
Self::str_replace_char(
|
|
|
|
scope[sc_idx].1.downcast_mut::<String>().unwrap(), // Root is a string
|
|
|
|
idx,
|
|
|
|
*target.downcast::<char>().unwrap(), // Target should be a char
|
|
|
|
);
|
2020-03-01 06:30:22 +01:00
|
|
|
}
|
2016-03-26 21:32:20 +01:00
|
|
|
|
2017-12-20 17:37:12 +01:00
|
|
|
value
|
2016-03-26 21:32:20 +01:00
|
|
|
}
|
2020-03-01 06:30:22 +01:00
|
|
|
_ => Err(EvalAltResult::ErrorDotExpr),
|
2016-03-07 21:39:02 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-25 08:02:27 +01:00
|
|
|
fn eval_expr(&self, scope: &mut Scope, expr: &Expr) -> Result<Dynamic, EvalAltResult> {
|
2020-02-29 10:10:51 +01:00
|
|
|
match expr {
|
|
|
|
Expr::IntegerConstant(i) => Ok(Box::new(*i)),
|
|
|
|
Expr::FloatConstant(i) => Ok(Box::new(*i)),
|
|
|
|
Expr::StringConstant(s) => Ok(Box::new(s.clone())),
|
|
|
|
Expr::CharConstant(c) => Ok(Box::new(*c)),
|
2020-03-01 17:11:00 +01:00
|
|
|
|
|
|
|
Expr::Identifier(id) => scope
|
|
|
|
.iter()
|
|
|
|
.rev()
|
|
|
|
.filter(|(name, _)| id == name)
|
|
|
|
.next()
|
|
|
|
.map(|(_, val)| val.clone())
|
|
|
|
.ok_or_else(|| EvalAltResult::ErrorVariableNotFound(id.clone())),
|
|
|
|
|
2020-03-01 06:30:22 +01:00
|
|
|
Expr::Index(id, idx_raw) => {
|
|
|
|
self.indexed_value(scope, id, idx_raw).map(|(_, _, _, x)| x)
|
|
|
|
}
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-02-29 10:10:51 +01:00
|
|
|
Expr::Assignment(ref id, rhs) => {
|
2017-10-02 23:51:04 +02:00
|
|
|
let rhs_val = self.eval_expr(scope, rhs)?;
|
2016-03-26 18:46:28 +01:00
|
|
|
|
2016-02-29 22:43:45 +01:00
|
|
|
match **id {
|
2020-03-01 17:11:00 +01:00
|
|
|
Expr::Identifier(ref n) => scope
|
|
|
|
.iter_mut()
|
|
|
|
.rev()
|
|
|
|
.filter(|(name, _)| n == name)
|
|
|
|
.next()
|
|
|
|
.map(|(_, val)| {
|
|
|
|
*val = rhs_val;
|
|
|
|
Box::new(()) as Dynamic
|
|
|
|
})
|
|
|
|
.ok_or_else(|| EvalAltResult::ErrorVariableNotFound(n.clone())),
|
|
|
|
|
2016-03-26 18:46:28 +01:00
|
|
|
Expr::Index(ref id, ref idx_raw) => {
|
2020-03-01 06:30:22 +01:00
|
|
|
let idx = *match self.eval_expr(scope, &idx_raw)?.downcast_ref::<i64>() {
|
|
|
|
Some(x) => x,
|
|
|
|
_ => return Err(EvalAltResult::ErrorIndexExpr),
|
|
|
|
};
|
|
|
|
|
|
|
|
let variable = &mut scope
|
|
|
|
.iter_mut()
|
|
|
|
.rev()
|
|
|
|
.filter(|(name, _)| id == name)
|
|
|
|
.map(|(_, val)| val)
|
|
|
|
.next();
|
|
|
|
|
|
|
|
let val = match variable {
|
|
|
|
Some(v) => v,
|
|
|
|
_ => return Err(EvalAltResult::ErrorVariableNotFound(id.clone())),
|
|
|
|
};
|
|
|
|
|
|
|
|
if let Some(arr) = val.downcast_mut() as Option<&mut Array> {
|
2020-03-01 17:11:00 +01:00
|
|
|
if idx < 0 {
|
2020-03-01 06:30:22 +01:00
|
|
|
Err(EvalAltResult::ErrorArrayBounds(arr.len(), idx))
|
|
|
|
} else if idx as usize >= arr.len() {
|
|
|
|
Err(EvalAltResult::ErrorArrayBounds(arr.len(), idx))
|
|
|
|
} else {
|
|
|
|
arr[idx as usize] = rhs_val;
|
|
|
|
Ok(Box::new(()))
|
2020-03-01 17:11:00 +01:00
|
|
|
}
|
|
|
|
} else if let Some(s) = val.downcast_mut() as Option<&mut String> {
|
2020-03-01 06:30:22 +01:00
|
|
|
let s_len = s.chars().count();
|
|
|
|
|
2020-03-01 17:11:00 +01:00
|
|
|
if idx < 0 {
|
2020-03-01 06:30:22 +01:00
|
|
|
Err(EvalAltResult::ErrorStringBounds(s_len, idx))
|
|
|
|
} else if idx as usize >= s_len {
|
|
|
|
Err(EvalAltResult::ErrorStringBounds(s_len, idx))
|
|
|
|
} else {
|
2020-03-01 17:11:00 +01:00
|
|
|
Self::str_replace_char(
|
|
|
|
s,
|
|
|
|
idx as usize,
|
|
|
|
*rhs_val.downcast::<char>().unwrap(),
|
|
|
|
);
|
2020-03-01 06:30:22 +01:00
|
|
|
Ok(Box::new(()))
|
2020-03-01 17:11:00 +01:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
Err(EvalAltResult::ErrorIndexExpr)
|
2020-03-01 06:30:22 +01:00
|
|
|
}
|
2016-03-26 18:46:28 +01:00
|
|
|
}
|
2020-03-02 05:08:03 +01:00
|
|
|
|
2016-03-26 18:46:28 +01:00
|
|
|
Expr::Dot(ref dot_lhs, ref dot_rhs) => {
|
2016-03-07 21:39:02 +01:00
|
|
|
self.set_dot_val(scope, dot_lhs, dot_rhs, rhs_val)
|
|
|
|
}
|
2020-03-02 05:08:03 +01:00
|
|
|
|
2016-04-17 04:32:18 +02:00
|
|
|
_ => Err(EvalAltResult::ErrorAssignmentToUnknownLHS),
|
2016-02-29 22:43:45 +01:00
|
|
|
}
|
|
|
|
}
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-02-29 10:10:51 +01:00
|
|
|
Expr::Dot(lhs, rhs) => self.get_dot_val(scope, lhs, rhs),
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-02-29 10:10:51 +01:00
|
|
|
Expr::Array(contents) => {
|
2016-03-26 18:46:28 +01:00
|
|
|
let mut arr = Vec::new();
|
|
|
|
|
2020-03-01 06:30:22 +01:00
|
|
|
contents.iter().try_for_each(|item| {
|
2017-10-02 23:51:04 +02:00
|
|
|
let arg = self.eval_expr(scope, item)?;
|
2016-03-26 18:46:28 +01:00
|
|
|
arr.push(arg);
|
2020-03-01 06:30:22 +01:00
|
|
|
Ok(())
|
|
|
|
})?;
|
2016-03-26 18:46:28 +01:00
|
|
|
|
|
|
|
Ok(Box::new(arr))
|
|
|
|
}
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-03-02 07:28:42 +01:00
|
|
|
Expr::FunctionCall(fn_name, args, def_value) => self.call_fn_raw(
|
|
|
|
fn_name.into(),
|
2017-12-20 12:16:14 +01:00
|
|
|
args.iter()
|
2020-03-02 05:08:03 +01:00
|
|
|
.map(|expr| self.eval_expr(scope, expr))
|
2020-02-23 15:48:46 +01:00
|
|
|
.collect::<Result<Array, _>>()?
|
2017-12-20 12:16:14 +01:00
|
|
|
.iter_mut()
|
2017-12-20 21:52:26 +01:00
|
|
|
.map(|b| b.as_mut())
|
2017-12-20 12:16:14 +01:00
|
|
|
.collect(),
|
2020-03-02 07:28:42 +01:00
|
|
|
def_value.as_ref(),
|
2017-12-20 12:16:14 +01:00
|
|
|
),
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-03-02 05:08:03 +01:00
|
|
|
Expr::And(lhs, rhs) => Ok(Box::new(
|
|
|
|
*self
|
|
|
|
.eval_expr(scope, &*lhs)?
|
|
|
|
.downcast::<bool>()
|
|
|
|
.map_err(|_| EvalAltResult::ErrorBooleanArgMismatch("AND".into()))?
|
|
|
|
&& *self
|
|
|
|
.eval_expr(scope, &*rhs)?
|
|
|
|
.downcast::<bool>()
|
|
|
|
.map_err(|_| EvalAltResult::ErrorBooleanArgMismatch("AND".into()))?,
|
|
|
|
)),
|
|
|
|
|
|
|
|
Expr::Or(lhs, rhs) => Ok(Box::new(
|
|
|
|
*self
|
|
|
|
.eval_expr(scope, &*lhs)?
|
|
|
|
.downcast::<bool>()
|
|
|
|
.map_err(|_| EvalAltResult::ErrorBooleanArgMismatch("OR".into()))?
|
|
|
|
|| *self
|
|
|
|
.eval_expr(scope, &*rhs)?
|
|
|
|
.downcast::<bool>()
|
|
|
|
.map_err(|_| EvalAltResult::ErrorBooleanArgMismatch("OR".into()))?,
|
|
|
|
)),
|
|
|
|
|
2016-04-17 04:32:18 +02:00
|
|
|
Expr::True => Ok(Box::new(true)),
|
|
|
|
Expr::False => Ok(Box::new(false)),
|
2018-05-23 01:44:41 +02:00
|
|
|
Expr::Unit => Ok(Box::new(())),
|
2016-02-29 22:43:45 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-02 07:28:42 +01:00
|
|
|
pub(crate) fn eval_stmt(
|
|
|
|
&self,
|
|
|
|
scope: &mut Scope,
|
|
|
|
stmt: &Stmt,
|
|
|
|
) -> Result<Dynamic, EvalAltResult> {
|
2020-02-29 10:10:51 +01:00
|
|
|
match stmt {
|
2020-03-01 06:30:22 +01:00
|
|
|
Stmt::Expr(expr) => self.eval_expr(scope, expr),
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-03-01 06:30:22 +01:00
|
|
|
Stmt::Block(block) => {
|
2016-03-02 02:45:02 +01:00
|
|
|
let prev_len = scope.len();
|
2020-02-25 08:02:27 +01:00
|
|
|
let mut last_result: Result<Dynamic, EvalAltResult> = Ok(Box::new(()));
|
2016-02-29 22:43:45 +01:00
|
|
|
|
2020-03-01 06:30:22 +01:00
|
|
|
for block_stmt in block.iter() {
|
|
|
|
last_result = self.eval_stmt(scope, block_stmt);
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2017-10-02 23:44:45 +02:00
|
|
|
if let Err(x) = last_result {
|
|
|
|
last_result = Err(x);
|
|
|
|
break;
|
2016-03-03 15:31:42 +01:00
|
|
|
}
|
2016-02-29 22:43:45 +01:00
|
|
|
}
|
|
|
|
|
2016-03-02 02:45:02 +01:00
|
|
|
while scope.len() > prev_len {
|
|
|
|
scope.pop();
|
2016-02-29 22:43:45 +01:00
|
|
|
}
|
|
|
|
|
2017-10-02 23:44:45 +02:00
|
|
|
last_result
|
2016-02-29 22:43:45 +01:00
|
|
|
}
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-03-01 06:30:22 +01:00
|
|
|
Stmt::If(guard, body) => self
|
|
|
|
.eval_expr(scope, guard)?
|
|
|
|
.downcast::<bool>()
|
|
|
|
.map_err(|_| EvalAltResult::ErrorIfGuard)
|
|
|
|
.and_then(|guard_val| {
|
|
|
|
if *guard_val {
|
|
|
|
self.eval_stmt(scope, body)
|
|
|
|
} else {
|
|
|
|
Ok(Box::new(()))
|
2016-02-29 22:43:45 +01:00
|
|
|
}
|
2020-03-01 06:30:22 +01:00
|
|
|
}),
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-03-01 06:30:22 +01:00
|
|
|
Stmt::IfElse(guard, body, else_body) => self
|
|
|
|
.eval_expr(scope, guard)?
|
|
|
|
.downcast::<bool>()
|
|
|
|
.map_err(|_| EvalAltResult::ErrorIfGuard)
|
|
|
|
.and_then(|guard_val| {
|
|
|
|
if *guard_val {
|
|
|
|
self.eval_stmt(scope, body)
|
|
|
|
} else {
|
|
|
|
self.eval_stmt(scope, else_body)
|
2016-03-03 14:20:55 +01:00
|
|
|
}
|
2020-03-01 06:30:22 +01:00
|
|
|
}),
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-02-29 10:10:51 +01:00
|
|
|
Stmt::While(guard, body) => loop {
|
2020-03-01 06:30:22 +01:00
|
|
|
match self.eval_expr(scope, guard)?.downcast::<bool>() {
|
|
|
|
Ok(guard_val) => {
|
|
|
|
if *guard_val {
|
2017-12-20 12:16:14 +01:00
|
|
|
match self.eval_stmt(scope, body) {
|
2017-12-21 12:28:59 +01:00
|
|
|
Err(EvalAltResult::LoopBreak) => return Ok(Box::new(())),
|
|
|
|
Err(x) => return Err(x),
|
2017-12-20 12:16:14 +01:00
|
|
|
_ => (),
|
2016-02-29 22:43:45 +01:00
|
|
|
}
|
2017-12-20 12:16:14 +01:00
|
|
|
} else {
|
|
|
|
return Ok(Box::new(()));
|
2016-02-29 22:43:45 +01:00
|
|
|
}
|
2016-04-14 03:01:08 +02:00
|
|
|
}
|
2020-03-01 06:30:22 +01:00
|
|
|
Err(_) => return Err(EvalAltResult::ErrorIfGuard),
|
2016-02-29 22:43:45 +01:00
|
|
|
}
|
2017-12-20 12:16:14 +01:00
|
|
|
},
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-02-29 10:10:51 +01:00
|
|
|
Stmt::Loop(body) => loop {
|
2017-12-20 12:16:14 +01:00
|
|
|
match self.eval_stmt(scope, body) {
|
2017-12-21 12:28:59 +01:00
|
|
|
Err(EvalAltResult::LoopBreak) => return Ok(Box::new(())),
|
|
|
|
Err(x) => return Err(x),
|
2017-12-20 12:16:14 +01:00
|
|
|
_ => (),
|
2017-10-30 16:08:44 +01:00
|
|
|
}
|
2017-12-20 12:16:14 +01:00
|
|
|
},
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-02-29 10:10:51 +01:00
|
|
|
Stmt::For(name, expr, body) => {
|
2020-02-23 15:48:46 +01:00
|
|
|
let arr = self.eval_expr(scope, expr)?;
|
|
|
|
let tid = Any::type_id(&*arr);
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-02-23 15:48:46 +01:00
|
|
|
if let Some(iter_fn) = self.type_iterators.get(&tid) {
|
|
|
|
scope.push((name.clone(), Box::new(())));
|
|
|
|
let idx = scope.len() - 1;
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-02-23 15:48:46 +01:00
|
|
|
for a in iter_fn(&arr) {
|
|
|
|
scope[idx].1 = a;
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-02-23 15:48:46 +01:00
|
|
|
match self.eval_stmt(scope, body) {
|
|
|
|
Err(EvalAltResult::LoopBreak) => break,
|
|
|
|
Err(x) => return Err(x),
|
|
|
|
_ => (),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
scope.remove(idx);
|
|
|
|
Ok(Box::new(()))
|
|
|
|
} else {
|
2020-03-01 06:30:22 +01:00
|
|
|
return Err(EvalAltResult::ErrorFor);
|
2020-02-23 15:48:46 +01:00
|
|
|
}
|
|
|
|
}
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2017-10-02 23:44:45 +02:00
|
|
|
Stmt::Break => Err(EvalAltResult::LoopBreak),
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2017-10-02 23:44:45 +02:00
|
|
|
Stmt::Return => Err(EvalAltResult::Return(Box::new(()))),
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-02-29 10:10:51 +01:00
|
|
|
Stmt::ReturnWithVal(a) => {
|
2017-10-02 23:51:04 +02:00
|
|
|
let result = self.eval_expr(scope, a)?;
|
2017-10-02 23:44:45 +02:00
|
|
|
Err(EvalAltResult::Return(result))
|
2016-03-03 15:31:42 +01:00
|
|
|
}
|
2020-03-01 17:11:00 +01:00
|
|
|
|
2020-02-29 10:10:51 +01:00
|
|
|
Stmt::Let(name, init) => {
|
2020-03-01 06:30:22 +01:00
|
|
|
if let Some(v) = init {
|
|
|
|
let i = self.eval_expr(scope, v)?;
|
|
|
|
scope.push((name.clone(), i));
|
|
|
|
} else {
|
|
|
|
scope.push((name.clone(), Box::new(())));
|
|
|
|
}
|
2016-02-29 22:43:45 +01:00
|
|
|
Ok(Box::new(()))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-30 16:08:44 +01:00
|
|
|
/// Make a new engine
|
2016-02-29 22:43:45 +01:00
|
|
|
pub fn new() -> Engine {
|
2017-12-20 12:16:14 +01:00
|
|
|
let mut engine = Engine {
|
2019-09-30 19:58:01 +02:00
|
|
|
fns: HashMap::new(),
|
2020-03-02 07:28:42 +01:00
|
|
|
script_fns: HashMap::new(),
|
2020-02-23 15:48:46 +01:00
|
|
|
type_iterators: HashMap::new(),
|
2020-02-25 03:40:48 +01:00
|
|
|
on_print: Box::new(|x: &str| println!("{}", x)),
|
|
|
|
on_debug: Box::new(|x: &str| println!("{}", x)),
|
2017-12-20 12:16:14 +01:00
|
|
|
};
|
2016-03-01 15:40:48 +01:00
|
|
|
|
2020-03-01 10:37:47 +01:00
|
|
|
engine.register_builtins();
|
2016-03-01 15:40:48 +01:00
|
|
|
|
|
|
|
engine
|
|
|
|
}
|
|
|
|
}
|