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

Refactoring a bit of the string/char parser code. Fmt'd

Browse Source
This commit is contained in:
jonathandturner 2016-04-16 19:32:18 -07:00
parent 02e67963e7
commit 7a46c7d9bc
4 changed files with 1357 additions and 861 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "rhai"
version = "0.3.0"
version = "0.3.1"
authors = ["Jonathan Turner"]
description = "Embedded scripting for Rust"
homepage = "https://github.com/jonathandturner/rhai"

1002
src/engine.rs
View File

File diff suppressed because it is too large Load Diff

418
src/fn_register.rs
View File

@ -8,31 +8,49 @@ pub trait FnRegister<A, RetVal, Args> {
}
impl<'a, A, T, U, V, W, X, Y, Z> FnRegister<A, Z, (&'a mut T, U, V, W, X, Y)> for Engine
where A: 'static+Fn(&mut T, U, V, W, X, Y) -> Z, T: Any, U: Clone+Any, V: Clone+Any, W: Clone+Any,
X: Clone+Any, Y: Clone+Any, Z: Any
where A: 'static + Fn(&mut T, U, V, W, X, Y) -> Z,
T: Any,
U: Clone + Any,
V: Clone + Any,
W: Clone + Any,
X: Clone + Any,
Y: Clone + Any,
Z: Any
{
fn register_fn(&mut self, name: &str, fun: A) {
let wrapped : Box<Fn(&mut Box<Any>, &mut Box<Any>, &mut Box<Any>, &mut Box<Any>, &mut Box<Any>,
&mut Box<Any>)->Result<Box<Any>, EvalAltResult>> =
let wrapped: Box<Fn(&mut Box<Any>,
&mut Box<Any>,
&mut Box<Any>,
&mut Box<Any>,
&mut Box<Any>,
&mut Box<Any>)
-> Result<Box<Any>, EvalAltResult>> =
Box::new(move |arg1: &mut Box<Any>,
arg2: &mut Box<Any>,
arg3: &mut Box<Any>,
arg4: &mut Box<Any>,
arg5: &mut Box<Any>,
arg6: &mut Box<Any>| {
Box::new(
move |arg1: &mut Box<Any>, arg2: &mut Box<Any>, arg3: &mut Box<Any>, arg4: &mut Box<Any>,
arg5: &mut Box<Any>, arg6: &mut Box<Any>| {
let inside1 = (*arg1).downcast_mut() as Option<&mut T>;
let inside2 = (*arg2).downcast_mut() as Option<&mut U>;
let inside3 = (*arg3).downcast_mut() as Option<&mut V>;
let inside4 = (*arg4).downcast_mut() as Option<&mut W>;
let inside5 = (*arg5).downcast_mut() as Option<&mut X>;
let inside6 = (*arg6).downcast_mut() as Option<&mut Y>;
let inside1 = (*arg1).downcast_mut() as Option<&mut T>;
let inside2 = (*arg2).downcast_mut() as Option<&mut U>;
let inside3 = (*arg3).downcast_mut() as Option<&mut V>;
let inside4 = (*arg4).downcast_mut() as Option<&mut W>;
let inside5 = (*arg5).downcast_mut() as Option<&mut X>;
let inside6 = (*arg6).downcast_mut() as Option<&mut Y>;
match (inside1, inside2, inside3, inside4, inside5, inside6) {
(Some(b), Some(c), Some(d), Some(e), Some(f), Some(g)) => Ok(Box::new(fun(b, c.clone(), d.clone(),
e.clone(), f.clone(), g.clone())) as Box<Any>),
_ => Err(EvalAltResult::ErrorFunctionArgMismatch)
match (inside1, inside2, inside3, inside4, inside5, inside6) {
(Some(b), Some(c), Some(d), Some(e), Some(f), Some(g)) => {
Ok(Box::new(fun(b,
c.clone(),
d.clone(),
e.clone(),
f.clone(),
g.clone())) as Box<Any>)
}
_ => Err(EvalAltResult::ErrorFunctionArgMismatch),
}
);
});
let ent = self.fns.entry(name.to_string()).or_insert(Vec::new());
(*ent).push(FnType::ExternalFn6(wrapped));
@ -40,31 +58,49 @@ impl<'a, A, T, U, V, W, X, Y, Z> FnRegister<A, Z, (&'a mut T, U, V, W, X, Y)> fo
}
impl<'a, A, T, U, V, W, X, Y, Z> FnRegister<A, Z, (&'a T, U, V, W, X, Y)> for Engine
where A: 'static+Fn(T, U, V, W, X, Y) -> Z, T: Clone+Any, U: Clone+Any, V: Clone+Any, W: Clone+Any,
X: Clone+Any, Y: Clone+Any, Z: Any
where A: 'static + Fn(T, U, V, W, X, Y) -> Z,
T: Clone + Any,
U: Clone + Any,
V: Clone + Any,
W: Clone + Any,
X: Clone + Any,
Y: Clone + Any,
Z: Any
{
fn register_fn(&mut self, name: &str, fun: A) {
let wrapped : Box<Fn(&mut Box<Any>, &mut Box<Any>, &mut Box<Any>, &mut Box<Any>, &mut Box<Any>,
&mut Box<Any>)->Result<Box<Any>, EvalAltResult>> =
let wrapped: Box<Fn(&mut Box<Any>,
&mut Box<Any>,
&mut Box<Any>,
&mut Box<Any>,
&mut Box<Any>,
&mut Box<Any>)
-> Result<Box<Any>, EvalAltResult>> =
Box::new(move |arg1: &mut Box<Any>,
arg2: &mut Box<Any>,
arg3: &mut Box<Any>,
arg4: &mut Box<Any>,
arg5: &mut Box<Any>,
arg6: &mut Box<Any>| {
Box::new(
move |arg1: &mut Box<Any>, arg2: &mut Box<Any>, arg3: &mut Box<Any>, arg4: &mut Box<Any>,
arg5: &mut Box<Any>, arg6: &mut Box<Any>| {
let inside1 = (*arg1).downcast_mut() as Option<&mut T>;
let inside2 = (*arg2).downcast_mut() as Option<&mut U>;
let inside3 = (*arg3).downcast_mut() as Option<&mut V>;
let inside4 = (*arg4).downcast_mut() as Option<&mut W>;
let inside5 = (*arg5).downcast_mut() as Option<&mut X>;
let inside6 = (*arg6).downcast_mut() as Option<&mut Y>;
let inside1 = (*arg1).downcast_mut() as Option<&mut T>;
let inside2 = (*arg2).downcast_mut() as Option<&mut U>;
let inside3 = (*arg3).downcast_mut() as Option<&mut V>;
let inside4 = (*arg4).downcast_mut() as Option<&mut W>;
let inside5 = (*arg5).downcast_mut() as Option<&mut X>;
let inside6 = (*arg6).downcast_mut() as Option<&mut Y>;
match (inside1, inside2, inside3, inside4, inside5, inside6) {
(Some(b), Some(c), Some(d), Some(e), Some(f), Some(g)) => Ok(Box::new(fun(b.clone(), c.clone(), d.clone(),
e.clone(), f.clone(), g.clone())) as Box<Any>),
_ => Err(EvalAltResult::ErrorFunctionArgMismatch)
match (inside1, inside2, inside3, inside4, inside5, inside6) {
(Some(b), Some(c), Some(d), Some(e), Some(f), Some(g)) => {
Ok(Box::new(fun(b.clone(),
c.clone(),
d.clone(),
e.clone(),
f.clone(),
g.clone())) as Box<Any>)
}
_ => Err(EvalAltResult::ErrorFunctionArgMismatch),
}
);
});
let ent = self.fns.entry(name.to_string()).or_insert(Vec::new());
(*ent).push(FnType::ExternalFn6(wrapped));
@ -72,27 +108,40 @@ impl<'a, A, T, U, V, W, X, Y, Z> FnRegister<A, Z, (&'a T, U, V, W, X, Y)> for En
}
impl<'a, A, T, U, V, W, X, Y> FnRegister<A, Y, (&'a mut T, U, V, W, X)> for Engine
where A: 'static+Fn(&mut T, U, V, W, X) -> Y, T: Any, U: Clone+Any, V: Clone+Any, W: Clone+Any, X: Clone+Any, Y: Any
where A: 'static + Fn(&mut T, U, V, W, X) -> Y,
T: Any,
U: Clone + Any,
V: Clone + Any,
W: Clone + Any,
X: Clone + Any,
Y: Any
{
fn register_fn(&mut self, name: &str, fun: A) {
let wrapped : Box<Fn(&mut Box<Any>, &mut Box<Any>, &mut Box<Any>, &mut Box<Any>, &mut Box<Any>)->Result<Box<Any>, EvalAltResult>> =
Box::new(
move |arg1: &mut Box<Any>, arg2: &mut Box<Any>, arg3: &mut Box<Any>, arg4: &mut Box<Any>,
arg5: &mut Box<Any>| {
let wrapped: Box<Fn(&mut Box<Any>,
&mut Box<Any>,
&mut Box<Any>,
&mut Box<Any>,
&mut Box<Any>)
-> Result<Box<Any>, EvalAltResult>> =
Box::new(move |arg1: &mut Box<Any>,
arg2: &mut Box<Any>,
arg3: &mut Box<Any>,
arg4: &mut Box<Any>,
arg5: &mut Box<Any>| {
let inside1 = (*arg1).downcast_mut() as Option<&mut T>;
let inside2 = (*arg2).downcast_mut() as Option<&mut U>;
let inside3 = (*arg3).downcast_mut() as Option<&mut V>;
let inside4 = (*arg4).downcast_mut() as Option<&mut W>;
let inside5 = (*arg5).downcast_mut() as Option<&mut X>;
let inside1 = (*arg1).downcast_mut() as Option<&mut T>;
let inside2 = (*arg2).downcast_mut() as Option<&mut U>;
let inside3 = (*arg3).downcast_mut() as Option<&mut V>;
let inside4 = (*arg4).downcast_mut() as Option<&mut W>;
let inside5 = (*arg5).downcast_mut() as Option<&mut X>;
match (inside1, inside2, inside3, inside4, inside5) {
(Some(b), Some(c), Some(d), Some(e), Some(f)) => Ok(Box::new(fun(b, c.clone(), d.clone(),
e.clone(), f.clone())) as Box<Any>),
_ => Err(EvalAltResult::ErrorFunctionArgMismatch)
match (inside1, inside2, inside3, inside4, inside5) {
(Some(b), Some(c), Some(d), Some(e), Some(f)) => {
Ok(Box::new(fun(b, c.clone(), d.clone(), e.clone(), f.clone())) as Box<Any>)
}
_ => Err(EvalAltResult::ErrorFunctionArgMismatch),
}
);
});
let ent = self.fns.entry(name.to_string()).or_insert(Vec::new());
(*ent).push(FnType::ExternalFn5(wrapped));
@ -100,27 +149,44 @@ impl<'a, A, T, U, V, W, X, Y> FnRegister<A, Y, (&'a mut T, U, V, W, X)> for Engi
}
impl<'a, A, T, U, V, W, X, Y> FnRegister<A, Y, (&'a T, U, V, W, X)> for Engine
where A: 'static+Fn(T, U, V, W, X) -> Y, T: Clone+Any, U: Clone+Any, V: Clone+Any, W: Clone+Any, X: Clone+Any, Y: Any
where A: 'static + Fn(T, U, V, W, X) -> Y,
T: Clone + Any,
U: Clone + Any,
V: Clone + Any,
W: Clone + Any,
X: Clone + Any,
Y: Any
{
fn register_fn(&mut self, name: &str, fun: A) {
let wrapped : Box<Fn(&mut Box<Any>, &mut Box<Any>, &mut Box<Any>, &mut Box<Any>, &mut Box<Any>)->Result<Box<Any>, EvalAltResult>> =
Box::new(
move |arg1: &mut Box<Any>, arg2: &mut Box<Any>, arg3: &mut Box<Any>, arg4: &mut Box<Any>,
arg5: &mut Box<Any>| {
let wrapped: Box<Fn(&mut Box<Any>,
&mut Box<Any>,
&mut Box<Any>,
&mut Box<Any>,
&mut Box<Any>)
-> Result<Box<Any>, EvalAltResult>> =
Box::new(move |arg1: &mut Box<Any>,
arg2: &mut Box<Any>,
arg3: &mut Box<Any>,
arg4: &mut Box<Any>,
arg5: &mut Box<Any>| {
let inside1 = (*arg1).downcast_mut() as Option<&mut T>;
let inside2 = (*arg2).downcast_mut() as Option<&mut U>;
let inside3 = (*arg3).downcast_mut() as Option<&mut V>;
let inside4 = (*arg4).downcast_mut() as Option<&mut W>;
let inside5 = (*arg5).downcast_mut() as Option<&mut X>;
let inside1 = (*arg1).downcast_mut() as Option<&mut T>;
let inside2 = (*arg2).downcast_mut() as Option<&mut U>;
let inside3 = (*arg3).downcast_mut() as Option<&mut V>;
let inside4 = (*arg4).downcast_mut() as Option<&mut W>;
let inside5 = (*arg5).downcast_mut() as Option<&mut X>;
match (inside1, inside2, inside3, inside4, inside5) {
(Some(b), Some(c), Some(d), Some(e), Some(f)) => Ok(Box::new(fun(b.clone(), c.clone(), d.clone(),
e.clone(), f.clone())) as Box<Any>),
_ => Err(EvalAltResult::ErrorFunctionArgMismatch)
match (inside1, inside2, inside3, inside4, inside5) {
(Some(b), Some(c), Some(d), Some(e), Some(f)) => {
Ok(Box::new(fun(b.clone(),
c.clone(),
d.clone(),
e.clone(),
f.clone())) as Box<Any>)
}
_ => Err(EvalAltResult::ErrorFunctionArgMismatch),
}
);
});
let ent = self.fns.entry(name.to_string()).or_insert(Vec::new());
(*ent).push(FnType::ExternalFn5(wrapped));
@ -128,23 +194,32 @@ impl<'a, A, T, U, V, W, X, Y> FnRegister<A, Y, (&'a T, U, V, W, X)> for Engine
}
impl<'a, A, T, U, V, W, X> FnRegister<A, X, (&'a mut T, U, V, W)> for Engine
where A: 'static+Fn(&mut T, U, V, W) -> X, T: Any, U: Clone+Any, V: Clone+Any, W: Clone+Any, X: Any
where A: 'static + Fn(&mut T, U, V, W) -> X,
T: Any,
U: Clone + Any,
V: Clone + Any,
W: Clone + Any,
X: Any
{
fn register_fn(&mut self, name: &str, fun: A) {
let wrapped : Box<Fn(&mut Box<Any>, &mut Box<Any>, &mut Box<Any>, &mut Box<Any>)->Result<Box<Any>, EvalAltResult>> =
Box::new(
move |arg1: &mut Box<Any>, arg2: &mut Box<Any>, arg3: &mut Box<Any>, arg4: &mut Box<Any>| {
let inside1 = (*arg1).downcast_mut() as Option<&mut T>;
let inside2 = (*arg2).downcast_mut() as Option<&mut U>;
let inside3 = (*arg3).downcast_mut() as Option<&mut V>;
let inside4 = (*arg4).downcast_mut() as Option<&mut W>;
let wrapped: Box<Fn(&mut Box<Any>, &mut Box<Any>, &mut Box<Any>, &mut Box<Any>)
-> Result<Box<Any>, EvalAltResult>> =
Box::new(move |arg1: &mut Box<Any>,
arg2: &mut Box<Any>,
arg3: &mut Box<Any>,
arg4: &mut Box<Any>| {
let inside1 = (*arg1).downcast_mut() as Option<&mut T>;
let inside2 = (*arg2).downcast_mut() as Option<&mut U>;
let inside3 = (*arg3).downcast_mut() as Option<&mut V>;
let inside4 = (*arg4).downcast_mut() as Option<&mut W>;
match (inside1, inside2, inside3, inside4) {
(Some(b), Some(c), Some(d), Some(e)) => Ok(Box::new(fun(b, c.clone(), d.clone(), e.clone())) as Box<Any>),
_ => Err(EvalAltResult::ErrorFunctionArgMismatch)
match (inside1, inside2, inside3, inside4) {
(Some(b), Some(c), Some(d), Some(e)) => {
Ok(Box::new(fun(b, c.clone(), d.clone(), e.clone())) as Box<Any>)
}
_ => Err(EvalAltResult::ErrorFunctionArgMismatch),
}
);
});
let ent = self.fns.entry(name.to_string()).or_insert(Vec::new());
(*ent).push(FnType::ExternalFn4(wrapped));
@ -152,23 +227,32 @@ impl<'a, A, T, U, V, W, X> FnRegister<A, X, (&'a mut T, U, V, W)> for Engine
}
impl<'a, A, T, U, V, W, X> FnRegister<A, X, (&'a T, U, V, W)> for Engine
where A: 'static+Fn(T, U, V, W) -> X, T: Clone+Any, U: Clone+Any, V: Clone+Any, W: Clone+Any, X: Any
where A: 'static + Fn(T, U, V, W) -> X,
T: Clone + Any,
U: Clone + Any,
V: Clone + Any,
W: Clone + Any,
X: Any
{
fn register_fn(&mut self, name: &str, fun: A) {
let wrapped : Box<Fn(&mut Box<Any>, &mut Box<Any>, &mut Box<Any>, &mut Box<Any>)->Result<Box<Any>, EvalAltResult>> =
Box::new(
move |arg1: &mut Box<Any>, arg2: &mut Box<Any>, arg3: &mut Box<Any>, arg4: &mut Box<Any>| {
let inside1 = (*arg1).downcast_mut() as Option<&mut T>;
let inside2 = (*arg2).downcast_mut() as Option<&mut U>;
let inside3 = (*arg3).downcast_mut() as Option<&mut V>;
let inside4 = (*arg4).downcast_mut() as Option<&mut W>;
let wrapped: Box<Fn(&mut Box<Any>, &mut Box<Any>, &mut Box<Any>, &mut Box<Any>)
-> Result<Box<Any>, EvalAltResult>> =
Box::new(move |arg1: &mut Box<Any>,
arg2: &mut Box<Any>,
arg3: &mut Box<Any>,
arg4: &mut Box<Any>| {
let inside1 = (*arg1).downcast_mut() as Option<&mut T>;
let inside2 = (*arg2).downcast_mut() as Option<&mut U>;
let inside3 = (*arg3).downcast_mut() as Option<&mut V>;
let inside4 = (*arg4).downcast_mut() as Option<&mut W>;
match (inside1, inside2, inside3, inside4) {
(Some(b), Some(c), Some(d), Some(e)) => Ok(Box::new(fun(b.clone(), c.clone(), d.clone(), e.clone())) as Box<Any>),
_ => Err(EvalAltResult::ErrorFunctionArgMismatch)
match (inside1, inside2, inside3, inside4) {
(Some(b), Some(c), Some(d), Some(e)) => {
Ok(Box::new(fun(b.clone(), c.clone(), d.clone(), e.clone())) as Box<Any>)
}
_ => Err(EvalAltResult::ErrorFunctionArgMismatch),
}
);
});
let ent = self.fns.entry(name.to_string()).or_insert(Vec::new());
(*ent).push(FnType::ExternalFn4(wrapped));
@ -176,22 +260,27 @@ impl<'a, A, T, U, V, W, X> FnRegister<A, X, (&'a T, U, V, W)> for Engine
}
impl<'a, A, T, U, V, W> FnRegister<A, W, (&'a mut T, U, V)> for Engine
where A: 'static+Fn(&mut T, U, V) -> W, T: Any, U: Clone+Any, V: Clone+Any, W: Any
where A: 'static + Fn(&mut T, U, V) -> W,
T: Any,
U: Clone + Any,
V: Clone + Any,
W: Any
{
fn register_fn(&mut self, name: &str, fun: A) {
let wrapped : Box<Fn(&mut Box<Any>, &mut Box<Any>, &mut Box<Any>)->Result<Box<Any>, EvalAltResult>> =
Box::new(
move |arg1: &mut Box<Any>, arg2: &mut Box<Any>, arg3: &mut Box<Any>| {
let inside1 = (*arg1).downcast_mut() as Option<&mut T>;
let inside2 = (*arg2).downcast_mut() as Option<&mut U>;
let inside3 = (*arg3).downcast_mut() as Option<&mut V>;
let wrapped: Box<Fn(&mut Box<Any>, &mut Box<Any>, &mut Box<Any>)
-> Result<Box<Any>, EvalAltResult>> =
Box::new(move |arg1: &mut Box<Any>, arg2: &mut Box<Any>, arg3: &mut Box<Any>| {
let inside1 = (*arg1).downcast_mut() as Option<&mut T>;
let inside2 = (*arg2).downcast_mut() as Option<&mut U>;
let inside3 = (*arg3).downcast_mut() as Option<&mut V>;
match (inside1, inside2, inside3) {
(Some(b), Some(c), Some(d)) => Ok(Box::new(fun(b, c.clone(), d.clone())) as Box<Any>),
_ => Err(EvalAltResult::ErrorFunctionArgMismatch)
match (inside1, inside2, inside3) {
(Some(b), Some(c), Some(d)) => {
Ok(Box::new(fun(b, c.clone(), d.clone())) as Box<Any>)
}
_ => Err(EvalAltResult::ErrorFunctionArgMismatch),
}
);
});
let ent = self.fns.entry(name.to_string()).or_insert(Vec::new());
(*ent).push(FnType::ExternalFn3(wrapped));
@ -199,22 +288,27 @@ impl<'a, A, T, U, V, W> FnRegister<A, W, (&'a mut T, U, V)> for Engine
}
impl<'a, A, T, U, V, W> FnRegister<A, W, (&'a T, U, V)> for Engine
where A: 'static+Fn(T, U, V) -> W, T: Clone+Any, U: Clone+Any, V: Clone+Any, W: Any
where A: 'static + Fn(T, U, V) -> W,
T: Clone + Any,
U: Clone + Any,
V: Clone + Any,
W: Any
{
fn register_fn(&mut self, name: &str, fun: A) {
let wrapped : Box<Fn(&mut Box<Any>, &mut Box<Any>, &mut Box<Any>)->Result<Box<Any>, EvalAltResult>> =
Box::new(
move |arg1: &mut Box<Any>, arg2: &mut Box<Any>, arg3: &mut Box<Any>| {
let inside1 = (*arg1).downcast_mut() as Option<&mut T>;
let inside2 = (*arg2).downcast_mut() as Option<&mut U>;
let inside3 = (*arg3).downcast_mut() as Option<&mut V>;
let wrapped: Box<Fn(&mut Box<Any>, &mut Box<Any>, &mut Box<Any>)
-> Result<Box<Any>, EvalAltResult>> =
Box::new(move |arg1: &mut Box<Any>, arg2: &mut Box<Any>, arg3: &mut Box<Any>| {
let inside1 = (*arg1).downcast_mut() as Option<&mut T>;
let inside2 = (*arg2).downcast_mut() as Option<&mut U>;
let inside3 = (*arg3).downcast_mut() as Option<&mut V>;
match (inside1, inside2, inside3) {
(Some(b), Some(c), Some(d)) => Ok(Box::new(fun(b.clone(), c.clone(), d.clone())) as Box<Any>),
_ => Err(EvalAltResult::ErrorFunctionArgMismatch)
match (inside1, inside2, inside3) {
(Some(b), Some(c), Some(d)) => {
Ok(Box::new(fun(b.clone(), c.clone(), d.clone())) as Box<Any>)
}
_ => Err(EvalAltResult::ErrorFunctionArgMismatch),
}
);
});
let ent = self.fns.entry(name.to_string()).or_insert(Vec::new());
(*ent).push(FnType::ExternalFn3(wrapped));
@ -222,21 +316,22 @@ impl<'a, A, T, U, V, W> FnRegister<A, W, (&'a T, U, V)> for Engine
}
impl<'a, A, T, U, V> FnRegister<A, V, (&'a mut T, U)> for Engine
where A: 'static+Fn(&mut T, U) -> V, T: Any, U: Clone+Any, V: Any
where A: 'static + Fn(&mut T, U) -> V,
T: Any,
U: Clone + Any,
V: Any
{
fn register_fn(&mut self, name: &str, fun: A) {
let wrapped : Box<Fn(&mut Box<Any>, &mut Box<Any>)->Result<Box<Any>, EvalAltResult>> =
Box::new(
move |arg1: &mut Box<Any>, arg2: &mut Box<Any>| {
let inside1 = (*arg1).downcast_mut() as Option<&mut T>;
let inside2 = (*arg2).downcast_mut() as Option<&mut U>;
let wrapped: Box<Fn(&mut Box<Any>, &mut Box<Any>) -> Result<Box<Any>, EvalAltResult>> =
Box::new(move |arg1: &mut Box<Any>, arg2: &mut Box<Any>| {
let inside1 = (*arg1).downcast_mut() as Option<&mut T>;
let inside2 = (*arg2).downcast_mut() as Option<&mut U>;
match (inside1, inside2) {
(Some(b), Some(c)) => Ok(Box::new(fun(b, c.clone())) as Box<Any>),
_ => Err(EvalAltResult::ErrorFunctionArgMismatch)
}
match (inside1, inside2) {
(Some(b), Some(c)) => Ok(Box::new(fun(b, c.clone())) as Box<Any>),
_ => Err(EvalAltResult::ErrorFunctionArgMismatch),
}
);
});
let ent = self.fns.entry(name.to_string()).or_insert(Vec::new());
(*ent).push(FnType::ExternalFn2(wrapped));
@ -244,21 +339,22 @@ impl<'a, A, T, U, V> FnRegister<A, V, (&'a mut T, U)> for Engine
}
impl<'a, A, T, U, V> FnRegister<A, V, (&'a T, U)> for Engine
where A: 'static+Fn(T, U) -> V, T: Clone+Any, U: Clone+Any, V: Any
where A: 'static + Fn(T, U) -> V,
T: Clone + Any,
U: Clone + Any,
V: Any
{
fn register_fn(&mut self, name: &str, fun: A) {
let wrapped : Box<Fn(&mut Box<Any>, &mut Box<Any>)->Result<Box<Any>, EvalAltResult>> =
Box::new(
move |arg1: &mut Box<Any>, arg2: &mut Box<Any>| {
let inside1 = (*arg1).downcast_mut() as Option<&mut T>;
let inside2 = (*arg2).downcast_mut() as Option<&mut U>;
let wrapped: Box<Fn(&mut Box<Any>, &mut Box<Any>) -> Result<Box<Any>, EvalAltResult>> =
Box::new(move |arg1: &mut Box<Any>, arg2: &mut Box<Any>| {
let inside1 = (*arg1).downcast_mut() as Option<&mut T>;
let inside2 = (*arg2).downcast_mut() as Option<&mut U>;
match (inside1, inside2) {
(Some(b), Some(c)) => Ok(Box::new(fun(b.clone(), c.clone())) as Box<Any>),
_ => Err(EvalAltResult::ErrorFunctionArgMismatch)
}
match (inside1, inside2) {
(Some(b), Some(c)) => Ok(Box::new(fun(b.clone(), c.clone())) as Box<Any>),
_ => Err(EvalAltResult::ErrorFunctionArgMismatch),
}
);
});
let ent = self.fns.entry(name.to_string()).or_insert(Vec::new());
(*ent).push(FnType::ExternalFn2(wrapped));
@ -266,20 +362,20 @@ impl<'a, A, T, U, V> FnRegister<A, V, (&'a T, U)> for Engine
}
impl<'a, A, T, U> FnRegister<A, U, (&'a mut T)> for Engine
where A: 'static+Fn(&mut T) -> U, T: Any, U: Any
where A: 'static + Fn(&mut T) -> U,
T: Any,
U: Any
{
fn register_fn(&mut self, name: &str, fun: A) {
let wrapped : Box<Fn(&mut Box<Any>)->Result<Box<Any>, EvalAltResult>> =
Box::new(
move |arg: &mut Box<Any>| {
let inside = (*arg).downcast_mut() as Option<&mut T>;
let wrapped: Box<Fn(&mut Box<Any>) -> Result<Box<Any>, EvalAltResult>> =
Box::new(move |arg: &mut Box<Any>| {
let inside = (*arg).downcast_mut() as Option<&mut T>;
match inside {
Some(b) => Ok(Box::new(fun(b)) as Box<Any>),
None => Err(EvalAltResult::ErrorFunctionArgMismatch)
}
match inside {
Some(b) => Ok(Box::new(fun(b)) as Box<Any>),
None => Err(EvalAltResult::ErrorFunctionArgMismatch),
}
);
});
let ent = self.fns.entry(name.to_string()).or_insert(Vec::new());
(*ent).push(FnType::ExternalFn1(wrapped));
@ -288,19 +384,19 @@ impl<'a, A, T, U> FnRegister<A, U, (&'a mut T)> for Engine
impl<'a, A, T, U> FnRegister<A, U, (&'a T)> for Engine
where A: 'static+Fn(T) -> U, T: Clone+Any, U: Any
where A: 'static + Fn(T) -> U,
T: Clone + Any,
U: Any
{
fn register_fn(&mut self, name: &str, fun: A) {
let wrapped : Box<Fn(&mut Box<Any>)->Result<Box<Any>, EvalAltResult>> =
Box::new(
move |arg: &mut Box<Any>| {
let inside = (*arg).downcast_mut() as Option<&mut T>;
match inside {
Some(b) => Ok(Box::new(fun(b.clone())) as Box<Any>),
None => Err(EvalAltResult::ErrorFunctionArgMismatch)
}
let wrapped: Box<Fn(&mut Box<Any>) -> Result<Box<Any>, EvalAltResult>> =
Box::new(move |arg: &mut Box<Any>| {
let inside = (*arg).downcast_mut() as Option<&mut T>;
match inside {
Some(b) => Ok(Box::new(fun(b.clone())) as Box<Any>),
None => Err(EvalAltResult::ErrorFunctionArgMismatch),
}
);
});
let ent = self.fns.entry(name.to_string()).or_insert(Vec::new());
(*ent).push(FnType::ExternalFn1(wrapped));
@ -308,13 +404,13 @@ impl<'a, A, T, U> FnRegister<A, U, (&'a T)> for Engine
}
impl<A, T> FnRegister<A, T, ()> for Engine
where A: 'static+Fn() -> T, T: Any
where A: 'static + Fn() -> T,
T: Any
{
fn register_fn(&mut self, name: &str, fun: A) {
let wrapped : Box<Fn()->Result<Box<Any>, EvalAltResult>> =
Box::new(
move || { Ok(Box::new(fun()) as Box<Any>) }
);
let wrapped: Box<Fn() -> Result<Box<Any>, EvalAltResult>> = Box::new(move || {
Ok(Box::new(fun()) as Box<Any>)
});
let ent = self.fns.entry(name.to_string()).or_insert(Vec::new());
(*ent).push(FnType::ExternalFn0(wrapped));

796
src/parser.rs
View File

File diff suppressed because it is too large Load Diff