2020-03-04 15:00:01 +01:00
|
|
|
use crate::any::{Any, AnyExt, Dynamic};
|
|
|
|
use crate::call::FuncArgs;
|
|
|
|
use crate::engine::{Engine, FnAny, FnIntExt, FnSpec};
|
|
|
|
use crate::error::ParseError;
|
|
|
|
use crate::fn_register::RegisterFn;
|
|
|
|
use crate::parser::{lex, parse, Position, AST};
|
|
|
|
use crate::result::EvalAltResult;
|
2020-03-03 08:20:20 +01:00
|
|
|
use crate::scope::Scope;
|
2020-03-04 15:00:01 +01:00
|
|
|
use std::any::TypeId;
|
2020-03-02 07:28:42 +01:00
|
|
|
use std::sync::Arc;
|
|
|
|
|
2020-03-06 17:29:45 +01:00
|
|
|
impl<'e> Engine<'e> {
|
2020-03-04 15:00:01 +01:00
|
|
|
pub(crate) fn register_fn_raw(
|
|
|
|
&mut self,
|
|
|
|
fn_name: &str,
|
|
|
|
args: Option<Vec<TypeId>>,
|
|
|
|
f: Box<FnAny>,
|
|
|
|
) {
|
|
|
|
debug_println!(
|
2020-03-06 08:49:38 +01:00
|
|
|
"Register function: {} for {} parameter(s)",
|
2020-03-04 15:00:01 +01:00
|
|
|
fn_name,
|
2020-03-06 08:49:38 +01:00
|
|
|
if let Some(a) = &args {
|
|
|
|
format!("{}", a.len())
|
|
|
|
} else {
|
|
|
|
"no".to_string()
|
|
|
|
}
|
2020-03-04 15:00:01 +01:00
|
|
|
);
|
|
|
|
|
|
|
|
let spec = FnSpec {
|
|
|
|
name: fn_name.to_string().into(),
|
|
|
|
args,
|
|
|
|
};
|
|
|
|
|
2020-03-04 16:06:05 +01:00
|
|
|
self.external_functions
|
|
|
|
.insert(spec, Arc::new(FnIntExt::Ext(f)));
|
2020-03-04 15:00:01 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Register a custom type for use with the `Engine`.
|
|
|
|
/// The type must be `Clone`.
|
|
|
|
pub fn register_type<T: Any + Clone>(&mut self) {
|
|
|
|
self.register_type_with_name::<T>(std::any::type_name::<T>());
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Register a custom type for use with the `Engine` with a name for the `type_of` function.
|
|
|
|
/// The type must be `Clone`.
|
|
|
|
pub fn register_type_with_name<T: Any + Clone>(&mut self, type_name: &str) {
|
|
|
|
// Add the pretty-print type name into the map
|
|
|
|
self.type_names.insert(
|
|
|
|
std::any::type_name::<T>().to_string(),
|
|
|
|
type_name.to_string(),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Register an iterator adapter for a type with the `Engine`.
|
|
|
|
pub fn register_iterator<T: Any, F>(&mut self, f: F)
|
|
|
|
where
|
|
|
|
F: Fn(&Dynamic) -> Box<dyn Iterator<Item = Dynamic>> + 'static,
|
|
|
|
{
|
|
|
|
self.type_iterators.insert(TypeId::of::<T>(), Arc::new(f));
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Register a getter function for a member of a registered type with the `Engine`.
|
|
|
|
pub fn register_get<T: Any + Clone, U: Any + Clone>(
|
|
|
|
&mut self,
|
|
|
|
name: &str,
|
2020-03-04 16:06:05 +01:00
|
|
|
callback: impl Fn(&mut T) -> U + 'static,
|
2020-03-04 15:00:01 +01:00
|
|
|
) {
|
|
|
|
let get_name = "get$".to_string() + name;
|
2020-03-04 16:06:05 +01:00
|
|
|
self.register_fn(&get_name, callback);
|
2020-03-04 15:00:01 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Register a setter function for a member of a registered type with the `Engine`.
|
|
|
|
pub fn register_set<T: Any + Clone, U: Any + Clone>(
|
|
|
|
&mut self,
|
|
|
|
name: &str,
|
2020-03-04 16:06:05 +01:00
|
|
|
callback: impl Fn(&mut T, U) -> () + 'static,
|
2020-03-04 15:00:01 +01:00
|
|
|
) {
|
|
|
|
let set_name = "set$".to_string() + name;
|
2020-03-04 16:06:05 +01:00
|
|
|
self.register_fn(&set_name, callback);
|
2020-03-04 15:00:01 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Shorthand for registering both getter and setter functions
|
|
|
|
/// of a registered type with the `Engine`.
|
|
|
|
pub fn register_get_set<T: Any + Clone, U: Any + Clone>(
|
|
|
|
&mut self,
|
|
|
|
name: &str,
|
|
|
|
get_fn: impl Fn(&mut T) -> U + 'static,
|
|
|
|
set_fn: impl Fn(&mut T, U) -> () + 'static,
|
|
|
|
) {
|
|
|
|
self.register_get(name, get_fn);
|
|
|
|
self.register_set(name, set_fn);
|
|
|
|
}
|
|
|
|
|
2020-03-02 07:28:42 +01:00
|
|
|
/// Compile a string into an AST
|
|
|
|
pub fn compile(input: &str) -> Result<AST, ParseError> {
|
|
|
|
let tokens = lex(input);
|
2020-03-02 09:29:50 +01:00
|
|
|
parse(&mut tokens.peekable())
|
2020-03-02 07:28:42 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Compile a file into an AST
|
|
|
|
pub fn compile_file(filename: &str) -> Result<AST, EvalAltResult> {
|
|
|
|
use std::fs::File;
|
|
|
|
use std::io::prelude::*;
|
|
|
|
|
|
|
|
let mut f = File::open(filename)
|
2020-03-04 15:00:01 +01:00
|
|
|
.map_err(|err| EvalAltResult::ErrorReadingScriptFile(filename.into(), err))?;
|
2020-03-02 07:28:42 +01:00
|
|
|
|
|
|
|
let mut contents = String::new();
|
|
|
|
|
|
|
|
f.read_to_string(&mut contents)
|
2020-03-04 15:00:01 +01:00
|
|
|
.map_err(|err| EvalAltResult::ErrorReadingScriptFile(filename.into(), err))
|
2020-03-02 07:28:42 +01:00
|
|
|
.and_then(|_| Self::compile(&contents).map_err(EvalAltResult::ErrorParsing))
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Evaluate a file
|
|
|
|
pub fn eval_file<T: Any + Clone>(&mut self, filename: &str) -> Result<T, EvalAltResult> {
|
|
|
|
use std::fs::File;
|
|
|
|
use std::io::prelude::*;
|
|
|
|
|
|
|
|
let mut f = File::open(filename)
|
2020-03-04 15:00:01 +01:00
|
|
|
.map_err(|err| EvalAltResult::ErrorReadingScriptFile(filename.into(), err))?;
|
2020-03-02 07:28:42 +01:00
|
|
|
|
|
|
|
let mut contents = String::new();
|
|
|
|
|
|
|
|
f.read_to_string(&mut contents)
|
2020-03-04 15:00:01 +01:00
|
|
|
.map_err(|err| EvalAltResult::ErrorReadingScriptFile(filename.into(), err))
|
2020-03-02 07:28:42 +01:00
|
|
|
.and_then(|_| self.eval::<T>(&contents))
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Evaluate a string
|
|
|
|
pub fn eval<T: Any + Clone>(&mut self, input: &str) -> Result<T, EvalAltResult> {
|
|
|
|
let mut scope = Scope::new();
|
|
|
|
self.eval_with_scope(&mut scope, input)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Evaluate a string with own scope
|
|
|
|
pub fn eval_with_scope<T: Any + Clone>(
|
|
|
|
&mut self,
|
|
|
|
scope: &mut Scope,
|
|
|
|
input: &str,
|
|
|
|
) -> Result<T, EvalAltResult> {
|
|
|
|
let ast = Self::compile(input).map_err(EvalAltResult::ErrorParsing)?;
|
|
|
|
self.eval_ast_with_scope(scope, &ast)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Evaluate an AST
|
|
|
|
pub fn eval_ast<T: Any + Clone>(&mut self, ast: &AST) -> Result<T, EvalAltResult> {
|
|
|
|
let mut scope = Scope::new();
|
|
|
|
self.eval_ast_with_scope(&mut scope, ast)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Evaluate an AST with own scope
|
|
|
|
pub fn eval_ast_with_scope<T: Any + Clone>(
|
|
|
|
&mut self,
|
|
|
|
scope: &mut Scope,
|
|
|
|
ast: &AST,
|
|
|
|
) -> Result<T, EvalAltResult> {
|
2020-03-04 16:06:05 +01:00
|
|
|
let AST(statements, functions) = ast;
|
2020-03-02 07:28:42 +01:00
|
|
|
|
2020-03-04 16:06:05 +01:00
|
|
|
functions.iter().for_each(|f| {
|
|
|
|
self.script_functions.insert(
|
2020-03-02 10:04:45 +01:00
|
|
|
FnSpec {
|
2020-03-04 15:00:01 +01:00
|
|
|
name: f.name.clone().into(),
|
2020-03-02 10:04:45 +01:00
|
|
|
args: None,
|
|
|
|
},
|
|
|
|
Arc::new(FnIntExt::Int(f.clone())),
|
|
|
|
);
|
|
|
|
});
|
2020-03-02 07:28:42 +01:00
|
|
|
|
2020-03-04 16:06:05 +01:00
|
|
|
let result = statements
|
2020-03-02 07:28:42 +01:00
|
|
|
.iter()
|
2020-03-06 17:29:45 +01:00
|
|
|
.try_fold(().into_dynamic(), |_, stmt| self.eval_stmt(scope, stmt));
|
2020-03-02 07:28:42 +01:00
|
|
|
|
2020-03-04 16:06:05 +01:00
|
|
|
self.script_functions.clear(); // Clean up engine
|
2020-03-02 07:28:42 +01:00
|
|
|
|
|
|
|
match result {
|
2020-03-03 09:24:03 +01:00
|
|
|
Err(EvalAltResult::Return(out, pos)) => out.downcast::<T>().map(|v| *v).map_err(|a| {
|
|
|
|
EvalAltResult::ErrorMismatchOutputType(
|
|
|
|
self.map_type_name((*a).type_name()).to_string(),
|
|
|
|
pos,
|
|
|
|
)
|
|
|
|
}),
|
|
|
|
|
|
|
|
Ok(out) => out.downcast::<T>().map(|v| *v).map_err(|a| {
|
|
|
|
EvalAltResult::ErrorMismatchOutputType(
|
|
|
|
self.map_type_name((*a).type_name()).to_string(),
|
|
|
|
Position::eof(),
|
|
|
|
)
|
|
|
|
}),
|
2020-03-02 15:13:14 +01:00
|
|
|
|
2020-03-02 07:28:42 +01:00
|
|
|
Err(err) => Err(err),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-04 15:00:01 +01:00
|
|
|
/// Evaluate a file, but throw away the result and only return error (if any).
|
2020-03-02 07:28:42 +01:00
|
|
|
/// Useful for when you don't need the result, but still need
|
|
|
|
/// to keep track of possible errors
|
|
|
|
pub fn consume_file(&mut self, filename: &str) -> Result<(), EvalAltResult> {
|
|
|
|
use std::fs::File;
|
|
|
|
use std::io::prelude::*;
|
|
|
|
|
|
|
|
let mut f = File::open(filename)
|
2020-03-04 15:00:01 +01:00
|
|
|
.map_err(|err| EvalAltResult::ErrorReadingScriptFile(filename.into(), err))?;
|
2020-03-02 07:28:42 +01:00
|
|
|
|
|
|
|
let mut contents = String::new();
|
|
|
|
|
|
|
|
f.read_to_string(&mut contents)
|
2020-03-04 15:00:01 +01:00
|
|
|
.map_err(|err| EvalAltResult::ErrorReadingScriptFile(filename.into(), err))
|
2020-03-02 07:28:42 +01:00
|
|
|
.and_then(|_| self.consume(&contents))
|
|
|
|
}
|
|
|
|
|
2020-03-04 15:00:01 +01:00
|
|
|
/// Evaluate a string, but throw away the result and only return error (if any).
|
2020-03-02 07:28:42 +01:00
|
|
|
/// Useful for when you don't need the result, but still need
|
|
|
|
/// to keep track of possible errors
|
|
|
|
pub fn consume(&mut self, input: &str) -> Result<(), EvalAltResult> {
|
|
|
|
self.consume_with_scope(&mut Scope::new(), input)
|
|
|
|
}
|
|
|
|
|
2020-03-04 15:00:01 +01:00
|
|
|
/// Evaluate a string with own scope, but throw away the result and only return error (if any).
|
2020-03-02 07:28:42 +01:00
|
|
|
/// Useful for when you don't need the result, but still need
|
|
|
|
/// to keep track of possible errors
|
|
|
|
pub fn consume_with_scope(
|
|
|
|
&mut self,
|
|
|
|
scope: &mut Scope,
|
|
|
|
input: &str,
|
|
|
|
) -> Result<(), EvalAltResult> {
|
|
|
|
let tokens = lex(input);
|
|
|
|
|
|
|
|
parse(&mut tokens.peekable())
|
|
|
|
.map_err(|err| EvalAltResult::ErrorParsing(err))
|
2020-03-04 16:06:05 +01:00
|
|
|
.and_then(|AST(ref statements, ref functions)| {
|
|
|
|
for f in functions {
|
|
|
|
self.script_functions.insert(
|
2020-03-02 10:04:45 +01:00
|
|
|
FnSpec {
|
2020-03-04 15:00:01 +01:00
|
|
|
name: f.name.clone().into(),
|
2020-03-02 10:04:45 +01:00
|
|
|
args: None,
|
|
|
|
},
|
|
|
|
Arc::new(FnIntExt::Int(f.clone())),
|
|
|
|
);
|
2020-03-02 07:28:42 +01:00
|
|
|
}
|
|
|
|
|
2020-03-04 16:06:05 +01:00
|
|
|
let val = statements
|
2020-03-02 07:28:42 +01:00
|
|
|
.iter()
|
2020-03-03 10:28:38 +01:00
|
|
|
.try_fold(().into_dynamic(), |_, o| self.eval_stmt(scope, o))
|
2020-03-02 07:28:42 +01:00
|
|
|
.map(|_| ());
|
|
|
|
|
2020-03-04 16:06:05 +01:00
|
|
|
self.script_functions.clear(); // Clean up engine
|
2020-03-02 07:28:42 +01:00
|
|
|
|
|
|
|
val
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2020-03-04 15:00:01 +01:00
|
|
|
/// Call a script function defined in a compiled AST.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ```rust
|
|
|
|
/// # use rhai::{Engine, EvalAltResult};
|
|
|
|
/// # fn main() -> Result<(), EvalAltResult> {
|
|
|
|
/// let mut engine = Engine::new();
|
|
|
|
///
|
|
|
|
/// let ast = Engine::compile("fn add(x, y) { x.len() + y }")?;
|
|
|
|
///
|
2020-03-06 17:29:45 +01:00
|
|
|
/// let result: i64 = engine.call_fn("add", &ast, (&mut String::from("abc"), &mut 123_i64))?;
|
2020-03-04 15:00:01 +01:00
|
|
|
///
|
|
|
|
/// assert_eq!(result, 126);
|
|
|
|
/// # Ok(())
|
|
|
|
/// # }
|
|
|
|
/// ```
|
|
|
|
pub fn call_fn<'f, A: FuncArgs<'f>, T: Any + Clone>(
|
|
|
|
&mut self,
|
|
|
|
name: &str,
|
2020-03-06 17:29:45 +01:00
|
|
|
ast: &AST,
|
2020-03-04 15:00:01 +01:00
|
|
|
args: A,
|
|
|
|
) -> Result<T, EvalAltResult> {
|
|
|
|
let pos = Default::default();
|
|
|
|
|
|
|
|
ast.1.iter().for_each(|f| {
|
2020-03-04 16:06:05 +01:00
|
|
|
self.script_functions.insert(
|
2020-03-04 15:00:01 +01:00
|
|
|
FnSpec {
|
|
|
|
name: f.name.clone().into(),
|
|
|
|
args: None,
|
|
|
|
},
|
|
|
|
Arc::new(FnIntExt::Int(f.clone())),
|
|
|
|
);
|
|
|
|
});
|
|
|
|
|
|
|
|
let result = self
|
|
|
|
.call_fn_raw(name, args.into_vec(), None, pos)
|
|
|
|
.and_then(|b| {
|
|
|
|
b.downcast().map(|b| *b).map_err(|a| {
|
|
|
|
EvalAltResult::ErrorMismatchOutputType(
|
|
|
|
self.map_type_name((*a).type_name()).into(),
|
|
|
|
pos,
|
|
|
|
)
|
|
|
|
})
|
|
|
|
});
|
|
|
|
|
2020-03-04 16:06:05 +01:00
|
|
|
self.script_functions.clear(); // Clean up engine
|
2020-03-04 15:00:01 +01:00
|
|
|
|
|
|
|
result
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Override default action of `print` (print to stdout using `println!`)
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ```rust
|
|
|
|
/// # use rhai::Engine;
|
|
|
|
/// let mut result = String::from("");
|
|
|
|
/// {
|
|
|
|
/// let mut engine = Engine::new();
|
|
|
|
///
|
|
|
|
/// // Override action of 'print' function
|
|
|
|
/// engine.on_print(|s| result.push_str(s));
|
|
|
|
/// engine.consume("print(40 + 2);").unwrap();
|
|
|
|
/// }
|
|
|
|
/// assert_eq!(result, "42");
|
|
|
|
/// ```
|
2020-03-06 17:29:45 +01:00
|
|
|
pub fn on_print(&mut self, callback: impl FnMut(&str) + 'e) {
|
2020-03-02 07:28:42 +01:00
|
|
|
self.on_print = Box::new(callback);
|
|
|
|
}
|
|
|
|
|
2020-03-04 15:00:01 +01:00
|
|
|
/// Override default action of `debug` (print to stdout using `println!`)
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ```rust
|
|
|
|
/// # use rhai::Engine;
|
|
|
|
/// let mut result = String::from("");
|
|
|
|
/// {
|
|
|
|
/// let mut engine = Engine::new();
|
|
|
|
///
|
|
|
|
/// // Override action of 'debug' function
|
|
|
|
/// engine.on_debug(|s| result.push_str(s));
|
|
|
|
/// engine.consume(r#"debug("hello");"#).unwrap();
|
|
|
|
/// }
|
|
|
|
/// assert_eq!(result, "\"hello\"");
|
|
|
|
/// ```
|
2020-03-06 17:29:45 +01:00
|
|
|
pub fn on_debug(&mut self, callback: impl FnMut(&str) + 'e) {
|
2020-03-02 07:28:42 +01:00
|
|
|
self.on_debug = Box::new(callback);
|
|
|
|
}
|
|
|
|
}
|