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

Bring more functions into modules in plugins via rhai_fn(name) attribute.

Browse Source
This commit is contained in:
Stephen Chung 2020-08-16 23:41:59 +08:00
parent 31a05f8c48
commit e75d91e9bf
9 changed files with 210 additions and 244 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
codegen/src/lib.rs
View File

@ -93,7 +93,7 @@
//! ```
//!
use quote::{quote, ToTokens};
use quote::quote;
use syn::parse_macro_input;
mod function;

44
src/packages/array_basic.rs
View File

@ -11,9 +11,6 @@ use crate::plugin::*;
#[cfg(not(feature = "unchecked"))]
use crate::{result::EvalAltResult, token::Position};
#[cfg(not(feature = "no_object"))]
use crate::engine::make_getter;
use crate::stdlib::{any::TypeId, boxed::Box};
#[cfg(not(feature = "unchecked"))]
@ -61,8 +58,9 @@ macro_rules! reg_pad {
def_package!(crate:BasicArrayPackage:"Basic array utilities.", lib, {
lib.combine(exported_module!(array_functions));
set_exported_fn!(lib, "+", append);
set_exported_fn!(lib, "+", concat);
#[cfg(not(feature = "no_object"))]
lib.combine(exported_module!(object_functions));
reg_functions!(lib += basic; INT, bool, char, ImmutableString, FnPtr, Array, Unit);
reg_pad!(lib, INT, bool, char, ImmutableString, FnPtr, Array, Unit);
@ -86,9 +84,6 @@ def_package!(crate:BasicArrayPackage:"Basic array utilities.", lib, {
reg_pad!(lib, f32, f64);
}
#[cfg(not(feature = "no_object"))]
set_exported_fn!(lib, make_getter("len"), array_funcs::len);
// Register array iterator
lib.set_iter(
TypeId::of::<Array>(),
@ -96,24 +91,23 @@ def_package!(crate:BasicArrayPackage:"Basic array utilities.", lib, {
);
});
#[export_fn]
fn append(x: &mut Array, y: Array) {
x.extend(y);
}
#[export_fn]
fn concat(mut x: Array, y: Array) -> Array {
x.extend(y);
x
}
#[export_module]
mod array_functions {
pub fn len(list: &mut Array) -> INT {
array_funcs::len(list)
list.len() as INT
}
pub fn append(x: &mut Array, y: Array) {
x.extend(y);
}
#[rhai_fn(name = "+=")]
pub fn append_operator(x: &mut Array, y: Array) {
append(x, y)
}
#[rhai_fn(name = "+")]
pub fn concat(mut x: Array, y: Array) -> Array {
x.extend(y);
x
}
pub fn pop(list: &mut Array) -> Dynamic {
list.pop().unwrap_or_else(|| ().into())
}
@ -143,14 +137,12 @@ mod array_functions {
}
}
mod array_funcs {
use crate::engine::Array;
use crate::parser::INT;
use crate::plugin::*;
#[export_fn]
#[cfg(not(feature = "no_object"))]
#[export_module]
mod object_functions {
#[rhai_fn(name = "get$len")]
pub fn len(list: &mut Array) -> INT {
list.len() as INT
array_functions::len(list)
}
}

8
src/packages/eval.rs
View File

@ -4,11 +4,11 @@ use crate::parser::ImmutableString;
use crate::plugin::*;
use crate::result::EvalAltResult;
def_package!(crate:EvalPackage:"Disable 'eval'.", lib, {
set_exported_fn!(lib, "eval", eval_override);
});
#[export_fn(return_raw)]
fn eval_override(_script: ImmutableString) -> Result<Dynamic, Box<EvalAltResult>> {
Err("eval is evil!".into())
}
def_package!(crate:EvalPackage:"Disable 'eval'.", lib, {
set_exported_fn!(lib, "eval", eval_override);
});

10
src/packages/fn_basic.rs
View File

@ -5,14 +5,14 @@ use crate::plugin::*;
#[cfg(not(feature = "no_object"))]
use crate::engine::make_getter;
#[export_fn]
fn get_fn_name(f: &mut FnPtr) -> ImmutableString {
f.get_fn_name().clone()
}
def_package!(crate:BasicFnPackage:"Basic Fn functions.", lib, {
set_exported_fn!(lib, "name", get_fn_name);
#[cfg(not(feature = "no_object"))]
set_exported_fn!(lib, make_getter("name"), get_fn_name);
});
#[export_fn]
fn get_fn_name(f: &mut FnPtr) -> ImmutableString {
f.get_fn_name().clone()
}

50
src/packages/map_basic.rs
View File

@ -2,7 +2,7 @@
use crate::any::Dynamic;
use crate::def_package;
use crate::engine::{make_getter, Map};
use crate::engine::Map;
use crate::parser::{ImmutableString, INT};
use crate::plugin::*;
@ -10,9 +10,6 @@ use crate::stdlib::vec::Vec;
def_package!(crate:BasicMapPackage:"Basic object map utilities.", lib, {
lib.combine(exported_module!(map_functions));
set_exported_fn!(lib, make_getter("len"), map_funcs::len);
set_exported_fn!(lib, "+=", map_funcs::mixin);
set_exported_fn!(lib, "+", map_funcs::merge);
// Register map access functions
#[cfg(not(feature = "no_index"))]
@ -25,7 +22,11 @@ mod map_functions {
map.contains_key(&prop)
}
pub fn len(map: &mut Map) -> INT {
map_funcs::len(map)
map.len() as INT
}
#[rhai_fn(name = "get$len")]
pub fn len_prop(map: &mut Map) -> INT {
len(map)
}
pub fn clear(map: &mut Map) {
map.clear();
@ -34,7 +35,20 @@ mod map_functions {
x.remove(&name).unwrap_or_else(|| ().into())
}
pub fn mixin(map1: &mut Map, map2: Map) {
map_funcs::mixin(map1, map2);
map2.into_iter().for_each(|(key, value)| {
map1.insert(key, value);
});
}
#[rhai_fn(name = "+=")]
pub fn mixin_operator(map1: &mut Map, map2: Map) {
mixin(map1, map2)
}
#[rhai_fn(name = "+")]
pub fn merge(mut map1: Map, map2: Map) -> Map {
map2.into_iter().for_each(|(key, value)| {
map1.insert(key, value);
});
map1
}
pub fn fill_with(map1: &mut Map, map2: Map) {
map2.into_iter().for_each(|(key, value)| {
@ -45,30 +59,6 @@ mod map_functions {
}
}
mod map_funcs {
use crate::engine::Map;
use crate::parser::INT;
use crate::plugin::*;
#[export_fn]
pub fn len(map: &mut Map) -> INT {
map.len() as INT
}
#[export_fn]
pub fn mixin(map1: &mut Map, map2: Map) {
map2.into_iter().for_each(|(key, value)| {
map1.insert(key, value);
});
}
#[export_fn]
pub fn merge(mut map1: Map, map2: Map) -> Map {
map2.into_iter().for_each(|(key, value)| {
map1.insert(key, value);
});
map1
}
}
#[cfg(not(feature = "no_index"))]
#[export_module]
mod index_functions {

153
src/packages/string_more.rs
View File

@ -11,9 +11,6 @@ use crate::utils::StaticVec;
#[cfg(not(feature = "unchecked"))]
use crate::{result::EvalAltResult, token::Position};
#[cfg(not(feature = "no_object"))]
use crate::engine::make_getter;
use crate::stdlib::{
any::TypeId, boxed::Box, fmt::Display, format, mem, string::String, string::ToString, vec::Vec,
};
@ -61,29 +58,12 @@ def_package!(crate:MoreStringPackage:"Additional string utilities, including str
reg_functions!(lib += float; f32, f64);
#[cfg(not(feature = "no_index"))]
{
set_exported_fn!(lib, "+", string_funcs_array::append_array);
set_exported_fn!(lib, "+", string_funcs_array::prepend_array);
}
lib.combine(exported_module!(index_functions));
#[cfg(not(feature = "no_object"))]
lib.combine(exported_module!(object_functions));
lib.combine(exported_module!(string_functions));
set_exported_fn!(lib, "contains", string_funcs::contains_char);
set_exported_fn!(lib, "contains", string_funcs::contains_string);
set_exported_fn!(lib, "index_of", string_funcs::index_of_char);
set_exported_fn!(lib, "index_of", string_funcs::index_of_char_starting_from);
set_exported_fn!(lib, "index_of", string_funcs::index_of_string);
set_exported_fn!(lib, "index_of", string_funcs::index_of_string_starting_from);
set_exported_fn!(lib, "append", string_funcs::append_char);
set_exported_fn!(lib, "+=", string_funcs::append_char);
set_exported_fn!(lib, "append", string_funcs::append_string);
set_exported_fn!(lib, "sub_string", string_funcs::sub_string);
set_exported_fn!(lib, "sub_string", string_funcs::sub_string_starting_from);
set_exported_fn!(lib, "crop", string_funcs::crop_string);
set_exported_fn!(lib, "crop", string_funcs::crop_string_starting_from);
set_exported_fn!(lib, "replace", string_funcs::replace_string);
set_exported_fn!(lib, "replace", string_funcs::replace_char);
set_exported_fn!(lib, "replace", string_funcs::replace_string_with_char);
set_exported_fn!(lib, "replace", string_funcs::replace_char_with_string);
lib.set_raw_fn(
"pad",
@ -131,9 +111,6 @@ def_package!(crate:MoreStringPackage:"Additional string utilities, including str
},
);
#[cfg(not(feature = "no_object"))]
set_exported_fn!(lib, make_getter("len"), string_funcs::len);
// Register string iterator
lib.set_iter(
TypeId::of::<ImmutableString>(),
@ -166,9 +143,27 @@ gen_concat_functions!(float => f32, f64);
#[export_module]
mod string_functions {
pub fn len(s: &mut ImmutableString) -> INT {
string_funcs::len(s)
#[rhai_fn(name = "+")]
pub fn append_unit(s: ImmutableString, _x: ()) -> ImmutableString {
s
}
#[rhai_fn(name = "+")]
pub fn prepend_unit(_x: (), s: ImmutableString) -> ImmutableString {
s
}
#[rhai_fn(name = "+")]
pub fn append_char(s: &mut ImmutableString, ch: char) {
*s += ch;
}
#[rhai_fn(name = "+")]
pub fn append_string(s: &mut ImmutableString, add: ImmutableString) {
*s += &add;
}
pub fn len(s: &mut ImmutableString) -> INT {
s.chars().count() as INT
}
pub fn clear(s: &mut ImmutableString) {
s.make_mut().clear();
}
@ -189,52 +184,17 @@ mod string_functions {
*s = trimmed.to_string().into();
}
}
}
#[cfg(not(feature = "no_index"))]
mod string_funcs_array {
use crate::engine::Array;
use crate::plugin::*;
use crate::stdlib::string::String;
use crate::utils::ImmutableString;
#[export_fn]
pub fn append_array(x: &mut ImmutableString, y: Array) -> String {
format!("{}{:?}", x, y)
}
#[export_fn]
pub fn prepend_array(x: &mut Array, y: ImmutableString) -> String {
format!("{:?}{}", x, y)
}
}
mod string_funcs {
use crate::parser::INT;
use crate::plugin::*;
use crate::stdlib::string::{String, ToString};
use crate::utils::{ImmutableString, StaticVec};
#[export_fn]
pub fn append_unit(s: ImmutableString, _x: ()) -> ImmutableString {
s
}
#[export_fn]
pub fn prepend_unit(_x: (), s: ImmutableString) -> ImmutableString {
s
}
#[export_fn]
pub fn len(s: &mut ImmutableString) -> INT {
s.chars().count() as INT
}
#[export_fn]
#[rhai_fn(name = "contains")]
pub fn contains_char(s: &mut ImmutableString, ch: char) -> bool {
s.contains(ch)
}
#[export_fn]
#[rhai_fn(name = "contains")]
pub fn contains_string(s: &mut ImmutableString, find: ImmutableString) -> bool {
s.contains(find.as_str())
}
#[export_fn]
#[rhai_fn(name = "index_of")]
pub fn index_of_char_starting_from(s: &mut ImmutableString, ch: char, start: INT) -> INT {
let start = if start < 0 {
0
@ -249,13 +209,13 @@ mod string_funcs {
.map(|index| s[0..start + index].chars().count() as INT)
.unwrap_or(-1 as INT)
}
#[export_fn]
#[rhai_fn(name = "index_of")]
pub fn index_of_char(s: &mut ImmutableString, ch: char) -> INT {
s.find(ch)
.map(|index| s[0..index].chars().count() as INT)
.unwrap_or(-1 as INT)
}
#[export_fn]
#[rhai_fn(name = "index_of")]
pub fn index_of_string_starting_from(
s: &mut ImmutableString,
find: ImmutableString,
@ -274,21 +234,14 @@ mod string_funcs {
.map(|index| s[0..start + index].chars().count() as INT)
.unwrap_or(-1 as INT)
}
#[export_fn]
#[rhai_fn(name = "index_of")]
pub fn index_of_string(s: &mut ImmutableString, find: ImmutableString) -> INT {
s.find(find.as_str())
.map(|index| s[0..index].chars().count() as INT)
.unwrap_or(-1 as INT)
}
#[export_fn]
pub fn append_char(s: &mut ImmutableString, ch: char) {
*s += ch;
}
#[export_fn]
pub fn append_string(s: &mut ImmutableString, add: ImmutableString) {
*s += &add;
}
#[export_fn]
#[rhai_fn(name = "sub_string")]
pub fn sub_string(s: ImmutableString, start: INT, len: INT) -> ImmutableString {
let offset = if s.is_empty() || len <= 0 {
return "".to_string().into();
@ -316,12 +269,13 @@ mod string_funcs {
.collect::<String>()
.into()
}
#[export_fn]
#[rhai_fn(name = "sub_string")]
pub fn sub_string_starting_from(s: ImmutableString, start: INT) -> ImmutableString {
let len = s.len() as INT;
sub_string(s, start, len)
}
#[export_fn]
#[rhai_fn(name = "crop")]
fn crop_string(s: &mut ImmutableString, start: INT, len: INT) {
let offset = if s.is_empty() || len <= 0 {
s.make_mut().clear();
@ -347,24 +301,49 @@ mod string_funcs {
copy.clear();
copy.extend(chars.iter().skip(offset).take(len));
}
#[export_fn]
#[rhai_fn(name = "crop")]
pub fn crop_string_starting_from(s: &mut ImmutableString, start: INT) {
crop_string(s, start, s.len() as INT);
}
#[export_fn]
#[rhai_fn(name = "replace")]
pub fn replace_string(s: &mut ImmutableString, find: ImmutableString, sub: ImmutableString) {
*s = s.replace(find.as_str(), sub.as_str()).into();
}
#[export_fn]
#[rhai_fn(name = "replace")]
pub fn replace_string_with_char(s: &mut ImmutableString, find: ImmutableString, sub: char) {
*s = s.replace(find.as_str(), &sub.to_string()).into();
}
#[export_fn]
#[rhai_fn(name = "replace")]
pub fn replace_char_with_string(s: &mut ImmutableString, find: char, sub: ImmutableString) {
*s = s.replace(&find.to_string(), sub.as_str()).into();
}
#[export_fn]
#[rhai_fn(name = "replace")]
pub fn replace_char(s: &mut ImmutableString, find: char, sub: char) {
*s = s.replace(&find.to_string(), &sub.to_string()).into();
}
}
#[cfg(not(feature = "no_index"))]
#[export_module]
mod index_functions {
use crate::engine::Array;
#[rhai_fn(name = "+")]
pub fn append(x: &mut ImmutableString, y: Array) -> String {
format!("{}{:?}", x, y)
}
#[rhai_fn(name = "+")]
pub fn prepend(x: &mut Array, y: ImmutableString) -> String {
format!("{:?}{}", x, y)
}
}
#[cfg(not(feature = "no_object"))]
#[export_module]
mod object_functions {
#[rhai_fn(name = "get$len")]
pub fn len(s: &mut ImmutableString) -> INT {
string_functions::len(s)
}
}

72
src/packages/time_basic.rs
View File

@ -18,9 +18,6 @@ use crate::parser::INT;
#[cfg(not(feature = "unchecked"))]
use crate::token::Position;
#[cfg(not(feature = "no_object"))]
use crate::engine::make_getter;
#[cfg(not(target_arch = "wasm32"))]
use crate::stdlib::time::Instant;
@ -29,38 +26,26 @@ use instant::Instant;
def_package!(crate:BasicTimePackage:"Basic timing utilities.", lib, {
// Register date/time functions
set_exported_fn!(lib, "timestamp", create_timestamp);
set_exported_fn!(lib, "elapsed", elapsed);
lib.combine(exported_module!(time_functions));
#[cfg(not(feature = "no_object"))]
set_exported_fn!(lib, make_getter("elapsed"), elapsed);
set_exported_fn!(lib, "-", time_diff);
//lib.combine(exported_module!(time_compare));
lib.set_fn_2("<", |x:Instant, y:Instant| Ok(x < y));
lib.set_fn_2("<=", |x:Instant, y:Instant| Ok(x <= y));
lib.set_fn_2(">", |x:Instant, y:Instant| Ok(x > y));
lib.set_fn_2(">=", |x:Instant, y:Instant| Ok(x >= y));
lib.set_fn_2("==", |x:Instant, y:Instant| Ok(x == y));
lib.set_fn_2("!=", |x:Instant, y:Instant| Ok(x != y));
lib.set_getter_fn("elapsed", time_functions::elapsed);
});
#[export_fn]
fn create_timestamp() -> Instant {
#[export_module]
mod time_functions {
pub fn timestamp() -> Instant {
Instant::now()
}
}
#[rhai_fn(return_raw)]
pub fn elapsed(timestamp: &mut Instant) -> Result<Dynamic, Box<EvalAltResult>> {
#[cfg(not(feature = "no_float"))]
{
Ok((timestamp.elapsed().as_secs_f64() as FLOAT).into())
}
#[cfg(not(feature = "no_float"))]
#[export_fn]
fn elapsed(timestamp: &mut Instant) -> FLOAT {
timestamp.elapsed().as_secs_f64() as FLOAT
}
#[cfg(feature = "no_float")]
#[export_fn(return_raw)]
fn elapsed(timestamp: &mut Instant) -> Result<Dynamic, Box<EvalAltResult>> {
#[cfg(feature = "no_float")]
{
let seconds = timestamp.elapsed().as_secs();
#[cfg(not(feature = "unchecked"))]
@ -73,21 +58,22 @@ fn elapsed(timestamp: &mut Instant) -> Result<Dynamic, Box<EvalAltResult>> {
}
Ok((seconds as INT).into())
}
}
}
#[cfg(not(feature = "no_float"))]
#[export_fn]
fn time_diff(ts1: Instant, ts2: Instant) -> FLOAT {
if ts2 > ts1 {
#[rhai_fn(return_raw, name = "-")]
fn time_diff(ts1: Instant, ts2: Instant) -> Result<Dynamic, Box<EvalAltResult>> {
#[cfg(not(feature = "no_float"))]
{
Ok(if ts2 > ts1 {
-(ts2 - ts1).as_secs_f64() as FLOAT
} else {
(ts1 - ts2).as_secs_f64() as FLOAT
}
}
.into())
}
#[cfg(feature = "no_float")]
#[export_fn(return_raw)]
fn time_diff(ts1: Instant, ts2: Instant) -> Result<Dynamic, Box<EvalAltResult>> {
#[cfg(feature = "no_float")]
if ts2 > ts1 {
let seconds = (ts2 - ts1).as_secs();
@ -115,25 +101,29 @@ fn time_diff(ts1: Instant, ts2: Instant) -> Result<Dynamic, Box<EvalAltResult>>
Ok((seconds as INT).into())
}
}
}
#[export_module]
mod time_compare {
#[rhai_fn(name = "==")]
pub fn eq(x: Instant, y: Instant) -> bool {
x == y
}
#[rhai_fn(name = "!=")]
pub fn ne(x: Instant, y: Instant) -> bool {
x != y
}
#[rhai_fn(name = "<")]
pub fn lt(x: Instant, y: Instant) -> bool {
x < y
}
#[rhai_fn(name = "<=")]
pub fn lte(x: Instant, y: Instant) -> bool {
x <= y
}
#[rhai_fn(name = ">")]
pub fn gt(x: Instant, y: Instant) -> bool {
x > y
}
#[rhai_fn(name = ">=")]
pub fn gte(x: Instant, y: Instant) -> bool {
x >= y
}

12
tests/plugins.rs
View File

@ -7,9 +7,14 @@ use rhai::{Engine, EvalAltResult, INT};
mod special_array_package {
use rhai::{Array, INT};
#[rhai_fn(name = "test")]
pub fn len(array: &mut Array, mul: INT) -> INT {
(array.len() as INT) * mul
}
#[rhai_fn(name = "+")]
pub fn funky_add(x: INT, y: INT) -> INT {
x / 2 + y * 2
}
}
macro_rules! gen_unary_functions {
@ -18,7 +23,7 @@ macro_rules! gen_unary_functions {
pub mod $arg_type {
use super::super::*;
#[export_fn]
#[export_fn(name="test")]
pub fn single(x: $arg_type) -> $return_type {
super::super::$op_fn(x)
}
@ -48,9 +53,10 @@ fn test_plugins_package() -> Result<(), Box<EvalAltResult>> {
reg_functions!(engine += greet::single(INT, bool, char));
assert_eq!(engine.eval::<INT>("let a = [1, 2, 3]; len(a, 2)")?, 6);
assert_eq!(engine.eval::<INT>("let a = [1, 2, 3]; test(a, 2)")?, 6);
assert_eq!(engine.eval::<INT>("2 + 2")?, 5);
assert_eq!(
engine.eval::<String>("let a = [1, 2, 3]; greet(len(a, 2))")?,
engine.eval::<String>("let a = [1, 2, 3]; greet(test(a, 2))")?,
"6 kitties"
);

9
tests/time.rs
View File

@ -39,5 +39,14 @@ fn test_timestamp() -> Result<(), Box<EvalAltResult>> {
)? < 10
);
assert!(engine.eval::<bool>(
r"
let time1 = timestamp();
for x in range(0, 10000) {}
let time2 = timestamp();
time1 <= time2
"
)?);
Ok(())
}