2017-12-20 12:16:14 +01:00
|
|
|
use std::any::TypeId;
|
2016-02-29 22:43:45 +01:00
|
|
|
|
2020-02-25 08:02:27 +01:00
|
|
|
use crate::any::{Any, Dynamic};
|
|
|
|
use crate::engine::{Engine, EvalAltResult, FnCallArgs};
|
2020-03-02 15:13:14 +01:00
|
|
|
use crate::parser::Position;
|
2016-02-29 22:43:45 +01:00
|
|
|
|
2017-12-20 12:16:14 +01:00
|
|
|
pub trait RegisterFn<FN, ARGS, RET> {
|
|
|
|
fn register_fn(&mut self, name: &str, f: FN);
|
2016-02-29 22:43:45 +01:00
|
|
|
}
|
2020-02-28 16:38:39 +01:00
|
|
|
pub trait RegisterDynamicFn<FN, ARGS> {
|
2020-02-25 08:02:27 +01:00
|
|
|
fn register_dynamic_fn(&mut self, name: &str, f: FN);
|
2020-02-23 15:48:46 +01:00
|
|
|
}
|
2016-02-29 22:43:45 +01:00
|
|
|
|
2017-12-20 12:16:14 +01:00
|
|
|
pub struct Ref<A>(A);
|
|
|
|
pub struct Mut<A>(A);
|
2016-04-17 04:32:18 +02:00
|
|
|
|
2017-12-20 12:16:14 +01:00
|
|
|
macro_rules! count_args {
|
|
|
|
() => {0usize};
|
|
|
|
($head:ident $($tail:ident)*) => {1usize + count_args!($($tail)*)};
|
2016-03-02 16:49:24 +01:00
|
|
|
}
|
|
|
|
|
2017-12-20 12:16:14 +01:00
|
|
|
macro_rules! def_register {
|
|
|
|
() => {
|
|
|
|
def_register!(imp);
|
|
|
|
};
|
|
|
|
(imp $($par:ident => $mark:ty => $param:ty => $clone:expr),*) => {
|
2020-02-25 08:02:27 +01:00
|
|
|
impl<
|
2017-12-20 12:16:14 +01:00
|
|
|
$($par: Any + Clone,)*
|
|
|
|
FN: Fn($($param),*) -> RET + 'static,
|
2020-02-25 08:02:27 +01:00
|
|
|
RET: Any
|
|
|
|
> RegisterFn<FN, ($($mark,)*), RET> for Engine
|
2017-12-20 12:16:14 +01:00
|
|
|
{
|
|
|
|
fn register_fn(&mut self, name: &str, f: FN) {
|
2020-03-02 05:08:03 +01:00
|
|
|
let fn_name = name.to_string();
|
|
|
|
|
2020-03-02 15:13:14 +01:00
|
|
|
let fun = move |mut args: FnCallArgs, pos: Position| {
|
2017-12-20 12:16:14 +01:00
|
|
|
// Check for length at the beginning to avoid
|
|
|
|
// per-element bound checks.
|
2020-03-02 05:08:03 +01:00
|
|
|
const NUM_ARGS: usize = count_args!($($par)*);
|
|
|
|
|
|
|
|
if args.len() != NUM_ARGS {
|
2020-03-02 15:13:14 +01:00
|
|
|
return Err(EvalAltResult::ErrorFunctionArgsMismatch(fn_name.clone(), NUM_ARGS, pos));
|
2016-03-02 16:49:24 +01:00
|
|
|
}
|
|
|
|
|
2019-09-18 12:21:07 +02:00
|
|
|
#[allow(unused_variables, unused_mut)]
|
2017-12-20 12:16:14 +01:00
|
|
|
let mut drain = args.drain(..);
|
|
|
|
$(
|
|
|
|
// Downcast every element, return in case of a type mismatch
|
2020-03-02 05:08:03 +01:00
|
|
|
let $par = ((*drain.next().unwrap()).downcast_mut() as Option<&mut $par>).unwrap();
|
2017-12-20 12:16:14 +01:00
|
|
|
)*
|
|
|
|
|
|
|
|
// Call the user-supplied function using ($clone) to
|
|
|
|
// potentially clone the value, otherwise pass the reference.
|
2020-02-23 15:48:46 +01:00
|
|
|
let r = f($(($clone)($par)),*);
|
2020-02-25 08:02:27 +01:00
|
|
|
Ok(Box::new(r) as Dynamic)
|
2020-02-23 15:48:46 +01:00
|
|
|
};
|
2020-03-02 07:28:42 +01:00
|
|
|
self.register_fn_raw(name.into(), Some(vec![$(TypeId::of::<$par>()),*]), Box::new(fun));
|
2020-02-23 15:48:46 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-25 08:02:27 +01:00
|
|
|
impl<
|
2020-02-23 15:48:46 +01:00
|
|
|
$($par: Any + Clone,)*
|
2020-02-25 08:02:27 +01:00
|
|
|
FN: Fn($($param),*) -> Dynamic + 'static,
|
2020-02-28 16:38:39 +01:00
|
|
|
> RegisterDynamicFn<FN, ($($mark,)*)> for Engine
|
2020-02-23 15:48:46 +01:00
|
|
|
{
|
2020-02-25 08:02:27 +01:00
|
|
|
fn register_dynamic_fn(&mut self, name: &str, f: FN) {
|
2020-03-02 05:08:03 +01:00
|
|
|
let fn_name = name.to_string();
|
|
|
|
|
2020-03-02 15:13:14 +01:00
|
|
|
let fun = move |mut args: FnCallArgs, pos: Position| {
|
2020-02-23 15:48:46 +01:00
|
|
|
// Check for length at the beginning to avoid
|
|
|
|
// per-element bound checks.
|
2020-03-02 05:08:03 +01:00
|
|
|
const NUM_ARGS: usize = count_args!($($par)*);
|
|
|
|
|
|
|
|
if args.len() != NUM_ARGS {
|
2020-03-02 15:13:14 +01:00
|
|
|
return Err(EvalAltResult::ErrorFunctionArgsMismatch(fn_name.clone(), NUM_ARGS, pos));
|
2020-02-23 15:48:46 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
#[allow(unused_variables, unused_mut)]
|
|
|
|
let mut drain = args.drain(..);
|
|
|
|
$(
|
|
|
|
// Downcast every element, return in case of a type mismatch
|
2020-03-02 05:08:03 +01:00
|
|
|
let $par = ((*drain.next().unwrap()).downcast_mut() as Option<&mut $par>).unwrap();
|
2020-02-23 15:48:46 +01:00
|
|
|
)*
|
|
|
|
|
|
|
|
// Call the user-supplied function using ($clone) to
|
|
|
|
// potentially clone the value, otherwise pass the reference.
|
|
|
|
Ok(f($(($clone)($par)),*))
|
2017-12-20 12:16:14 +01:00
|
|
|
};
|
2020-03-02 07:28:42 +01:00
|
|
|
self.register_fn_raw(name.into(), Some(vec![$(TypeId::of::<$par>()),*]), Box::new(fun));
|
2017-12-20 12:16:14 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//def_register!(imp_pop $($par => $mark => $param),*);
|
|
|
|
};
|
|
|
|
($p0:ident $(, $p:ident)*) => {
|
|
|
|
def_register!(imp $p0 => $p0 => $p0 => Clone::clone $(, $p => $p => $p => Clone::clone)*);
|
|
|
|
def_register!(imp $p0 => Ref<$p0> => &$p0 => |x| { x } $(, $p => $p => $p => Clone::clone)*);
|
|
|
|
def_register!(imp $p0 => Mut<$p0> => &mut $p0 => |x| { x } $(, $p => $p => $p => Clone::clone)*);
|
|
|
|
|
|
|
|
def_register!($($p),*);
|
|
|
|
};
|
|
|
|
// (imp_pop) => {};
|
|
|
|
// (imp_pop $head:ident => $head_mark:ty => $head_param:ty $(,$tail:ident => $tail_mark:ty => $tp:ty)*) => {
|
|
|
|
// def_register!(imp $($tail => $tail_mark => $tp),*);
|
|
|
|
// };
|
2016-03-02 16:49:24 +01:00
|
|
|
}
|
|
|
|
|
2017-12-20 12:16:14 +01:00
|
|
|
#[cfg_attr(rustfmt, rustfmt_skip)]
|
2017-12-20 22:16:53 +01:00
|
|
|
def_register!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S);
|