Merge pull request #375 from schungx/master
Change HashMap to BTreeMap.
This commit is contained in:
Stephen Chung
GitHub
commit
77a71dbbf0
17
CHANGELOG.md
17
CHANGELOG.md
@ -4,18 +4,33 @@ Rhai Release Notes
|
||||
Version 0.19.15
|
||||
===============
|
||||
|
||||
This version replaces internal usage of `HashMap` with `BTreeMap` in many cases, which should result
|
||||
in speed improvements because a `BTreeMap` is faster when the number of items held is small.
|
||||
|
||||
This also translates to the Rhai object map type, `Map`, which used to be an alias to `HashMap` and
|
||||
is now aliased to `BTreeMap` instead. This change is due to the fact that, in the vast majority of
|
||||
object map usages, the number of properties held is small.
|
||||
|
||||
`HashMap` and `BTreeMap` have almost identical public API's so this change is unlikely to break a
|
||||
lot of existing code.
|
||||
|
||||
|
||||
Breaking changes
|
||||
----------------
|
||||
|
||||
* `Map` is now an alias to `BTreeMap` instead of `HashMap`. This is because most object maps used have few properties.
|
||||
* The traits `RegisterFn` and `RegisterResultFn` are removed. `Engine::register_fn` and `Engine::register_result_fn` are now implemented directly on `Engine`.
|
||||
* `FnPtr::call_dynamic` now takes `&NativeCallContext` instead of consuming it.
|
||||
* All `Module::set_fn_XXX` methods are removed, in favor of `Module::set_native_fn`.
|
||||
* `Array::reduce` and `Array::reduce_rev` now take a `Dynamic` as initial value instead of a function pointer.
|
||||
* `protected`, `super` are now reserved keywords.
|
||||
|
||||
Enhancements
|
||||
------------
|
||||
|
||||
* `Engine::register_result_fn` no longer requires the successful return type to be `Dynamic`. It can now be any type.
|
||||
* Replaced most `HashMap` usage with `BTreeMap` for better performance when the number of items is small.
|
||||
* `Engine::register_result_fn` no longer requires the successful return type to be `Dynamic`. It can now be any clonable type.
|
||||
* `#[rhai_fn(return_raw)]` can now return `Result<T, Box<EvalAltResult>>` where `T` is any clonable type instead of `Result<Dynamic, Box<EvalAltResult>>`.
|
||||
|
||||
|
||||
Version 0.19.14
|
||||
|
||||
45
Cargo.toml
45
Cargo.toml
@ -17,31 +17,30 @@ categories = ["no-std", "embedded", "wasm", "parser-implementations"]
|
||||
|
||||
[dependencies]
|
||||
smallvec = { version = "1.6", default-features = false, features = ["union"] }
|
||||
ahash = { version = "0.6", default-features = false }
|
||||
ahash = { version = "0.7", default-features = false }
|
||||
num-traits = { version = "0.2", default_features = false }
|
||||
rhai_codegen = { version = "0.3.3", path = "codegen" }
|
||||
rhai_codegen = { version = "0.3.4", path = "codegen" }
|
||||
|
||||
[features]
|
||||
default = []
|
||||
unchecked = [] # unchecked arithmetic
|
||||
sync = [] # restrict to only types that implement Send + Sync
|
||||
no_optimize = [] # no script optimizer
|
||||
no_float = [] # no floating-point
|
||||
f32_float = [] # set FLOAT=f32
|
||||
only_i32 = [] # set INT=i32 (useful for 32-bit systems)
|
||||
only_i64 = [] # set INT=i64 (default) and disable support for all other integer types
|
||||
decimal = ["rust_decimal"] # add the Decimal number type
|
||||
no_index = [] # no arrays and indexing
|
||||
no_object = [] # no custom objects
|
||||
no_function = ["no_closure"] # no script-defined functions (meaning no closures)
|
||||
no_closure = [] # no automatic sharing and capture of anonymous functions to external variables
|
||||
no_module = [] # no modules
|
||||
internals = [] # expose internal data structures
|
||||
unchecked = [] # unchecked arithmetic
|
||||
sync = [] # restrict to only types that implement Send + Sync
|
||||
no_optimize = [] # no script optimizer
|
||||
no_float = [] # no floating-point
|
||||
f32_float = [] # set FLOAT=f32
|
||||
only_i32 = [] # set INT=i32 (useful for 32-bit systems)
|
||||
only_i64 = [] # set INT=i64 (default) and disable support for all other integer types
|
||||
decimal = ["rust_decimal"] # add the Decimal number type
|
||||
no_index = [] # no arrays and indexing
|
||||
no_object = [] # no custom objects
|
||||
no_function = ["no_closure"] # no script-defined functions (meaning no closures)
|
||||
no_closure = [] # no automatic sharing and capture of anonymous functions to external variables
|
||||
no_module = [] # no modules
|
||||
internals = [] # expose internal data structures
|
||||
unicode-xid-ident = ["unicode-xid"] # allow Unicode Standard Annex #31 for identifiers.
|
||||
metadata = ["serde", "serde_json"] # enables exporting functions metadata to JSON
|
||||
metadata = ["serde", "serde_json"] # enables exporting functions metadata to JSON
|
||||
|
||||
# compiling for no-std
|
||||
no_std = ["smallvec/union", "num-traits/libm", "hashbrown", "core-error", "libm", "ahash/compile-time-rng"]
|
||||
no_std = ["smallvec/union", "num-traits/libm", "core-error", "libm", "ahash/compile-time-rng"]
|
||||
|
||||
# compiling for WASM
|
||||
wasm-bindgen = ["instant/wasm-bindgen"]
|
||||
@ -64,12 +63,6 @@ default_features = false
|
||||
features = ["alloc"]
|
||||
optional = true
|
||||
|
||||
[dependencies.hashbrown]
|
||||
version = "0.7"
|
||||
default-features = false
|
||||
features = ["ahash", "nightly", "inline-more"]
|
||||
optional = true
|
||||
|
||||
[dependencies.serde]
|
||||
version = "1.0"
|
||||
default_features = false
|
||||
@ -99,4 +92,4 @@ instant = { version = "0.1" } # WASM implementation of std::time::Instant
|
||||
instant = { version = "0.1" } # WASM implementation of std::time::Instant
|
||||
|
||||
[package.metadata.docs.rs]
|
||||
features = ["metadata", "internals", "decimal"]
|
||||
features = ["metadata", "internals", "decimal"] # compiling for no-std
|
||||
|
||||
17
README.md
17
README.md
@ -28,11 +28,11 @@ Supported targets and builds
|
||||
Standard features
|
||||
-----------------
|
||||
|
||||
* Simple language similar to JavaScript+Rust with dynamic typing.
|
||||
* Simple language similar to JavaScript+Rust with [dynamic](https://rhai.rs/book/language/dynamic.html) typing.
|
||||
* Fairly efficient evaluation (1 million iterations in 0.3 sec on a single-core, 2.3 GHz Linux VM).
|
||||
* Tight integration with native Rust [functions](https://rhai.rs/book/rust/functions.html) and [types]([#custom-types-and-methods](https://rhai.rs/book/rust/custom.html)), including [getters/setters](https://rhai.rs/book/rust/getters-setters.html), [methods](https://rhai.rs/book/rust/custom.html) and [indexers](https://rhai.rs/book/rust/indexers.html).
|
||||
* Freely pass Rust variables/constants into a script via an external [`Scope`](https://rhai.rs/book/rust/scope.html) - all clonable Rust types are supported; no need to implement any special trait.
|
||||
* Built-in support for most common [data types](https://rhai.rs/book/language/values-and-types.html) including booleans, integers, floating-point numbers (including [`Decimal`](https://crates.io/crates/rust_decimal)), strings, Unicode characters, arrays and maps.
|
||||
* Freely pass Rust values into a script as [variables](https://rhai.rs/book/language/variables.html)/[constants](https://rhai.rs/book/language/constants.html) via an external [`Scope`](https://rhai.rs/book/rust/scope.html) - all clonable Rust types are supported; no need to implement any special trait. Or tap directly into the [variable resolution process](https://rhai.rs/book/engine/var.html).
|
||||
* Built-in support for most common [data types](https://rhai.rs/book/language/values-and-types.html) including booleans, [integers](https://rhai.rs/book/language/numbers.html), [floating-point numbers](https://rhai.rs/book/language/numbers.html) (including [`Decimal`](https://crates.io/crates/rust_decimal)), [strings](https://rhai.rs/book/language/strings-chars.html), [Unicode characters](https://rhai.rs/book/language/strings-chars.html), [arrays](https://rhai.rs/book/language/arrays.html) and [object maps](https://rhai.rs/book/language/object-maps.html).
|
||||
* Easily [call a script-defined function](https://rhai.rs/book/engine/call-fn.html) from Rust.
|
||||
* Relatively little `unsafe` code (yes there are some for performance reasons).
|
||||
* Few dependencies (currently only [`smallvec`](https://crates.io/crates/smallvec), [`num-traits`](https://crates.io/crates/num-traits) and [`ahash`](https://crates.io/crates/ahash)).
|
||||
@ -44,7 +44,7 @@ Standard features
|
||||
* Dynamic dispatch via [function pointers](https://rhai.rs/book/language/fn-ptr.html) with additional support for [currying](https://rhai.rs/book/language/fn-curry.html).
|
||||
* [Closures](https://rhai.rs/book/language/fn-closure.html) (anonymous functions) that can capture shared values.
|
||||
* Some syntactic support for [object-oriented programming (OOP)](https://rhai.rs/book/language/oop.html).
|
||||
* Organize code base with dynamically-loadable [modules](https://rhai.rs/book/language/modules.html), optionally overriding the resolution process
|
||||
* Organize code base with dynamically-loadable [modules](https://rhai.rs/book/language/modules.html), optionally [overriding the resolution process](https://rhai.rs/book/rust/modules/resolvers.html).
|
||||
* Serialization/deserialization support via [serde](https://crates.io/crates/serde) (requires the `serde` feature).
|
||||
* Support for [minimal builds](https://rhai.rs/book/start/builds/minimal.html) by excluding unneeded language [features](https://rhai.rs/book/start/features.html).
|
||||
|
||||
@ -52,7 +52,8 @@ Standard features
|
||||
Protected against attacks
|
||||
-------------------------
|
||||
|
||||
* Sand-boxed - the scripting engine, if declared immutable, cannot mutate the containing environment unless [explicitly permitted](https://rhai.rs/book/patterns/control.html).
|
||||
* _Don't Panic_ guarantee - Any panic is a bug. Rhai subscribes to the motto that a library should never panic the host system, and is coded with this in mind.
|
||||
* [Sand-boxed](https://rhai.rs/book/safety/sandbox.html) - the scripting engine, if declared immutable, cannot mutate the containing environment unless [explicitly permitted](https://rhai.rs/book/patterns/control.html).
|
||||
* Rugged - protected against malicious attacks (such as [stack-overflow](https://rhai.rs/book/safety/max-call-stack.html), [over-sized data](https://rhai.rs/book/safety/max-string-size.html), and [runaway scripts](https://rhai.rs/book/safety/max-operations.html) etc.) that may come from untrusted third-party user-land scripts.
|
||||
* Track script evaluation [progress](https://rhai.rs/book/safety/progress.html) and manually terminate a script run.
|
||||
|
||||
@ -75,14 +76,14 @@ Project Site
|
||||
Documentation
|
||||
-------------
|
||||
|
||||
See [The Rhai Book](https://rhai.rs/book) for details on the Rhai scripting engine and language.
|
||||
See [_The Rhai Book_](https://rhai.rs/book) for details on the Rhai scripting engine and language.
|
||||
|
||||
|
||||
Playground
|
||||
----------
|
||||
|
||||
An [Online Playground](https://rhai.rs/playground) is available with
|
||||
syntax-highlighting editor, powered by WebAssembly.
|
||||
An [_Online Playground_](https://rhai.rs/playground) is available with syntax-highlighting editor,
|
||||
powered by WebAssembly.
|
||||
|
||||
Scripts can be evaluated directly from the editor.
|
||||
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "rhai_codegen"
|
||||
version = "0.3.3"
|
||||
version = "0.3.4"
|
||||
edition = "2018"
|
||||
authors = ["jhwgh1968"]
|
||||
description = "Procedural macro support package for Rhai, a scripting language for Rust"
|
||||
@ -12,7 +12,7 @@ license = "MIT OR Apache-2.0"
|
||||
proc-macro = true
|
||||
|
||||
[dev-dependencies]
|
||||
rhai = { path = ".." }
|
||||
rhai = { path = "..", version = "^0.19.15" }
|
||||
trybuild = "1"
|
||||
|
||||
[dependencies]
|
||||
|
||||
@ -279,7 +279,6 @@ pub struct ExportedFn {
|
||||
signature: syn::Signature,
|
||||
visibility: syn::Visibility,
|
||||
pass_context: bool,
|
||||
return_dynamic: bool,
|
||||
mut_receiver: bool,
|
||||
params: ExportedFnParams,
|
||||
}
|
||||
@ -290,10 +289,6 @@ impl Parse for ExportedFn {
|
||||
let entire_span = fn_all.span();
|
||||
let str_type_path = syn::parse2::<syn::Path>(quote! { str }).unwrap();
|
||||
|
||||
let dynamic_type_path1 = syn::parse2::<syn::Path>(quote! { Dynamic }).unwrap();
|
||||
let dynamic_type_path2 = syn::parse2::<syn::Path>(quote! { rhai::Dynamic }).unwrap();
|
||||
let mut return_dynamic = false;
|
||||
|
||||
let context_type_path1 = syn::parse2::<syn::Path>(quote! { NativeCallContext }).unwrap();
|
||||
let context_type_path2 =
|
||||
syn::parse2::<syn::Path>(quote! { rhai::NativeCallContext }).unwrap();
|
||||
@ -400,11 +395,6 @@ impl Parse for ExportedFn {
|
||||
"Rhai functions cannot return references",
|
||||
))
|
||||
}
|
||||
syn::Type::Path(p)
|
||||
if p.path == dynamic_type_path1 || p.path == dynamic_type_path2 =>
|
||||
{
|
||||
return_dynamic = true
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
@ -413,7 +403,6 @@ impl Parse for ExportedFn {
|
||||
signature: fn_all.sig,
|
||||
visibility,
|
||||
pass_context,
|
||||
return_dynamic,
|
||||
mut_receiver,
|
||||
params: Default::default(),
|
||||
})
|
||||
@ -520,7 +509,7 @@ impl ExportedFn {
|
||||
if params.return_raw.is_some() && self.return_type().is_none() {
|
||||
return Err(syn::Error::new(
|
||||
params.return_raw.unwrap(),
|
||||
"functions marked with 'return_raw' must return Result<Dynamic, Box<EvalAltResult>>",
|
||||
"functions marked with 'return_raw' must return Result<T, Box<EvalAltResult>>",
|
||||
));
|
||||
}
|
||||
|
||||
@ -602,9 +591,8 @@ impl ExportedFn {
|
||||
syn::Ident::new(&format!("rhai_fn_{}", self.name()), self.name().span());
|
||||
let impl_block = self.generate_impl("Token");
|
||||
let callable_block = self.generate_callable("Token");
|
||||
let input_names_block = self.generate_input_names("Token");
|
||||
let param_names_block = self.generate_param_names("Token");
|
||||
let input_types_block = self.generate_input_types("Token");
|
||||
let return_type_block = self.generate_return_type("Token");
|
||||
let dyn_result_fn_block = self.generate_dynamic_fn();
|
||||
let vis = self.visibility;
|
||||
quote! {
|
||||
@ -614,10 +602,8 @@ impl ExportedFn {
|
||||
struct Token();
|
||||
#impl_block
|
||||
#callable_block
|
||||
#input_names_block
|
||||
#param_names_block
|
||||
#input_types_block
|
||||
#return_type_block
|
||||
#[allow(unused)]
|
||||
#dyn_result_fn_block
|
||||
}
|
||||
}
|
||||
@ -656,17 +642,13 @@ impl ExportedFn {
|
||||
if self.params.return_raw.is_some() {
|
||||
quote_spanned! { return_span =>
|
||||
pub #dynamic_signature {
|
||||
#name(#(#arguments),*)
|
||||
}
|
||||
}
|
||||
} else if self.return_dynamic {
|
||||
quote_spanned! { return_span =>
|
||||
pub #dynamic_signature {
|
||||
Ok(#name(#(#arguments),*))
|
||||
#name(#(#arguments),*).map(Dynamic::from)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
quote_spanned! { return_span =>
|
||||
#[allow(unused)]
|
||||
#[inline(always)]
|
||||
pub #dynamic_signature {
|
||||
Ok(Dynamic::from(#name(#(#arguments),*)))
|
||||
}
|
||||
@ -681,21 +663,23 @@ impl ExportedFn {
|
||||
self.name().span(),
|
||||
);
|
||||
quote! {
|
||||
#[inline(always)]
|
||||
pub fn #callable_fn_name() -> CallableFunction {
|
||||
#token_name().into()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn generate_input_names(&self, on_type_name: &str) -> proc_macro2::TokenStream {
|
||||
pub fn generate_param_names(&self, on_type_name: &str) -> proc_macro2::TokenStream {
|
||||
let token_name: syn::Ident = syn::Ident::new(on_type_name, self.name().span());
|
||||
let input_names_fn_name: syn::Ident = syn::Ident::new(
|
||||
&format!("{}_input_names", on_type_name.to_lowercase()),
|
||||
let param_names_fn_name: syn::Ident = syn::Ident::new(
|
||||
&format!("{}_param_names", on_type_name.to_lowercase()),
|
||||
self.name().span(),
|
||||
);
|
||||
quote! {
|
||||
pub fn #input_names_fn_name() -> Box<[&'static str]> {
|
||||
#token_name().input_names()
|
||||
#[inline(always)]
|
||||
pub fn #param_names_fn_name() -> Box<[&'static str]> {
|
||||
#token_name().param_names()
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -707,25 +691,13 @@ impl ExportedFn {
|
||||
self.name().span(),
|
||||
);
|
||||
quote! {
|
||||
#[inline(always)]
|
||||
pub fn #input_types_fn_name() -> Box<[TypeId]> {
|
||||
#token_name().input_types()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn generate_return_type(&self, on_type_name: &str) -> proc_macro2::TokenStream {
|
||||
let token_name: syn::Ident = syn::Ident::new(on_type_name, self.name().span());
|
||||
let return_type_fn_name: syn::Ident = syn::Ident::new(
|
||||
&format!("{}_return_type", on_type_name.to_lowercase()),
|
||||
self.name().span(),
|
||||
);
|
||||
quote! {
|
||||
pub fn #return_type_fn_name() -> &'static str {
|
||||
#token_name().return_type()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn generate_impl(&self, on_type_name: &str) -> proc_macro2::TokenStream {
|
||||
let sig_name = self.name().clone();
|
||||
let arg_count = self.arg_count();
|
||||
@ -890,42 +862,34 @@ impl ExportedFn {
|
||||
.map(|r| r.span())
|
||||
.unwrap_or_else(|| proc_macro2::Span::call_site());
|
||||
let return_expr = if !self.params.return_raw.is_some() {
|
||||
if self.return_dynamic {
|
||||
quote_spanned! { return_span =>
|
||||
Ok(#sig_name(#(#unpack_exprs),*))
|
||||
}
|
||||
} else {
|
||||
quote_spanned! { return_span =>
|
||||
Ok(Dynamic::from(#sig_name(#(#unpack_exprs),*)))
|
||||
}
|
||||
quote_spanned! { return_span =>
|
||||
Ok(Dynamic::from(#sig_name(#(#unpack_exprs),*)))
|
||||
}
|
||||
} else {
|
||||
quote_spanned! { return_span =>
|
||||
#sig_name(#(#unpack_exprs),*)
|
||||
#sig_name(#(#unpack_exprs),*).map(Dynamic::from)
|
||||
}
|
||||
};
|
||||
|
||||
let type_name = syn::Ident::new(on_type_name, proc_macro2::Span::call_site());
|
||||
quote! {
|
||||
impl PluginFunction for #type_name {
|
||||
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
#[inline(always)]
|
||||
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> RhaiResult {
|
||||
debug_assert_eq!(args.len(), #arg_count, "wrong arg count: {} != {}", args.len(), #arg_count);
|
||||
#(#unpack_statements)*
|
||||
#return_expr
|
||||
}
|
||||
|
||||
fn is_method_call(&self) -> bool { #is_method_call }
|
||||
fn is_variadic(&self) -> bool { false }
|
||||
fn clone_boxed(&self) -> Box<dyn PluginFunction> { Box::new(#type_name()) }
|
||||
fn input_names(&self) -> Box<[&'static str]> {
|
||||
new_vec![#(#input_type_names),*].into_boxed_slice()
|
||||
#[inline(always)] fn is_method_call(&self) -> bool { #is_method_call }
|
||||
#[inline(always)] fn is_variadic(&self) -> bool { false }
|
||||
#[inline(always)] fn clone_boxed(&self) -> Box<dyn PluginFunction> { Box::new(#type_name()) }
|
||||
#[inline(always)] fn param_names(&self) -> Box<[&'static str]> {
|
||||
new_vec![#(#input_type_names,)* #return_type].into_boxed_slice()
|
||||
}
|
||||
fn input_types(&self) -> Box<[TypeId]> {
|
||||
#[inline(always)] fn input_types(&self) -> Box<[TypeId]> {
|
||||
new_vec![#(#input_type_exprs),*].into_boxed_slice()
|
||||
}
|
||||
fn return_type(&self) -> &'static str {
|
||||
#return_type
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -340,7 +340,7 @@ pub fn set_exported_fn(args: proc_macro::TokenStream) -> proc_macro::TokenStream
|
||||
let gen_mod_path = crate::register::generated_module_path(&rust_mod_path);
|
||||
let tokens = quote! {
|
||||
#module_expr.set_fn(#export_name, FnNamespace::Internal, FnAccess::Public,
|
||||
Some(#gen_mod_path::token_input_names().as_ref()),
|
||||
Some(#gen_mod_path::token_param_names().as_ref()),
|
||||
#gen_mod_path::token_input_types().as_ref(),
|
||||
#gen_mod_path::token_callable());
|
||||
};
|
||||
@ -382,7 +382,7 @@ pub fn set_exported_global_fn(args: proc_macro::TokenStream) -> proc_macro::Toke
|
||||
let gen_mod_path = crate::register::generated_module_path(&rust_mod_path);
|
||||
let tokens = quote! {
|
||||
#module_expr.set_fn(#export_name, FnNamespace::Global, FnAccess::Public,
|
||||
Some(#gen_mod_path::token_input_names().as_ref()),
|
||||
Some(#gen_mod_path::token_param_names().as_ref()),
|
||||
#gen_mod_path::token_input_types().as_ref(),
|
||||
#gen_mod_path::token_callable());
|
||||
};
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
use std::collections::HashMap;
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
use quote::{quote, ToTokens};
|
||||
|
||||
@ -185,9 +185,8 @@ pub fn generate_body(
|
||||
});
|
||||
gen_fn_tokens.push(function.generate_impl(&fn_token_name.to_string()));
|
||||
gen_fn_tokens.push(function.generate_callable(&fn_token_name.to_string()));
|
||||
gen_fn_tokens.push(function.generate_input_names(&fn_token_name.to_string()));
|
||||
gen_fn_tokens.push(function.generate_param_names(&fn_token_name.to_string()));
|
||||
gen_fn_tokens.push(function.generate_input_types(&fn_token_name.to_string()));
|
||||
gen_fn_tokens.push(function.generate_return_type(&fn_token_name.to_string()));
|
||||
}
|
||||
|
||||
let mut generate_fn_call = syn::parse2::<syn::ItemMod>(quote! {
|
||||
@ -239,8 +238,8 @@ pub fn check_rename_collisions(fns: &Vec<ExportedFn>) -> Result<(), syn::Error>
|
||||
})
|
||||
}
|
||||
|
||||
let mut renames = HashMap::<String, proc_macro2::Span>::new();
|
||||
let mut fn_defs = HashMap::<String, proc_macro2::Span>::new();
|
||||
let mut renames = BTreeMap::<String, proc_macro2::Span>::new();
|
||||
let mut fn_defs = BTreeMap::<String, proc_macro2::Span>::new();
|
||||
|
||||
for item_fn in fns.iter() {
|
||||
if !item_fn.params().name.is_empty() || item_fn.params().special != FnSpecialAccess::None {
|
||||
|
||||
@ -277,39 +277,33 @@ mod generate_tests {
|
||||
use super::*;
|
||||
struct Token();
|
||||
impl PluginFunction for Token {
|
||||
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
#[inline(always)] fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> RhaiResult {
|
||||
debug_assert_eq!(args.len(), 0usize,
|
||||
"wrong arg count: {} != {}", args.len(), 0usize);
|
||||
Ok(Dynamic::from(do_nothing()))
|
||||
}
|
||||
|
||||
fn is_method_call(&self) -> bool { false }
|
||||
fn is_variadic(&self) -> bool { false }
|
||||
fn clone_boxed(&self) -> Box<dyn PluginFunction> { Box::new(Token()) }
|
||||
fn input_names(&self) -> Box<[&'static str]> {
|
||||
new_vec![].into_boxed_slice()
|
||||
#[inline(always)] fn is_method_call(&self) -> bool { false }
|
||||
#[inline(always)] fn is_variadic(&self) -> bool { false }
|
||||
#[inline(always)] fn clone_boxed(&self) -> Box<dyn PluginFunction> { Box::new(Token()) }
|
||||
#[inline(always)] fn param_names(&self) -> Box<[&'static str]> {
|
||||
new_vec!["()"].into_boxed_slice()
|
||||
}
|
||||
fn input_types(&self) -> Box<[TypeId]> {
|
||||
#[inline(always)] fn input_types(&self) -> Box<[TypeId]> {
|
||||
new_vec![].into_boxed_slice()
|
||||
}
|
||||
fn return_type(&self) -> &'static str {
|
||||
"()"
|
||||
}
|
||||
}
|
||||
pub fn token_callable() -> CallableFunction {
|
||||
#[inline(always)] pub fn token_callable() -> CallableFunction {
|
||||
Token().into()
|
||||
}
|
||||
pub fn token_input_names() -> Box<[&'static str]> {
|
||||
Token().input_names()
|
||||
#[inline(always)] pub fn token_param_names() -> Box<[&'static str]> {
|
||||
Token().param_names()
|
||||
}
|
||||
pub fn token_input_types() -> Box<[TypeId]> {
|
||||
#[inline(always)] pub fn token_input_types() -> Box<[TypeId]> {
|
||||
Token().input_types()
|
||||
}
|
||||
pub fn token_return_type() -> &'static str {
|
||||
Token().return_type()
|
||||
}
|
||||
#[allow(unused)]
|
||||
pub fn dynamic_result_fn() -> Result<Dynamic, Box<EvalAltResult> > {
|
||||
#[inline(always)] pub fn dynamic_result_fn() -> Result<Dynamic, Box<EvalAltResult> > {
|
||||
Ok(Dynamic::from(do_nothing()))
|
||||
}
|
||||
}
|
||||
@ -331,40 +325,35 @@ mod generate_tests {
|
||||
use super::*;
|
||||
struct Token();
|
||||
impl PluginFunction for Token {
|
||||
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
#[inline(always)]
|
||||
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> RhaiResult {
|
||||
debug_assert_eq!(args.len(), 1usize,
|
||||
"wrong arg count: {} != {}", args.len(), 1usize);
|
||||
let arg0 = mem::take(args[0usize]).cast::<usize>();
|
||||
Ok(Dynamic::from(do_something(arg0)))
|
||||
}
|
||||
|
||||
fn is_method_call(&self) -> bool { false }
|
||||
fn is_variadic(&self) -> bool { false }
|
||||
fn clone_boxed(&self) -> Box<dyn PluginFunction> { Box::new(Token()) }
|
||||
fn input_names(&self) -> Box<[&'static str]> {
|
||||
new_vec!["x: usize"].into_boxed_slice()
|
||||
#[inline(always)] fn is_method_call(&self) -> bool { false }
|
||||
#[inline(always)] fn is_variadic(&self) -> bool { false }
|
||||
#[inline(always)] fn clone_boxed(&self) -> Box<dyn PluginFunction> { Box::new(Token()) }
|
||||
#[inline(always)] fn param_names(&self) -> Box<[&'static str]> {
|
||||
new_vec!["x: usize", "()"].into_boxed_slice()
|
||||
}
|
||||
fn input_types(&self) -> Box<[TypeId]> {
|
||||
#[inline(always)] fn input_types(&self) -> Box<[TypeId]> {
|
||||
new_vec![TypeId::of::<usize>()].into_boxed_slice()
|
||||
}
|
||||
fn return_type(&self) -> &'static str {
|
||||
"()"
|
||||
}
|
||||
}
|
||||
pub fn token_callable() -> CallableFunction {
|
||||
#[inline(always)] pub fn token_callable() -> CallableFunction {
|
||||
Token().into()
|
||||
}
|
||||
pub fn token_input_names() -> Box<[&'static str]> {
|
||||
Token().input_names()
|
||||
#[inline(always)] pub fn token_param_names() -> Box<[&'static str]> {
|
||||
Token().param_names()
|
||||
}
|
||||
pub fn token_input_types() -> Box<[TypeId]> {
|
||||
#[inline(always)] pub fn token_input_types() -> Box<[TypeId]> {
|
||||
Token().input_types()
|
||||
}
|
||||
pub fn token_return_type() -> &'static str {
|
||||
Token().return_type()
|
||||
}
|
||||
#[allow(unused)]
|
||||
pub fn dynamic_result_fn(x: usize) -> Result<Dynamic, Box<EvalAltResult> > {
|
||||
#[inline(always)] pub fn dynamic_result_fn(x: usize) -> Result<Dynamic, Box<EvalAltResult> > {
|
||||
Ok(Dynamic::from(do_something(x)))
|
||||
}
|
||||
}
|
||||
@ -386,40 +375,35 @@ mod generate_tests {
|
||||
use super::*;
|
||||
struct Token();
|
||||
impl PluginFunction for Token {
|
||||
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
#[inline(always)]
|
||||
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> RhaiResult {
|
||||
debug_assert_eq!(args.len(), 1usize,
|
||||
"wrong arg count: {} != {}", args.len(), 1usize);
|
||||
let arg0 = mem::take(args[0usize]).cast::<usize>();
|
||||
Ok(Dynamic::from(do_something(context, arg0)))
|
||||
}
|
||||
|
||||
fn is_method_call(&self) -> bool { false }
|
||||
fn is_variadic(&self) -> bool { false }
|
||||
fn clone_boxed(&self) -> Box<dyn PluginFunction> { Box::new(Token()) }
|
||||
fn input_names(&self) -> Box<[&'static str]> {
|
||||
new_vec!["x: usize"].into_boxed_slice()
|
||||
#[inline(always)] fn is_method_call(&self) -> bool { false }
|
||||
#[inline(always)] fn is_variadic(&self) -> bool { false }
|
||||
#[inline(always)] fn clone_boxed(&self) -> Box<dyn PluginFunction> { Box::new(Token()) }
|
||||
#[inline(always)] fn param_names(&self) -> Box<[&'static str]> {
|
||||
new_vec!["x: usize", "()"].into_boxed_slice()
|
||||
}
|
||||
fn input_types(&self) -> Box<[TypeId]> {
|
||||
#[inline(always)] fn input_types(&self) -> Box<[TypeId]> {
|
||||
new_vec![TypeId::of::<usize>()].into_boxed_slice()
|
||||
}
|
||||
fn return_type(&self) -> &'static str {
|
||||
"()"
|
||||
}
|
||||
}
|
||||
pub fn token_callable() -> CallableFunction {
|
||||
#[inline(always)] pub fn token_callable() -> CallableFunction {
|
||||
Token().into()
|
||||
}
|
||||
pub fn token_input_names() -> Box<[&'static str]> {
|
||||
Token().input_names()
|
||||
#[inline(always)] pub fn token_param_names() -> Box<[&'static str]> {
|
||||
Token().param_names()
|
||||
}
|
||||
pub fn token_input_types() -> Box<[TypeId]> {
|
||||
#[inline(always)] pub fn token_input_types() -> Box<[TypeId]> {
|
||||
Token().input_types()
|
||||
}
|
||||
pub fn token_return_type() -> &'static str {
|
||||
Token().return_type()
|
||||
}
|
||||
#[allow(unused)]
|
||||
pub fn dynamic_result_fn(context: NativeCallContext, x: usize) -> Result<Dynamic, Box<EvalAltResult> > {
|
||||
#[inline(always)] pub fn dynamic_result_fn(context: NativeCallContext, x: usize) -> Result<Dynamic, Box<EvalAltResult> > {
|
||||
Ok(Dynamic::from(do_something(context, x)))
|
||||
}
|
||||
}
|
||||
@ -444,40 +428,35 @@ mod generate_tests {
|
||||
use super::*;
|
||||
struct Token();
|
||||
impl PluginFunction for Token {
|
||||
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
#[inline(always)]
|
||||
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> RhaiResult {
|
||||
debug_assert_eq!(args.len(), 0usize,
|
||||
"wrong arg count: {} != {}", args.len(), 0usize);
|
||||
Ok(return_dynamic())
|
||||
Ok(Dynamic::from(return_dynamic()))
|
||||
}
|
||||
|
||||
fn is_method_call(&self) -> bool { false }
|
||||
fn is_variadic(&self) -> bool { false }
|
||||
fn clone_boxed(&self) -> Box<dyn PluginFunction> { Box::new(Token()) }
|
||||
fn input_names(&self) -> Box<[&'static str]> {
|
||||
new_vec![].into_boxed_slice()
|
||||
#[inline(always)] fn is_method_call(&self) -> bool { false }
|
||||
#[inline(always)] fn is_variadic(&self) -> bool { false }
|
||||
#[inline(always)] fn clone_boxed(&self) -> Box<dyn PluginFunction> { Box::new(Token()) }
|
||||
#[inline(always)] fn param_names(&self) -> Box<[&'static str]> {
|
||||
new_vec!["rhai::Dynamic"].into_boxed_slice()
|
||||
}
|
||||
fn input_types(&self) -> Box<[TypeId]> {
|
||||
#[inline(always)] fn input_types(&self) -> Box<[TypeId]> {
|
||||
new_vec![].into_boxed_slice()
|
||||
}
|
||||
fn return_type(&self) -> &'static str {
|
||||
"rhai::Dynamic"
|
||||
}
|
||||
}
|
||||
pub fn token_callable() -> CallableFunction {
|
||||
#[inline(always)] pub fn token_callable() -> CallableFunction {
|
||||
Token().into()
|
||||
}
|
||||
pub fn token_input_names() -> Box<[&'static str]> {
|
||||
Token().input_names()
|
||||
#[inline(always)] pub fn token_param_names() -> Box<[&'static str]> {
|
||||
Token().param_names()
|
||||
}
|
||||
pub fn token_input_types() -> Box<[TypeId]> {
|
||||
#[inline(always)] pub fn token_input_types() -> Box<[TypeId]> {
|
||||
Token().input_types()
|
||||
}
|
||||
pub fn token_return_type() -> &'static str {
|
||||
Token().return_type()
|
||||
}
|
||||
#[allow(unused)]
|
||||
pub fn dynamic_result_fn() -> Result<Dynamic, Box<EvalAltResult> > {
|
||||
Ok(return_dynamic())
|
||||
#[inline(always)] pub fn dynamic_result_fn() -> Result<Dynamic, Box<EvalAltResult> > {
|
||||
Ok(Dynamic::from(return_dynamic()))
|
||||
}
|
||||
}
|
||||
};
|
||||
@ -494,25 +473,23 @@ mod generate_tests {
|
||||
|
||||
let expected_tokens = quote! {
|
||||
impl PluginFunction for TestStruct {
|
||||
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
#[inline(always)]
|
||||
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> RhaiResult {
|
||||
debug_assert_eq!(args.len(), 1usize,
|
||||
"wrong arg count: {} != {}", args.len(), 1usize);
|
||||
let arg0 = mem::take(args[0usize]).cast::<usize>();
|
||||
Ok(Dynamic::from(do_something(arg0)))
|
||||
}
|
||||
|
||||
fn is_method_call(&self) -> bool { false }
|
||||
fn is_variadic(&self) -> bool { false }
|
||||
fn clone_boxed(&self) -> Box<dyn PluginFunction> { Box::new(TestStruct()) }
|
||||
fn input_names(&self) -> Box<[&'static str]> {
|
||||
new_vec!["x: usize"].into_boxed_slice()
|
||||
#[inline(always)] fn is_method_call(&self) -> bool { false }
|
||||
#[inline(always)] fn is_variadic(&self) -> bool { false }
|
||||
#[inline(always)] fn clone_boxed(&self) -> Box<dyn PluginFunction> { Box::new(TestStruct()) }
|
||||
#[inline(always)] fn param_names(&self) -> Box<[&'static str]> {
|
||||
new_vec!["x: usize", "()"].into_boxed_slice()
|
||||
}
|
||||
fn input_types(&self) -> Box<[TypeId]> {
|
||||
#[inline(always)] fn input_types(&self) -> Box<[TypeId]> {
|
||||
new_vec![TypeId::of::<usize>()].into_boxed_slice()
|
||||
}
|
||||
fn return_type(&self) -> &'static str {
|
||||
"()"
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
@ -532,7 +509,8 @@ mod generate_tests {
|
||||
use super::*;
|
||||
struct Token();
|
||||
impl PluginFunction for Token {
|
||||
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
#[inline(always)]
|
||||
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> RhaiResult {
|
||||
debug_assert_eq!(args.len(), 2usize,
|
||||
"wrong arg count: {} != {}", args.len(), 2usize);
|
||||
let arg0 = mem::take(args[0usize]).cast::<usize>();
|
||||
@ -540,34 +518,28 @@ mod generate_tests {
|
||||
Ok(Dynamic::from(add_together(arg0, arg1)))
|
||||
}
|
||||
|
||||
fn is_method_call(&self) -> bool { false }
|
||||
fn is_variadic(&self) -> bool { false }
|
||||
fn clone_boxed(&self) -> Box<dyn PluginFunction> { Box::new(Token()) }
|
||||
fn input_names(&self) -> Box<[&'static str]> {
|
||||
new_vec!["x: usize", "y: usize"].into_boxed_slice()
|
||||
#[inline(always)] fn is_method_call(&self) -> bool { false }
|
||||
#[inline(always)] fn is_variadic(&self) -> bool { false }
|
||||
#[inline(always)] fn clone_boxed(&self) -> Box<dyn PluginFunction> { Box::new(Token()) }
|
||||
#[inline(always)] fn param_names(&self) -> Box<[&'static str]> {
|
||||
new_vec!["x: usize", "y: usize", "usize"].into_boxed_slice()
|
||||
}
|
||||
fn input_types(&self) -> Box<[TypeId]> {
|
||||
#[inline(always)] fn input_types(&self) -> Box<[TypeId]> {
|
||||
new_vec![TypeId::of::<usize>(),
|
||||
TypeId::of::<usize>()].into_boxed_slice()
|
||||
}
|
||||
fn return_type(&self) -> &'static str {
|
||||
"usize"
|
||||
}
|
||||
}
|
||||
pub fn token_callable() -> CallableFunction {
|
||||
#[inline(always)] pub fn token_callable() -> CallableFunction {
|
||||
Token().into()
|
||||
}
|
||||
pub fn token_input_names() -> Box<[&'static str]> {
|
||||
Token().input_names()
|
||||
#[inline(always)] pub fn token_param_names() -> Box<[&'static str]> {
|
||||
Token().param_names()
|
||||
}
|
||||
pub fn token_input_types() -> Box<[TypeId]> {
|
||||
#[inline(always)] pub fn token_input_types() -> Box<[TypeId]> {
|
||||
Token().input_types()
|
||||
}
|
||||
pub fn token_return_type() -> &'static str {
|
||||
Token().return_type()
|
||||
}
|
||||
#[allow(unused)]
|
||||
pub fn dynamic_result_fn(x: usize, y: usize) -> Result<Dynamic, Box<EvalAltResult> > {
|
||||
#[inline(always)] pub fn dynamic_result_fn(x: usize, y: usize) -> Result<Dynamic, Box<EvalAltResult> > {
|
||||
Ok(Dynamic::from(add_together(x, y)))
|
||||
}
|
||||
}
|
||||
@ -589,7 +561,8 @@ mod generate_tests {
|
||||
use super::*;
|
||||
struct Token();
|
||||
impl PluginFunction for Token {
|
||||
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
#[inline(always)]
|
||||
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> RhaiResult {
|
||||
debug_assert_eq!(args.len(), 2usize,
|
||||
"wrong arg count: {} != {}", args.len(), 2usize);
|
||||
if args[0usize].is_read_only() {
|
||||
@ -602,34 +575,28 @@ mod generate_tests {
|
||||
Ok(Dynamic::from(increment(arg0, arg1)))
|
||||
}
|
||||
|
||||
fn is_method_call(&self) -> bool { true }
|
||||
fn is_variadic(&self) -> bool { false }
|
||||
fn clone_boxed(&self) -> Box<dyn PluginFunction> { Box::new(Token()) }
|
||||
fn input_names(&self) -> Box<[&'static str]> {
|
||||
new_vec!["x: &mut usize", "y: usize"].into_boxed_slice()
|
||||
#[inline(always)] fn is_method_call(&self) -> bool { true }
|
||||
#[inline(always)] fn is_variadic(&self) -> bool { false }
|
||||
#[inline(always)] fn clone_boxed(&self) -> Box<dyn PluginFunction> { Box::new(Token()) }
|
||||
#[inline(always)] fn param_names(&self) -> Box<[&'static str]> {
|
||||
new_vec!["x: &mut usize", "y: usize", "()"].into_boxed_slice()
|
||||
}
|
||||
fn input_types(&self) -> Box<[TypeId]> {
|
||||
#[inline(always)] fn input_types(&self) -> Box<[TypeId]> {
|
||||
new_vec![TypeId::of::<usize>(),
|
||||
TypeId::of::<usize>()].into_boxed_slice()
|
||||
}
|
||||
fn return_type(&self) -> &'static str {
|
||||
"()"
|
||||
}
|
||||
}
|
||||
pub fn token_callable() -> CallableFunction {
|
||||
#[inline(always)] pub fn token_callable() -> CallableFunction {
|
||||
Token().into()
|
||||
}
|
||||
pub fn token_input_names() -> Box<[&'static str]> {
|
||||
Token().input_names()
|
||||
#[inline(always)] pub fn token_param_names() -> Box<[&'static str]> {
|
||||
Token().param_names()
|
||||
}
|
||||
pub fn token_input_types() -> Box<[TypeId]> {
|
||||
#[inline(always)] pub fn token_input_types() -> Box<[TypeId]> {
|
||||
Token().input_types()
|
||||
}
|
||||
pub fn token_return_type() -> &'static str {
|
||||
Token().return_type()
|
||||
}
|
||||
#[allow(unused)]
|
||||
pub fn dynamic_result_fn(x: &mut usize, y: usize) -> Result<Dynamic, Box<EvalAltResult> > {
|
||||
#[inline(always)] pub fn dynamic_result_fn(x: &mut usize, y: usize) -> Result<Dynamic, Box<EvalAltResult> > {
|
||||
Ok(Dynamic::from(increment(x, y)))
|
||||
}
|
||||
}
|
||||
@ -652,40 +619,35 @@ mod generate_tests {
|
||||
use super::*;
|
||||
struct Token();
|
||||
impl PluginFunction for Token {
|
||||
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
#[inline(always)]
|
||||
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> RhaiResult {
|
||||
debug_assert_eq!(args.len(), 1usize,
|
||||
"wrong arg count: {} != {}", args.len(), 1usize);
|
||||
let arg0 = mem::take(args[0usize]).take_immutable_string().unwrap();
|
||||
Ok(Dynamic::from(special_print(&arg0)))
|
||||
}
|
||||
|
||||
fn is_method_call(&self) -> bool { false }
|
||||
fn is_variadic(&self) -> bool { false }
|
||||
fn clone_boxed(&self) -> Box<dyn PluginFunction> { Box::new(Token()) }
|
||||
fn input_names(&self) -> Box<[&'static str]> {
|
||||
new_vec!["message: &str"].into_boxed_slice()
|
||||
#[inline(always)] fn is_method_call(&self) -> bool { false }
|
||||
#[inline(always)] fn is_variadic(&self) -> bool { false }
|
||||
#[inline(always)] fn clone_boxed(&self) -> Box<dyn PluginFunction> { Box::new(Token()) }
|
||||
#[inline(always)] fn param_names(&self) -> Box<[&'static str]> {
|
||||
new_vec!["message: &str", "()"].into_boxed_slice()
|
||||
}
|
||||
fn input_types(&self) -> Box<[TypeId]> {
|
||||
#[inline(always)] fn input_types(&self) -> Box<[TypeId]> {
|
||||
new_vec![TypeId::of::<ImmutableString>()].into_boxed_slice()
|
||||
}
|
||||
fn return_type(&self) -> &'static str {
|
||||
"()"
|
||||
}
|
||||
}
|
||||
pub fn token_callable() -> CallableFunction {
|
||||
#[inline(always)] pub fn token_callable() -> CallableFunction {
|
||||
Token().into()
|
||||
}
|
||||
pub fn token_input_names() -> Box<[&'static str]> {
|
||||
Token().input_names()
|
||||
#[inline(always)] pub fn token_param_names() -> Box<[&'static str]> {
|
||||
Token().param_names()
|
||||
}
|
||||
pub fn token_input_types() -> Box<[TypeId]> {
|
||||
#[inline(always)] pub fn token_input_types() -> Box<[TypeId]> {
|
||||
Token().input_types()
|
||||
}
|
||||
pub fn token_return_type() -> &'static str {
|
||||
Token().return_type()
|
||||
}
|
||||
#[allow(unused)]
|
||||
pub fn dynamic_result_fn(message: &str) -> Result<Dynamic, Box<EvalAltResult> > {
|
||||
#[inline(always)] pub fn dynamic_result_fn(message: &str) -> Result<Dynamic, Box<EvalAltResult> > {
|
||||
Ok(Dynamic::from(special_print(message)))
|
||||
}
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,4 +1,3 @@
|
||||
use rhai::module_resolvers::*;
|
||||
use rhai::plugin::*;
|
||||
use rhai::{Engine, EvalAltResult, Module, FLOAT};
|
||||
|
||||
@ -152,10 +151,8 @@ pub mod raw_returning_fn {
|
||||
y1: FLOAT,
|
||||
x2: FLOAT,
|
||||
y2: FLOAT,
|
||||
) -> Result<rhai::Dynamic, Box<rhai::EvalAltResult>> {
|
||||
Ok(Dynamic::from(
|
||||
((y2 - y1).abs().powf(2.0) + (x2 - x1).abs().powf(2.0)).sqrt(),
|
||||
))
|
||||
) -> Result<rhai::FLOAT, Box<rhai::EvalAltResult>> {
|
||||
Ok(((y2 - y1).abs().powf(2.0) + (x2 - x1).abs().powf(2.0)).sqrt())
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
use rhai::module_resolvers::*;
|
||||
use rhai::{Array, Engine, EvalAltResult, FLOAT, INT};
|
||||
|
||||
pub mod empty_module {
|
||||
|
||||
@ -1,5 +1,4 @@
|
||||
use rhai::module_resolvers::*;
|
||||
use rhai::{Array, Engine, EvalAltResult, FLOAT, INT};
|
||||
use rhai::{Array, Engine, EvalAltResult, FLOAT};
|
||||
|
||||
pub mod one_fn_module_nested_attr {
|
||||
use rhai::plugin::*;
|
||||
@ -10,8 +9,8 @@ pub mod one_fn_module_nested_attr {
|
||||
use rhai::FLOAT;
|
||||
|
||||
#[rhai_fn(return_raw)]
|
||||
pub fn get_mystic_number() -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
Ok(Dynamic::from(42.0 as FLOAT))
|
||||
pub fn get_mystic_number() -> Result<FLOAT, Box<EvalAltResult>> {
|
||||
Ok(42.0)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -39,8 +38,8 @@ pub mod one_fn_sub_module_nested_attr {
|
||||
use rhai::plugin::*;
|
||||
use rhai::FLOAT;
|
||||
#[rhai_fn(return_raw)]
|
||||
pub fn get_mystic_number() -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
Ok(Dynamic::from(42.0 as FLOAT))
|
||||
pub fn get_mystic_number() -> Result<FLOAT, Box<EvalAltResult>> {
|
||||
Ok(42.0)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
error: functions marked with 'return_raw' must return Result<Dynamic, Box<EvalAltResult>>
|
||||
error: functions marked with 'return_raw' must return Result<T, Box<EvalAltResult>>
|
||||
--> $DIR/export_fn_raw_noreturn.rs:9:13
|
||||
|
|
||||
9 | #[export_fn(return_raw)]
|
||||
|
||||
@ -1,10 +1,9 @@
|
||||
error[E0308]: mismatched types
|
||||
--> $DIR/export_fn_raw_return.rs:10:8
|
||||
error[E0599]: the method `map` exists for type `bool`, but its trait bounds were not satisfied
|
||||
--> $DIR/export_fn_raw_return.rs:10:33
|
||||
|
|
||||
9 | #[export_fn(return_raw)]
|
||||
| ------------------------ expected `Result<rhai::Dynamic, std::boxed::Box<rhai::EvalAltResult>>` because of return type
|
||||
10 | pub fn test_fn(input: Point) -> bool {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected enum `Result`, found `bool`
|
||||
| ^^^^ method cannot be called on `bool` due to unsatisfied trait bounds
|
||||
|
|
||||
= note: expected enum `Result<rhai::Dynamic, std::boxed::Box<rhai::EvalAltResult>>`
|
||||
found type `bool`
|
||||
= note: the following trait bounds were not satisfied:
|
||||
`bool: std::iter::Iterator`
|
||||
which is required by `&mut bool: std::iter::Iterator`
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
error: functions marked with 'return_raw' must return Result<Dynamic, Box<EvalAltResult>>
|
||||
error: functions marked with 'return_raw' must return Result<T, Box<EvalAltResult>>
|
||||
--> $DIR/export_mod_raw_noreturn.rs:11:11
|
||||
|
|
||||
11 | #[rhai_fn(return_raw)]
|
||||
|
||||
@ -1,11 +1,9 @@
|
||||
error[E0308]: mismatched types
|
||||
--> $DIR/export_mod_raw_return.rs:12:8
|
||||
error[E0599]: the method `map` exists for type `bool`, but its trait bounds were not satisfied
|
||||
--> $DIR/export_mod_raw_return.rs:12:33
|
||||
|
|
||||
9 | #[export_module]
|
||||
| ---------------- expected `Result<rhai::Dynamic, std::boxed::Box<rhai::EvalAltResult>>` because of return type
|
||||
...
|
||||
12 | pub fn test_fn(input: Point) -> bool {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected enum `Result`, found `bool`
|
||||
| ^^^^ method cannot be called on `bool` due to unsatisfied trait bounds
|
||||
|
|
||||
= note: expected enum `Result<rhai::Dynamic, std::boxed::Box<rhai::EvalAltResult>>`
|
||||
found type `bool`
|
||||
= note: the following trait bounds were not satisfied:
|
||||
`bool: std::iter::Iterator`
|
||||
which is required by `&mut bool: std::iter::Iterator`
|
||||
|
||||
@ -6,5 +6,5 @@ error[E0277]: the trait bound `NonClonable: Clone` is not satisfied
|
||||
|
|
||||
::: $WORKSPACE/src/dynamic.rs
|
||||
|
|
||||
| pub fn from<T: Variant + Clone>(value: T) -> Self {
|
||||
| pub fn from<T: Variant + Clone>(mut value: T) -> Self {
|
||||
| ----- required by this bound in `rhai::Dynamic::from`
|
||||
|
||||
@ -6,5 +6,5 @@ error[E0277]: the trait bound `NonClonable: Clone` is not satisfied
|
||||
|
|
||||
::: $WORKSPACE/src/dynamic.rs
|
||||
|
|
||||
| pub fn from<T: Variant + Clone>(value: T) -> Self {
|
||||
| pub fn from<T: Variant + Clone>(mut value: T) -> Self {
|
||||
| ----- required by this bound in `rhai::Dynamic::from`
|
||||
|
||||
23
src/ast.rs
23
src/ast.rs
@ -6,6 +6,7 @@ use crate::module::NamespaceRef;
|
||||
use crate::stdlib::{
|
||||
borrow::Cow,
|
||||
boxed::Box,
|
||||
collections::BTreeMap,
|
||||
fmt,
|
||||
hash::Hash,
|
||||
num::NonZeroUsize,
|
||||
@ -15,7 +16,6 @@ use crate::stdlib::{
|
||||
vec::Vec,
|
||||
};
|
||||
use crate::token::Token;
|
||||
use crate::utils::{HashableHashMap, StraightHasherBuilder};
|
||||
use crate::{
|
||||
Dynamic, FnNamespace, FnPtr, ImmutableString, Module, Position, Shared, StaticVec, INT,
|
||||
};
|
||||
@ -866,14 +866,7 @@ pub enum Stmt {
|
||||
/// `if` expr `{` stmt `}` `else` `{` stmt `}`
|
||||
If(Expr, Box<(StmtBlock, StmtBlock)>, Position),
|
||||
/// `switch` expr `{` literal or _ `=>` stmt `,` ... `}`
|
||||
Switch(
|
||||
Expr,
|
||||
Box<(
|
||||
HashableHashMap<u64, StmtBlock, StraightHasherBuilder>,
|
||||
StmtBlock,
|
||||
)>,
|
||||
Position,
|
||||
),
|
||||
Switch(Expr, Box<(BTreeMap<u64, StmtBlock>, StmtBlock)>, Position),
|
||||
/// `while` expr `{` stmt `}`
|
||||
While(Expr, Box<StmtBlock>, Position),
|
||||
/// `do` `{` stmt `}` `while`|`until` expr
|
||||
@ -1303,7 +1296,7 @@ pub struct OpAssignment {
|
||||
///
|
||||
/// Two separate hashes are pre-calculated because of the following pattern:
|
||||
///
|
||||
/// ```,ignore
|
||||
/// ```ignore
|
||||
/// func(a, b, c); // Native: func(a, b, c) - 3 parameters
|
||||
/// // Script: func(a, b, c) - 3 parameters
|
||||
///
|
||||
@ -1594,20 +1587,14 @@ impl Expr {
|
||||
|
||||
#[cfg(not(feature = "no_index"))]
|
||||
Self::Array(x, _) if self.is_constant() => {
|
||||
let mut arr = Array::with_capacity(crate::stdlib::cmp::max(
|
||||
crate::engine::TYPICAL_ARRAY_SIZE,
|
||||
x.len(),
|
||||
));
|
||||
let mut arr = Array::with_capacity(x.len());
|
||||
arr.extend(x.iter().map(|v| v.get_constant_value().unwrap()));
|
||||
Dynamic(Union::Array(Box::new(arr), AccessMode::ReadOnly))
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "no_object"))]
|
||||
Self::Map(x, _) if self.is_constant() => {
|
||||
let mut map = Map::with_capacity(crate::stdlib::cmp::max(
|
||||
crate::engine::TYPICAL_MAP_SIZE,
|
||||
x.len(),
|
||||
));
|
||||
let mut map = Map::new();
|
||||
map.extend(
|
||||
x.iter()
|
||||
.map(|(k, v)| (k.name.clone(), v.get_constant_value().unwrap())),
|
||||
|
||||
@ -61,6 +61,7 @@ fn main() {
|
||||
let mut engine = Engine::new();
|
||||
|
||||
#[cfg(not(feature = "no_module"))]
|
||||
#[cfg(not(feature = "no_std"))]
|
||||
{
|
||||
// Set a file module resolver without caching
|
||||
let mut resolver = rhai::module_resolvers::FileModuleResolver::new();
|
||||
|
||||
@ -812,8 +812,8 @@ impl Dynamic {
|
||||
/// A [`Vec<T>`][Vec] does not get automatically converted to an [`Array`], but will be a generic
|
||||
/// restricted trait object instead, because [`Vec<T>`][Vec] is not a supported standard type.
|
||||
///
|
||||
/// Similarly, passing in a [`HashMap<String, T>`][std::collections::HashMap] will not get a [`Map`]
|
||||
/// but a trait object.
|
||||
/// Similarly, passing in a [`HashMap<String, T>`][std::collections::HashMap] or
|
||||
/// [`BTreeMap<String, T>`][std::collections::BTreeMap] will not get a [`Map`] but a trait object.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
@ -833,9 +833,13 @@ impl Dynamic {
|
||||
/// assert_eq!(new_result.to_string(), "hello");
|
||||
/// ```
|
||||
#[inline(always)]
|
||||
pub fn from<T: Variant + Clone>(value: T) -> Self {
|
||||
pub fn from<T: Variant + Clone>(mut value: T) -> Self {
|
||||
// Coded this way in order to maximally leverage potentials for dead-code removal.
|
||||
|
||||
if TypeId::of::<T>() == TypeId::of::<Dynamic>() {
|
||||
return unsafe_try_cast::<_, Dynamic>(value).ok().unwrap();
|
||||
}
|
||||
|
||||
if TypeId::of::<T>() == TypeId::of::<INT>() {
|
||||
return <dyn Any>::downcast_ref::<INT>(&value)
|
||||
.unwrap()
|
||||
@ -884,46 +888,43 @@ impl Dynamic {
|
||||
return ().into();
|
||||
}
|
||||
|
||||
let mut boxed = Box::new(value);
|
||||
|
||||
boxed = match unsafe_cast_box::<_, Dynamic>(boxed) {
|
||||
Ok(d) => return *d,
|
||||
Err(val) => val,
|
||||
};
|
||||
boxed = match unsafe_cast_box::<_, String>(boxed) {
|
||||
Ok(s) => return (*s).into(),
|
||||
value = match unsafe_try_cast::<_, String>(value) {
|
||||
Ok(s) => return (s).into(),
|
||||
Err(val) => val,
|
||||
};
|
||||
#[cfg(not(feature = "no_index"))]
|
||||
{
|
||||
boxed = match unsafe_cast_box::<_, Array>(boxed) {
|
||||
Ok(array) => return (*array).into(),
|
||||
value = match unsafe_try_cast::<_, Array>(value) {
|
||||
Ok(array) => return (array).into(),
|
||||
Err(val) => val,
|
||||
};
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "no_object"))]
|
||||
{
|
||||
boxed = match unsafe_cast_box::<_, Map>(boxed) {
|
||||
Ok(map) => return (*map).into(),
|
||||
value = match unsafe_try_cast::<_, Map>(value) {
|
||||
Ok(map) => return (map).into(),
|
||||
Err(val) => val,
|
||||
}
|
||||
}
|
||||
|
||||
boxed = match unsafe_cast_box::<_, FnPtr>(boxed) {
|
||||
Ok(fn_ptr) => return (*fn_ptr).into(),
|
||||
value = match unsafe_try_cast::<_, FnPtr>(value) {
|
||||
Ok(fn_ptr) => return (fn_ptr).into(),
|
||||
Err(val) => val,
|
||||
};
|
||||
|
||||
#[cfg(not(feature = "no_std"))]
|
||||
{
|
||||
boxed = match unsafe_cast_box::<_, Instant>(boxed) {
|
||||
Ok(timestamp) => return (*timestamp).into(),
|
||||
value = match unsafe_try_cast::<_, Instant>(value) {
|
||||
Ok(timestamp) => return (timestamp).into(),
|
||||
Err(val) => val,
|
||||
}
|
||||
}
|
||||
|
||||
Self(Union::Variant(Box::new(boxed), AccessMode::ReadWrite))
|
||||
Self(Union::Variant(
|
||||
Box::new(Box::new(value)),
|
||||
AccessMode::ReadWrite,
|
||||
))
|
||||
}
|
||||
/// Turn the [`Dynamic`] value into a shared [`Dynamic`] value backed by an
|
||||
/// [`Rc`][std::rc::Rc]`<`[`RefCell`][std::cell::RefCell]`<`[`Dynamic`]`>>` or
|
||||
@ -986,12 +987,12 @@ impl Dynamic {
|
||||
}
|
||||
|
||||
if TypeId::of::<T>() == TypeId::of::<Dynamic>() {
|
||||
return unsafe_cast_box::<_, T>(Box::new(self)).ok().map(|v| *v);
|
||||
return unsafe_try_cast::<_, T>(self).ok();
|
||||
}
|
||||
|
||||
if TypeId::of::<T>() == TypeId::of::<INT>() {
|
||||
return match self.0 {
|
||||
Union::Int(value, _) => unsafe_try_cast(value),
|
||||
Union::Int(value, _) => unsafe_try_cast(value).ok(),
|
||||
_ => None,
|
||||
};
|
||||
}
|
||||
@ -999,7 +1000,7 @@ impl Dynamic {
|
||||
#[cfg(not(feature = "no_float"))]
|
||||
if TypeId::of::<T>() == TypeId::of::<FLOAT>() {
|
||||
return match self.0 {
|
||||
Union::Float(value, _) => unsafe_try_cast(*value),
|
||||
Union::Float(value, _) => unsafe_try_cast(*value).ok(),
|
||||
_ => None,
|
||||
};
|
||||
}
|
||||
@ -1007,35 +1008,35 @@ impl Dynamic {
|
||||
#[cfg(feature = "decimal")]
|
||||
if TypeId::of::<T>() == TypeId::of::<Decimal>() {
|
||||
return match self.0 {
|
||||
Union::Decimal(value, _) => unsafe_try_cast(*value),
|
||||
Union::Decimal(value, _) => unsafe_try_cast(*value).ok(),
|
||||
_ => None,
|
||||
};
|
||||
}
|
||||
|
||||
if TypeId::of::<T>() == TypeId::of::<bool>() {
|
||||
return match self.0 {
|
||||
Union::Bool(value, _) => unsafe_try_cast(value),
|
||||
Union::Bool(value, _) => unsafe_try_cast(value).ok(),
|
||||
_ => None,
|
||||
};
|
||||
}
|
||||
|
||||
if TypeId::of::<T>() == TypeId::of::<ImmutableString>() {
|
||||
return match self.0 {
|
||||
Union::Str(value, _) => unsafe_try_cast(value),
|
||||
Union::Str(value, _) => unsafe_try_cast(value).ok(),
|
||||
_ => None,
|
||||
};
|
||||
}
|
||||
|
||||
if TypeId::of::<T>() == TypeId::of::<String>() {
|
||||
return match self.0 {
|
||||
Union::Str(value, _) => unsafe_try_cast(value.into_owned()),
|
||||
Union::Str(value, _) => unsafe_try_cast(value.into_owned()).ok(),
|
||||
_ => None,
|
||||
};
|
||||
}
|
||||
|
||||
if TypeId::of::<T>() == TypeId::of::<char>() {
|
||||
return match self.0 {
|
||||
Union::Char(value, _) => unsafe_try_cast(value),
|
||||
Union::Char(value, _) => unsafe_try_cast(value).ok(),
|
||||
_ => None,
|
||||
};
|
||||
}
|
||||
@ -1073,7 +1074,7 @@ impl Dynamic {
|
||||
|
||||
if TypeId::of::<T>() == TypeId::of::<()>() {
|
||||
return match self.0 {
|
||||
Union::Unit(value, _) => unsafe_try_cast(value),
|
||||
Union::Unit(value, _) => unsafe_try_cast(value).ok(),
|
||||
_ => None,
|
||||
};
|
||||
}
|
||||
@ -1695,6 +1696,7 @@ impl<T: Variant + Clone> crate::stdlib::iter::FromIterator<T> for Dynamic {
|
||||
}
|
||||
}
|
||||
#[cfg(not(feature = "no_object"))]
|
||||
#[cfg(not(feature = "no_std"))]
|
||||
impl<K: Into<ImmutableString>, T: Variant + Clone> From<crate::stdlib::collections::HashMap<K, T>>
|
||||
for Dynamic
|
||||
{
|
||||
@ -1711,6 +1713,23 @@ impl<K: Into<ImmutableString>, T: Variant + Clone> From<crate::stdlib::collectio
|
||||
))
|
||||
}
|
||||
}
|
||||
#[cfg(not(feature = "no_object"))]
|
||||
impl<K: Into<ImmutableString>, T: Variant + Clone> From<crate::stdlib::collections::BTreeMap<K, T>>
|
||||
for Dynamic
|
||||
{
|
||||
#[inline(always)]
|
||||
fn from(value: crate::stdlib::collections::BTreeMap<K, T>) -> Self {
|
||||
Self(Union::Map(
|
||||
Box::new(
|
||||
value
|
||||
.into_iter()
|
||||
.map(|(k, v)| (k.into(), Dynamic::from(v)))
|
||||
.collect(),
|
||||
),
|
||||
AccessMode::ReadWrite,
|
||||
))
|
||||
}
|
||||
}
|
||||
impl From<FnPtr> for Dynamic {
|
||||
#[inline(always)]
|
||||
fn from(value: FnPtr) -> Self {
|
||||
|
||||
@ -14,7 +14,7 @@ use crate::stdlib::{
|
||||
any::{type_name, TypeId},
|
||||
borrow::Cow,
|
||||
boxed::Box,
|
||||
collections::{HashMap, HashSet},
|
||||
collections::{BTreeMap, BTreeSet},
|
||||
fmt, format,
|
||||
hash::{Hash, Hasher},
|
||||
num::{NonZeroU8, NonZeroUsize},
|
||||
@ -23,7 +23,7 @@ use crate::stdlib::{
|
||||
vec::Vec,
|
||||
};
|
||||
use crate::syntax::CustomSyntax;
|
||||
use crate::utils::{get_hasher, StraightHasherBuilder};
|
||||
use crate::utils::get_hasher;
|
||||
use crate::{
|
||||
Dynamic, EvalAltResult, FnPtr, ImmutableString, Module, Position, RhaiResult, Scope, Shared,
|
||||
StaticVec,
|
||||
@ -32,15 +32,9 @@ use crate::{
|
||||
#[cfg(not(feature = "no_index"))]
|
||||
use crate::{calc_fn_hash, stdlib::iter::empty, Array};
|
||||
|
||||
#[cfg(not(feature = "no_index"))]
|
||||
pub const TYPICAL_ARRAY_SIZE: usize = 8; // Small arrays are typical
|
||||
|
||||
#[cfg(not(feature = "no_object"))]
|
||||
use crate::Map;
|
||||
|
||||
#[cfg(not(feature = "no_object"))]
|
||||
pub const TYPICAL_MAP_SIZE: usize = 8; // Small maps are typical
|
||||
|
||||
pub type Precedence = NonZeroU8;
|
||||
|
||||
/// _(INTERNALS)_ A stack of imported [modules][Module].
|
||||
@ -501,7 +495,7 @@ pub struct FnResolutionCacheEntry {
|
||||
}
|
||||
|
||||
/// A function resolution cache.
|
||||
pub type FnResolutionCache = HashMap<u64, Option<FnResolutionCacheEntry>, StraightHasherBuilder>;
|
||||
pub type FnResolutionCache = BTreeMap<u64, Option<FnResolutionCacheEntry>>;
|
||||
|
||||
/// _(INTERNALS)_ A type that holds all the current states of the [`Engine`].
|
||||
/// Exported under the `internals` feature only.
|
||||
@ -540,9 +534,7 @@ impl State {
|
||||
/// Get a mutable reference to the current function resolution cache.
|
||||
pub fn fn_resolution_cache_mut(&mut self) -> &mut FnResolutionCache {
|
||||
if self.fn_resolution_caches.0.is_empty() {
|
||||
self.fn_resolution_caches
|
||||
.0
|
||||
.push(HashMap::with_capacity_and_hasher(64, StraightHasherBuilder));
|
||||
self.fn_resolution_caches.0.push(BTreeMap::new());
|
||||
}
|
||||
self.fn_resolution_caches.0.last_mut().unwrap()
|
||||
}
|
||||
@ -711,21 +703,21 @@ pub struct Engine {
|
||||
/// A collection of all modules loaded into the global namespace of the Engine.
|
||||
pub(crate) global_modules: StaticVec<Shared<Module>>,
|
||||
/// A collection of all sub-modules directly loaded into the Engine.
|
||||
pub(crate) global_sub_modules: HashMap<ImmutableString, Shared<Module>>,
|
||||
pub(crate) global_sub_modules: BTreeMap<ImmutableString, Shared<Module>>,
|
||||
|
||||
/// A module resolution service.
|
||||
#[cfg(not(feature = "no_module"))]
|
||||
pub(crate) module_resolver: Box<dyn crate::ModuleResolver>,
|
||||
|
||||
/// A hashmap mapping type names to pretty-print names.
|
||||
pub(crate) type_names: HashMap<String, String>,
|
||||
/// A map mapping type names to pretty-print names.
|
||||
pub(crate) type_names: BTreeMap<String, String>,
|
||||
|
||||
/// A hashset containing symbols to disable.
|
||||
pub(crate) disabled_symbols: HashSet<String>,
|
||||
/// A hashmap containing custom keywords and precedence to recognize.
|
||||
pub(crate) custom_keywords: HashMap<String, Option<Precedence>>,
|
||||
/// A set of symbols to disable.
|
||||
pub(crate) disabled_symbols: BTreeSet<String>,
|
||||
/// A map containing custom keywords and precedence to recognize.
|
||||
pub(crate) custom_keywords: BTreeMap<String, Option<Precedence>>,
|
||||
/// Custom syntax.
|
||||
pub(crate) custom_syntax: HashMap<ImmutableString, CustomSyntax>,
|
||||
pub(crate) custom_syntax: BTreeMap<ImmutableString, CustomSyntax>,
|
||||
/// Callback closure for resolving variable access.
|
||||
pub(crate) resolve_var: Option<OnVarCallback>,
|
||||
|
||||
@ -1047,12 +1039,6 @@ impl Engine {
|
||||
|
||||
let val = scope.get_mut_by_index(index);
|
||||
|
||||
// Check for data race - probably not necessary because the only place it should conflict is
|
||||
// in a method call when the object variable is also used as a parameter.
|
||||
// if cfg!(not(feature = "no_closure")) && val.is_locked() {
|
||||
// return EvalAltResult::ErrorDataRace(name.into(), *pos).into();
|
||||
// }
|
||||
|
||||
Ok((val.into(), *pos))
|
||||
}
|
||||
|
||||
@ -1688,8 +1674,7 @@ impl Engine {
|
||||
|
||||
#[cfg(not(feature = "no_index"))]
|
||||
Expr::Array(x, _) => {
|
||||
let mut arr =
|
||||
Array::with_capacity(crate::stdlib::cmp::max(TYPICAL_ARRAY_SIZE, x.len()));
|
||||
let mut arr = Array::with_capacity(x.len());
|
||||
for item in x.as_ref() {
|
||||
arr.push(
|
||||
self.eval_expr(scope, mods, state, lib, this_ptr, item, level)?
|
||||
@ -1701,8 +1686,7 @@ impl Engine {
|
||||
|
||||
#[cfg(not(feature = "no_object"))]
|
||||
Expr::Map(x, _) => {
|
||||
let mut map =
|
||||
Map::with_capacity(crate::stdlib::cmp::max(TYPICAL_MAP_SIZE, x.len()));
|
||||
let mut map = Map::new();
|
||||
for (Ident { name: key, .. }, expr) in x.as_ref() {
|
||||
map.insert(
|
||||
key.clone(),
|
||||
|
||||
@ -880,7 +880,7 @@ impl Engine {
|
||||
#[cfg(not(feature = "no_module"))]
|
||||
pub fn register_static_module(&mut self, name: &str, module: Shared<Module>) -> &mut Self {
|
||||
fn register_static_module_raw(
|
||||
root: &mut crate::stdlib::collections::HashMap<crate::ImmutableString, Shared<Module>>,
|
||||
root: &mut crate::stdlib::collections::BTreeMap<crate::ImmutableString, Shared<Module>>,
|
||||
name: &str,
|
||||
module: Shared<Module>,
|
||||
) {
|
||||
@ -1012,14 +1012,14 @@ impl Engine {
|
||||
ast::{ASTNode, Expr, Stmt},
|
||||
fn_native::shared_take_or_clone,
|
||||
module::resolvers::StaticModuleResolver,
|
||||
stdlib::collections::HashSet,
|
||||
stdlib::collections::BTreeSet,
|
||||
ImmutableString,
|
||||
};
|
||||
|
||||
fn collect_imports(
|
||||
ast: &AST,
|
||||
resolver: &StaticModuleResolver,
|
||||
imports: &mut HashSet<ImmutableString>,
|
||||
imports: &mut BTreeSet<ImmutableString>,
|
||||
) {
|
||||
ast.walk(&mut |path| match path.last().unwrap() {
|
||||
// Collect all `import` statements with a string constant path
|
||||
@ -1035,7 +1035,7 @@ impl Engine {
|
||||
|
||||
let mut resolver = StaticModuleResolver::new();
|
||||
let mut ast = self.compile_scripts_with_scope(scope, &[script])?;
|
||||
let mut imports = HashSet::<ImmutableString>::new();
|
||||
let mut imports = Default::default();
|
||||
|
||||
collect_imports(&ast, &mut resolver, &mut imports);
|
||||
|
||||
@ -1885,9 +1885,8 @@ impl Engine {
|
||||
.ok_or_else(|| EvalAltResult::ErrorFunctionNotFound(name.into(), Position::NONE))?;
|
||||
|
||||
// Check for data race.
|
||||
if cfg!(not(feature = "no_closure")) {
|
||||
crate::fn_call::ensure_no_data_race(name, args, false)?;
|
||||
}
|
||||
#[cfg(not(feature = "no_closure"))]
|
||||
crate::fn_call::ensure_no_data_race(name, args, false)?;
|
||||
|
||||
self.call_script_fn(
|
||||
scope,
|
||||
|
||||
@ -109,7 +109,7 @@ pub fn get_builtin_binary_op_fn(
|
||||
return Some(|_, args| {
|
||||
let x = args[0].$xx().unwrap() as $base;
|
||||
let y = args[1].$yy().unwrap() as $base;
|
||||
$func(x, y)
|
||||
$func(x, y).map(Into::<Dynamic>::into)
|
||||
})
|
||||
};
|
||||
(from $base:ty => $xx:ident $op:tt $yy:ident) => {
|
||||
@ -130,7 +130,7 @@ pub fn get_builtin_binary_op_fn(
|
||||
return Some(|_, args| {
|
||||
let x = <$base>::from(args[0].$xx().unwrap());
|
||||
let y = <$base>::from(args[1].$yy().unwrap());
|
||||
$func(x, y)
|
||||
$func(x, y).map(Into::<Dynamic>::into)
|
||||
})
|
||||
};
|
||||
}
|
||||
|
||||
@ -102,21 +102,18 @@ pub fn ensure_no_data_race(
|
||||
args: &FnCallArgs,
|
||||
is_ref: bool,
|
||||
) -> Result<(), Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "no_closure")) {
|
||||
let skip = if is_ref { 1 } else { 0 };
|
||||
|
||||
if let Some((n, _)) = args
|
||||
.iter()
|
||||
.skip(skip)
|
||||
.enumerate()
|
||||
.find(|(_, a)| a.is_locked())
|
||||
{
|
||||
return EvalAltResult::ErrorDataRace(
|
||||
format!("argument #{} of function '{}'", n + 1 + skip, fn_name),
|
||||
Position::NONE,
|
||||
)
|
||||
.into();
|
||||
}
|
||||
#[cfg(not(feature = "no_closure"))]
|
||||
if let Some((n, _)) = args
|
||||
.iter()
|
||||
.enumerate()
|
||||
.skip(if is_ref { 1 } else { 0 })
|
||||
.find(|(_, a)| a.is_locked())
|
||||
{
|
||||
return EvalAltResult::ErrorDataRace(
|
||||
format!("argument #{} of function '{}'", n + 1, fn_name),
|
||||
Position::NONE,
|
||||
)
|
||||
.into();
|
||||
}
|
||||
|
||||
Ok(())
|
||||
@ -636,9 +633,8 @@ impl Engine {
|
||||
_level: usize,
|
||||
) -> Result<(Dynamic, bool), Box<EvalAltResult>> {
|
||||
// Check for data race.
|
||||
if cfg!(not(feature = "no_closure")) {
|
||||
ensure_no_data_race(fn_name, args, is_ref)?;
|
||||
}
|
||||
#[cfg(not(feature = "no_closure"))]
|
||||
ensure_no_data_race(fn_name, args, is_ref)?;
|
||||
|
||||
// These may be redirected from method style calls.
|
||||
match fn_name {
|
||||
@ -1259,7 +1255,10 @@ impl Engine {
|
||||
arg_values = args_expr
|
||||
.iter()
|
||||
.skip(1)
|
||||
.map(|expr| self.eval_expr(scope, mods, state, lib, this_ptr, expr, level))
|
||||
.map(|expr| {
|
||||
self.eval_expr(scope, mods, state, lib, this_ptr, expr, level)
|
||||
.map(Dynamic::flatten)
|
||||
})
|
||||
.collect::<Result<_, _>>()?;
|
||||
|
||||
let (mut target, pos) =
|
||||
@ -1285,7 +1284,10 @@ impl Engine {
|
||||
// func(..., ...)
|
||||
arg_values = args_expr
|
||||
.iter()
|
||||
.map(|expr| self.eval_expr(scope, mods, state, lib, this_ptr, expr, level))
|
||||
.map(|expr| {
|
||||
self.eval_expr(scope, mods, state, lib, this_ptr, expr, level)
|
||||
.map(Dynamic::flatten)
|
||||
})
|
||||
.collect::<Result<_, _>>()?;
|
||||
|
||||
args = curry.iter_mut().chain(arg_values.iter_mut()).collect();
|
||||
@ -1340,6 +1342,7 @@ impl Engine {
|
||||
Ok(Default::default())
|
||||
} else {
|
||||
self.eval_expr(scope, mods, state, lib, this_ptr, expr, level)
|
||||
.map(Dynamic::flatten)
|
||||
}
|
||||
})
|
||||
.collect::<Result<_, _>>()?;
|
||||
@ -1364,7 +1367,10 @@ impl Engine {
|
||||
// func(..., ...) or func(mod::x, ...)
|
||||
arg_values = args_expr
|
||||
.iter()
|
||||
.map(|expr| self.eval_expr(scope, mods, state, lib, this_ptr, expr, level))
|
||||
.map(|expr| {
|
||||
self.eval_expr(scope, mods, state, lib, this_ptr, expr, level)
|
||||
.map(Dynamic::flatten)
|
||||
})
|
||||
.collect::<Result<_, _>>()?;
|
||||
|
||||
args = arg_values.iter_mut().collect();
|
||||
|
||||
@ -98,10 +98,7 @@ macro_rules! def_anonymous_fn {
|
||||
#[inline(always)]
|
||||
fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output {
|
||||
let fn_name = entry_point.to_string();
|
||||
|
||||
Box::new(move |$($par: $par),*| {
|
||||
self.call_fn(&mut Scope::new(), &ast, &fn_name, ($($par,)*))
|
||||
})
|
||||
Box::new(move |$($par),*| self.call_fn(&mut Scope::new(), &ast, &fn_name, ($($par,)*)))
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
|
||||
@ -11,7 +11,7 @@
|
||||
//!
|
||||
//! ## Contents of `my_script.rhai`
|
||||
//!
|
||||
//! ```,ignore
|
||||
//! ```ignore
|
||||
//! /// Brute force factorial function
|
||||
//! fn factorial(x) {
|
||||
//! if x == 1 { return 1; }
|
||||
@ -24,7 +24,7 @@
|
||||
//!
|
||||
//! ## The Rust part
|
||||
//!
|
||||
//! ```,no_run
|
||||
//! ```no_run
|
||||
//! use rhai::{Engine, EvalAltResult};
|
||||
//!
|
||||
//! fn main() -> Result<(), Box<EvalAltResult>>
|
||||
@ -88,7 +88,7 @@ mod token;
|
||||
mod r#unsafe;
|
||||
mod utils;
|
||||
|
||||
type RhaiResult = Result<Dynamic, stdlib::boxed::Box<EvalAltResult>>;
|
||||
type RhaiResult = stdlib::result::Result<Dynamic, stdlib::boxed::Box<EvalAltResult>>;
|
||||
|
||||
/// The system integer type. It is defined as [`i64`].
|
||||
///
|
||||
@ -164,7 +164,7 @@ pub type Array = stdlib::vec::Vec<Dynamic>;
|
||||
///
|
||||
/// Not available under `no_object`.
|
||||
#[cfg(not(feature = "no_object"))]
|
||||
pub type Map = stdlib::collections::HashMap<ImmutableString, Dynamic>;
|
||||
pub type Map = stdlib::collections::BTreeMap<ImmutableString, Dynamic>;
|
||||
|
||||
#[cfg(not(feature = "no_module"))]
|
||||
pub use module::ModuleResolver;
|
||||
|
||||
@ -7,7 +7,7 @@ use crate::fn_register::RegisterNativeFunction;
|
||||
use crate::stdlib::{
|
||||
any::TypeId,
|
||||
boxed::Box,
|
||||
collections::HashMap,
|
||||
collections::BTreeMap,
|
||||
fmt, format,
|
||||
iter::empty,
|
||||
num::NonZeroUsize,
|
||||
@ -16,7 +16,6 @@ use crate::stdlib::{
|
||||
vec::Vec,
|
||||
};
|
||||
use crate::token::Token;
|
||||
use crate::utils::StraightHasherBuilder;
|
||||
use crate::{
|
||||
calc_fn_hash, calc_fn_params_hash, combine_hashes, Dynamic, EvalAltResult, ImmutableString,
|
||||
NativeCallContext, Position, Shared, StaticVec,
|
||||
@ -130,20 +129,20 @@ pub struct Module {
|
||||
/// ID identifying the module.
|
||||
id: Option<ImmutableString>,
|
||||
/// Sub-modules.
|
||||
modules: HashMap<ImmutableString, Shared<Module>>,
|
||||
modules: BTreeMap<ImmutableString, Shared<Module>>,
|
||||
/// [`Module`] variables.
|
||||
variables: HashMap<ImmutableString, Dynamic>,
|
||||
variables: BTreeMap<ImmutableString, Dynamic>,
|
||||
/// Flattened collection of all [`Module`] variables, including those in sub-modules.
|
||||
all_variables: HashMap<u64, Dynamic, StraightHasherBuilder>,
|
||||
all_variables: BTreeMap<u64, Dynamic>,
|
||||
/// External Rust functions.
|
||||
functions: HashMap<u64, Box<FuncInfo>, StraightHasherBuilder>,
|
||||
functions: BTreeMap<u64, Box<FuncInfo>>,
|
||||
/// Flattened collection of all external Rust functions, native or scripted.
|
||||
/// including those in sub-modules.
|
||||
all_functions: HashMap<u64, CallableFunction, StraightHasherBuilder>,
|
||||
all_functions: BTreeMap<u64, CallableFunction>,
|
||||
/// Iterator functions, keyed by the type producing the iterator.
|
||||
type_iterators: HashMap<TypeId, IteratorFn>,
|
||||
type_iterators: BTreeMap<TypeId, IteratorFn>,
|
||||
/// Flattened collection of iterator functions, including those in sub-modules.
|
||||
all_type_iterators: HashMap<TypeId, IteratorFn>,
|
||||
all_type_iterators: BTreeMap<TypeId, IteratorFn>,
|
||||
/// Is the [`Module`] indexed?
|
||||
indexed: bool,
|
||||
/// Does the [`Module`] contain indexed functions that have been exposed to the global namespace?
|
||||
@ -158,8 +157,8 @@ impl Default for Module {
|
||||
modules: Default::default(),
|
||||
variables: Default::default(),
|
||||
all_variables: Default::default(),
|
||||
functions: HashMap::with_capacity_and_hasher(64, StraightHasherBuilder),
|
||||
all_functions: HashMap::with_capacity_and_hasher(256, StraightHasherBuilder),
|
||||
functions: Default::default(),
|
||||
all_functions: Default::default(),
|
||||
type_iterators: Default::default(),
|
||||
all_type_iterators: Default::default(),
|
||||
indexed: false,
|
||||
@ -270,25 +269,6 @@ impl Module {
|
||||
Default::default()
|
||||
}
|
||||
|
||||
/// Create a new [`Module`] with a specified capacity for native Rust functions.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```
|
||||
/// use rhai::Module;
|
||||
///
|
||||
/// let mut module = Module::new();
|
||||
/// module.set_var("answer", 42_i64);
|
||||
/// assert_eq!(module.get_var_value::<i64>("answer").unwrap(), 42);
|
||||
/// ```
|
||||
#[inline(always)]
|
||||
pub fn new_with_capacity(capacity: usize) -> Self {
|
||||
Self {
|
||||
functions: HashMap::with_capacity_and_hasher(capacity, StraightHasherBuilder),
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the ID of the [`Module`], if any.
|
||||
///
|
||||
/// # Example
|
||||
@ -520,7 +500,7 @@ impl Module {
|
||||
.map(|f| f.func.get_fn_def())
|
||||
}
|
||||
|
||||
/// Get a mutable reference to the underlying [`HashMap`] of sub-modules.
|
||||
/// Get a mutable reference to the underlying [`BTreeMap`] of sub-modules.
|
||||
///
|
||||
/// # WARNING
|
||||
///
|
||||
@ -528,7 +508,7 @@ impl Module {
|
||||
/// Thus the [`Module`] is automatically set to be non-indexed.
|
||||
#[cfg(not(feature = "no_module"))]
|
||||
#[inline(always)]
|
||||
pub(crate) fn sub_modules_mut(&mut self) -> &mut HashMap<ImmutableString, Shared<Module>> {
|
||||
pub(crate) fn sub_modules_mut(&mut self) -> &mut BTreeMap<ImmutableString, Shared<Module>> {
|
||||
// We must assume that the user has changed the sub-modules
|
||||
// (otherwise why take a mutable reference?)
|
||||
self.all_functions.clear();
|
||||
@ -1235,13 +1215,16 @@ impl Module {
|
||||
&mut self,
|
||||
filter: impl Fn(FnNamespace, FnAccess, &str, usize) -> bool,
|
||||
) -> &mut Self {
|
||||
self.functions.retain(|_, f| {
|
||||
if f.func.is_script() {
|
||||
filter(f.namespace, f.access, f.name.as_str(), f.params)
|
||||
} else {
|
||||
false
|
||||
}
|
||||
});
|
||||
self.functions = crate::stdlib::mem::take(&mut self.functions)
|
||||
.into_iter()
|
||||
.filter(|(_, f)| {
|
||||
if f.func.is_script() {
|
||||
filter(f.namespace, f.access, f.name.as_str(), f.params)
|
||||
} else {
|
||||
false
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
|
||||
self.all_functions.clear();
|
||||
self.all_variables.clear();
|
||||
@ -1460,9 +1443,9 @@ impl Module {
|
||||
fn index_module<'a>(
|
||||
module: &'a Module,
|
||||
path: &mut Vec<&'a str>,
|
||||
variables: &mut HashMap<u64, Dynamic, StraightHasherBuilder>,
|
||||
functions: &mut HashMap<u64, CallableFunction, StraightHasherBuilder>,
|
||||
type_iterators: &mut HashMap<TypeId, IteratorFn>,
|
||||
variables: &mut BTreeMap<u64, Dynamic>,
|
||||
functions: &mut BTreeMap<u64, CallableFunction>,
|
||||
type_iterators: &mut BTreeMap<TypeId, IteratorFn>,
|
||||
) -> bool {
|
||||
let mut contains_indexed_global_functions = false;
|
||||
|
||||
@ -1518,9 +1501,9 @@ impl Module {
|
||||
|
||||
if !self.indexed {
|
||||
let mut path = Vec::with_capacity(4);
|
||||
let mut variables = HashMap::with_capacity_and_hasher(16, StraightHasherBuilder);
|
||||
let mut functions = HashMap::with_capacity_and_hasher(256, StraightHasherBuilder);
|
||||
let mut type_iterators = HashMap::with_capacity(16);
|
||||
let mut variables = Default::default();
|
||||
let mut functions = Default::default();
|
||||
let mut type_iterators = Default::default();
|
||||
|
||||
path.push("root");
|
||||
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
use crate::stdlib::{
|
||||
boxed::Box,
|
||||
collections::HashMap,
|
||||
collections::BTreeMap,
|
||||
io::Error as IoError,
|
||||
path::{Path, PathBuf},
|
||||
string::String,
|
||||
@ -44,9 +44,9 @@ pub struct FileModuleResolver {
|
||||
cache_enabled: bool,
|
||||
|
||||
#[cfg(not(feature = "sync"))]
|
||||
cache: crate::stdlib::cell::RefCell<HashMap<PathBuf, Shared<Module>>>,
|
||||
cache: crate::stdlib::cell::RefCell<BTreeMap<PathBuf, Shared<Module>>>,
|
||||
#[cfg(feature = "sync")]
|
||||
cache: crate::stdlib::sync::RwLock<HashMap<PathBuf, Shared<Module>>>,
|
||||
cache: crate::stdlib::sync::RwLock<BTreeMap<PathBuf, Shared<Module>>>,
|
||||
}
|
||||
|
||||
impl Default for FileModuleResolver {
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
use crate::stdlib::{boxed::Box, collections::HashMap, ops::AddAssign, string::String};
|
||||
use crate::stdlib::{boxed::Box, collections::BTreeMap, ops::AddAssign, string::String};
|
||||
use crate::{Engine, EvalAltResult, Module, ModuleResolver, Position, Shared};
|
||||
|
||||
/// A static [module][Module] resolution service that serves [modules][Module] added into it.
|
||||
@ -19,7 +19,7 @@ use crate::{Engine, EvalAltResult, Module, ModuleResolver, Position, Shared};
|
||||
/// engine.set_module_resolver(resolver);
|
||||
/// ```
|
||||
#[derive(Debug, Clone, Default)]
|
||||
pub struct StaticModuleResolver(HashMap<String, Shared<Module>>);
|
||||
pub struct StaticModuleResolver(BTreeMap<String, Shared<Module>>);
|
||||
|
||||
impl StaticModuleResolver {
|
||||
/// Create a new [`StaticModuleResolver`].
|
||||
|
||||
@ -24,91 +24,91 @@ macro_rules! gen_arithmetic_functions {
|
||||
#[export_module]
|
||||
pub mod functions {
|
||||
#[rhai_fn(name = "+", return_raw)]
|
||||
pub fn add(x: $arg_type, y: $arg_type) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn add(x: $arg_type, y: $arg_type) -> Result<$arg_type, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) {
|
||||
x.checked_add(y).ok_or_else(|| make_err(format!("Addition overflow: {} + {}", x, y))).map(Dynamic::from)
|
||||
x.checked_add(y).ok_or_else(|| make_err(format!("Addition overflow: {} + {}", x, y)))
|
||||
} else {
|
||||
Ok(Dynamic::from(x + y))
|
||||
Ok(x + y)
|
||||
}
|
||||
}
|
||||
#[rhai_fn(name = "-", return_raw)]
|
||||
pub fn subtract(x: $arg_type, y: $arg_type) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn subtract(x: $arg_type, y: $arg_type) -> Result<$arg_type, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) {
|
||||
x.checked_sub(y).ok_or_else(|| make_err(format!("Subtraction overflow: {} - {}", x, y))).map(Dynamic::from)
|
||||
x.checked_sub(y).ok_or_else(|| make_err(format!("Subtraction overflow: {} - {}", x, y)))
|
||||
} else {
|
||||
Ok(Dynamic::from(x - y))
|
||||
Ok(x - y)
|
||||
}
|
||||
}
|
||||
#[rhai_fn(name = "*", return_raw)]
|
||||
pub fn multiply(x: $arg_type, y: $arg_type) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn multiply(x: $arg_type, y: $arg_type) -> Result<$arg_type, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) {
|
||||
x.checked_mul(y).ok_or_else(|| make_err(format!("Multiplication overflow: {} * {}", x, y))).map(Dynamic::from)
|
||||
x.checked_mul(y).ok_or_else(|| make_err(format!("Multiplication overflow: {} * {}", x, y)))
|
||||
} else {
|
||||
Ok(Dynamic::from(x * y))
|
||||
Ok(x * y)
|
||||
}
|
||||
}
|
||||
#[rhai_fn(name = "/", return_raw)]
|
||||
pub fn divide(x: $arg_type, y: $arg_type) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn divide(x: $arg_type, y: $arg_type) -> Result<$arg_type, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) {
|
||||
// Detect division by zero
|
||||
if y == 0 {
|
||||
Err(make_err(format!("Division by zero: {} / {}", x, y)))
|
||||
} else {
|
||||
x.checked_div(y).ok_or_else(|| make_err(format!("Division overflow: {} / {}", x, y))).map(Dynamic::from)
|
||||
x.checked_div(y).ok_or_else(|| make_err(format!("Division overflow: {} / {}", x, y)))
|
||||
}
|
||||
} else {
|
||||
Ok(Dynamic::from(x / y))
|
||||
Ok(x / y)
|
||||
}
|
||||
}
|
||||
#[rhai_fn(name = "%", return_raw)]
|
||||
pub fn modulo(x: $arg_type, y: $arg_type) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn modulo(x: $arg_type, y: $arg_type) -> Result<$arg_type, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) {
|
||||
x.checked_rem(y).ok_or_else(|| make_err(format!("Modulo division by zero or overflow: {} % {}", x, y))).map(Dynamic::from)
|
||||
x.checked_rem(y).ok_or_else(|| make_err(format!("Modulo division by zero or overflow: {} % {}", x, y)))
|
||||
} else {
|
||||
Ok(Dynamic::from(x % y))
|
||||
Ok(x % y)
|
||||
}
|
||||
}
|
||||
#[rhai_fn(name = "**", return_raw)]
|
||||
pub fn power(x: INT, y: INT) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn power(x: $arg_type, y: INT) -> Result<$arg_type, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) {
|
||||
if cfg!(not(feature = "only_i32")) && y > (u32::MAX as INT) {
|
||||
Err(make_err(format!("Integer raised to too large an index: {} ~ {}", x, y)))
|
||||
} else if y < 0 {
|
||||
Err(make_err(format!("Integer raised to a negative index: {} ~ {}", x, y)))
|
||||
} else {
|
||||
x.checked_pow(y as u32).ok_or_else(|| make_err(format!("Power overflow: {} ~ {}", x, y))).map(Dynamic::from)
|
||||
x.checked_pow(y as u32).ok_or_else(|| make_err(format!("Power overflow: {} ~ {}", x, y)))
|
||||
}
|
||||
} else {
|
||||
Ok(Dynamic::from(x.pow(y as u32)))
|
||||
Ok(x.pow(y as u32))
|
||||
}
|
||||
}
|
||||
|
||||
#[rhai_fn(name = "<<", return_raw)]
|
||||
pub fn shift_left(x: $arg_type, y: INT) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn shift_left(x: $arg_type, y: INT) -> Result<$arg_type, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) {
|
||||
if cfg!(not(feature = "only_i32")) && y > (u32::MAX as INT) {
|
||||
Err(make_err(format!("Left-shift by too many bits: {} << {}", x, y)))
|
||||
} else if y < 0 {
|
||||
Err(make_err(format!("Left-shift by a negative number: {} << {}", x, y)))
|
||||
} else {
|
||||
x.checked_shl(y as u32).ok_or_else(|| make_err(format!("Left-shift by too many bits: {} << {}", x, y))).map(Dynamic::from)
|
||||
x.checked_shl(y as u32).ok_or_else(|| make_err(format!("Left-shift by too many bits: {} << {}", x, y)))
|
||||
}
|
||||
} else {
|
||||
Ok(Dynamic::from(x << y))
|
||||
Ok(x << y)
|
||||
}
|
||||
}
|
||||
#[rhai_fn(name = ">>", return_raw)]
|
||||
pub fn shift_right(x: $arg_type, y: INT) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn shift_right(x: $arg_type, y: INT) -> Result<$arg_type, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) {
|
||||
if cfg!(not(feature = "only_i32")) && y > (u32::MAX as INT) {
|
||||
Err(make_err(format!("Right-shift by too many bits: {} >> {}", x, y)))
|
||||
} else if y < 0 {
|
||||
Err(make_err(format!("Right-shift by a negative number: {} >> {}", x, y)))
|
||||
} else {
|
||||
x.checked_shr(y as u32).ok_or_else(|| make_err(format!("Right-shift by too many bits: {} >> {}", x, y))).map(Dynamic::from)
|
||||
x.checked_shr(y as u32).ok_or_else(|| make_err(format!("Right-shift by too many bits: {} >> {}", x, y)))
|
||||
}
|
||||
} else {
|
||||
Ok(Dynamic::from(x >> y))
|
||||
Ok(x >> y)
|
||||
}
|
||||
}
|
||||
#[rhai_fn(name = "&")]
|
||||
@ -136,11 +136,11 @@ macro_rules! gen_signed_functions {
|
||||
#[export_module]
|
||||
pub mod functions {
|
||||
#[rhai_fn(name = "-", return_raw)]
|
||||
pub fn neg(x: $arg_type) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn neg(x: $arg_type) -> Result<$arg_type, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) {
|
||||
x.checked_neg().ok_or_else(|| make_err(format!("Negation overflow: -{}", x))).map(Dynamic::from)
|
||||
x.checked_neg().ok_or_else(|| make_err(format!("Negation overflow: -{}", x)))
|
||||
} else {
|
||||
Ok(Dynamic::from(-x))
|
||||
Ok(-x)
|
||||
}
|
||||
}
|
||||
#[rhai_fn(name = "+")]
|
||||
@ -148,11 +148,11 @@ macro_rules! gen_signed_functions {
|
||||
x
|
||||
}
|
||||
#[rhai_fn(return_raw)]
|
||||
pub fn abs(x: $arg_type) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn abs(x: $arg_type) -> Result<$arg_type, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) {
|
||||
x.checked_abs().ok_or_else(|| make_err(format!("Negation overflow: -{}", x))).map(Dynamic::from)
|
||||
x.checked_abs().ok_or_else(|| make_err(format!("Negation overflow: -{}", x)))
|
||||
} else {
|
||||
Ok(Dynamic::from(x.abs()))
|
||||
Ok(x.abs())
|
||||
}
|
||||
}
|
||||
pub fn sign(x: $arg_type) -> INT {
|
||||
@ -318,14 +318,14 @@ mod f32_functions {
|
||||
}
|
||||
}
|
||||
#[rhai_fn(name = "**", return_raw)]
|
||||
pub fn pow_f_i(x: f32, y: INT) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn pow_f_i(x: f32, y: INT) -> Result<f32, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) && y > (i32::MAX as INT) {
|
||||
Err(make_err(format!(
|
||||
"Number raised to too large an index: {} ~ {}",
|
||||
x, y
|
||||
)))
|
||||
} else {
|
||||
Ok(Dynamic::from(x.powi(y as i32)))
|
||||
Ok(x.powi(y as i32))
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -423,14 +423,14 @@ mod f64_functions {
|
||||
}
|
||||
}
|
||||
#[rhai_fn(name = "**", return_raw)]
|
||||
pub fn pow_f_i(x: FLOAT, y: INT) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn pow_f_i(x: FLOAT, y: INT) -> Result<FLOAT, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) && y > (i32::MAX as INT) {
|
||||
Err(make_err(format!(
|
||||
"Number raised to too large an index: {} ~ {}",
|
||||
x, y
|
||||
)))
|
||||
} else {
|
||||
Ok(x.powi(y as i32).into())
|
||||
Ok(x.powi(y as i32))
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -441,37 +441,34 @@ pub mod decimal_functions {
|
||||
use rust_decimal::{prelude::Zero, Decimal};
|
||||
|
||||
#[rhai_fn(skip, return_raw)]
|
||||
pub fn add(x: Decimal, y: Decimal) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn add(x: Decimal, y: Decimal) -> Result<Decimal, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) {
|
||||
x.checked_add(y)
|
||||
.ok_or_else(|| make_err(format!("Addition overflow: {} + {}", x, y)))
|
||||
.map(Into::<Dynamic>::into)
|
||||
} else {
|
||||
Ok(Dynamic::from(x + y))
|
||||
Ok(x + y)
|
||||
}
|
||||
}
|
||||
#[rhai_fn(skip, return_raw)]
|
||||
pub fn subtract(x: Decimal, y: Decimal) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn subtract(x: Decimal, y: Decimal) -> Result<Decimal, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) {
|
||||
x.checked_sub(y)
|
||||
.ok_or_else(|| make_err(format!("Subtraction overflow: {} - {}", x, y)))
|
||||
.map(Into::<Dynamic>::into)
|
||||
} else {
|
||||
Ok(Dynamic::from(x - y))
|
||||
Ok(x - y)
|
||||
}
|
||||
}
|
||||
#[rhai_fn(skip, return_raw)]
|
||||
pub fn multiply(x: Decimal, y: Decimal) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn multiply(x: Decimal, y: Decimal) -> Result<Decimal, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) {
|
||||
x.checked_mul(y)
|
||||
.ok_or_else(|| make_err(format!("Multiplication overflow: {} * {}", x, y)))
|
||||
.map(Into::<Dynamic>::into)
|
||||
} else {
|
||||
Ok(Dynamic::from(x * y))
|
||||
Ok(x * y)
|
||||
}
|
||||
}
|
||||
#[rhai_fn(skip, return_raw)]
|
||||
pub fn divide(x: Decimal, y: Decimal) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn divide(x: Decimal, y: Decimal) -> Result<Decimal, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) {
|
||||
// Detect division by zero
|
||||
if y == Decimal::zero() {
|
||||
@ -479,25 +476,22 @@ pub mod decimal_functions {
|
||||
} else {
|
||||
x.checked_div(y)
|
||||
.ok_or_else(|| make_err(format!("Division overflow: {} / {}", x, y)))
|
||||
.map(Into::<Dynamic>::into)
|
||||
}
|
||||
} else {
|
||||
Ok(Dynamic::from(x / y))
|
||||
Ok(x / y)
|
||||
}
|
||||
}
|
||||
#[rhai_fn(skip, return_raw)]
|
||||
pub fn modulo(x: Decimal, y: Decimal) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn modulo(x: Decimal, y: Decimal) -> Result<Decimal, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) {
|
||||
x.checked_rem(y)
|
||||
.ok_or_else(|| {
|
||||
make_err(format!(
|
||||
"Modulo division by zero or overflow: {} % {}",
|
||||
x, y
|
||||
))
|
||||
})
|
||||
.map(Into::<Dynamic>::into)
|
||||
x.checked_rem(y).ok_or_else(|| {
|
||||
make_err(format!(
|
||||
"Modulo division by zero or overflow: {} % {}",
|
||||
x, y
|
||||
))
|
||||
})
|
||||
} else {
|
||||
Ok(Dynamic::from(x % y))
|
||||
Ok(x % y)
|
||||
}
|
||||
}
|
||||
#[rhai_fn(name = "-")]
|
||||
|
||||
@ -1,9 +1,9 @@
|
||||
#![cfg(not(feature = "no_index"))]
|
||||
#![allow(non_snake_case)]
|
||||
|
||||
use crate::engine::{OP_EQUALS, TYPICAL_ARRAY_SIZE};
|
||||
use crate::engine::OP_EQUALS;
|
||||
use crate::plugin::*;
|
||||
use crate::stdlib::{any::TypeId, boxed::Box, cmp::max, cmp::Ordering, mem, string::ToString};
|
||||
use crate::stdlib::{any::TypeId, boxed::Box, cmp::Ordering, mem, string::ToString};
|
||||
use crate::{def_package, Array, Dynamic, EvalAltResult, FnPtr, NativeCallContext, Position, INT};
|
||||
|
||||
def_package!(crate:BasicArrayPackage:"Basic array utilities.", lib, {
|
||||
@ -47,7 +47,7 @@ mod array_functions {
|
||||
array: &mut Array,
|
||||
len: INT,
|
||||
item: Dynamic,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
) -> Result<(), Box<EvalAltResult>> {
|
||||
// Check if array will be over max size limit
|
||||
#[cfg(not(feature = "unchecked"))]
|
||||
if _ctx.engine().max_array_size() > 0
|
||||
@ -62,7 +62,7 @@ mod array_functions {
|
||||
array.resize(len as usize, item);
|
||||
}
|
||||
|
||||
Ok(Dynamic::UNIT)
|
||||
Ok(())
|
||||
}
|
||||
pub fn pop(array: &mut Array) -> Dynamic {
|
||||
array.pop().unwrap_or_else(|| ().into())
|
||||
@ -169,8 +169,8 @@ mod array_functions {
|
||||
ctx: NativeCallContext,
|
||||
array: &mut Array,
|
||||
mapper: FnPtr,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
let mut ar = Array::with_capacity(max(TYPICAL_ARRAY_SIZE, array.len()));
|
||||
) -> Result<Array, Box<EvalAltResult>> {
|
||||
let mut ar = Array::with_capacity(array.len());
|
||||
|
||||
for (i, item) in array.iter().enumerate() {
|
||||
ar.push(
|
||||
@ -195,15 +195,15 @@ mod array_functions {
|
||||
);
|
||||
}
|
||||
|
||||
Ok(ar.into())
|
||||
Ok(ar)
|
||||
}
|
||||
#[rhai_fn(return_raw, pure)]
|
||||
pub fn filter(
|
||||
ctx: NativeCallContext,
|
||||
array: &mut Array,
|
||||
filter: FnPtr,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
let mut ar = Array::with_capacity(max(TYPICAL_ARRAY_SIZE, array.len()));
|
||||
) -> Result<Array, Box<EvalAltResult>> {
|
||||
let mut ar = Array::new();
|
||||
|
||||
for (i, item) in array.iter().enumerate() {
|
||||
if filter
|
||||
@ -231,14 +231,14 @@ mod array_functions {
|
||||
}
|
||||
}
|
||||
|
||||
Ok(ar.into())
|
||||
Ok(ar)
|
||||
}
|
||||
#[rhai_fn(return_raw, pure)]
|
||||
pub fn contains(
|
||||
ctx: NativeCallContext,
|
||||
array: &mut Array,
|
||||
value: Dynamic,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
) -> Result<bool, Box<EvalAltResult>> {
|
||||
for item in array.iter_mut() {
|
||||
if ctx
|
||||
.call_fn_dynamic_raw(OP_EQUALS, true, &mut [item, &mut value.clone()])
|
||||
@ -258,18 +258,18 @@ mod array_functions {
|
||||
.as_bool()
|
||||
.unwrap_or(false)
|
||||
{
|
||||
return Ok(Dynamic::TRUE);
|
||||
return Ok(true);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(Dynamic::FALSE)
|
||||
Ok(false)
|
||||
}
|
||||
#[rhai_fn(return_raw, pure)]
|
||||
pub fn index_of(
|
||||
ctx: NativeCallContext,
|
||||
array: &mut Array,
|
||||
value: Dynamic,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
) -> Result<INT, Box<EvalAltResult>> {
|
||||
for (i, item) in array.iter_mut().enumerate() {
|
||||
if ctx
|
||||
.call_fn_dynamic_raw(OP_EQUALS, true, &mut [item, &mut value.clone()])
|
||||
@ -289,18 +289,18 @@ mod array_functions {
|
||||
.as_bool()
|
||||
.unwrap_or(false)
|
||||
{
|
||||
return Ok((i as INT).into());
|
||||
return Ok(i as INT);
|
||||
}
|
||||
}
|
||||
|
||||
Ok((-1 as INT).into())
|
||||
Ok(-1 as INT)
|
||||
}
|
||||
#[rhai_fn(name = "index_of", return_raw, pure)]
|
||||
pub fn index_of_filter(
|
||||
ctx: NativeCallContext,
|
||||
array: &mut Array,
|
||||
filter: FnPtr,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
) -> Result<INT, Box<EvalAltResult>> {
|
||||
for (i, item) in array.iter().enumerate() {
|
||||
if filter
|
||||
.call_dynamic(&ctx, None, [item.clone()])
|
||||
@ -323,18 +323,18 @@ mod array_functions {
|
||||
.as_bool()
|
||||
.unwrap_or(false)
|
||||
{
|
||||
return Ok((i as INT).into());
|
||||
return Ok(i as INT);
|
||||
}
|
||||
}
|
||||
|
||||
Ok((-1 as INT).into())
|
||||
Ok(-1 as INT)
|
||||
}
|
||||
#[rhai_fn(return_raw, pure)]
|
||||
pub fn some(
|
||||
ctx: NativeCallContext,
|
||||
array: &mut Array,
|
||||
filter: FnPtr,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
) -> Result<bool, Box<EvalAltResult>> {
|
||||
for (i, item) in array.iter().enumerate() {
|
||||
if filter
|
||||
.call_dynamic(&ctx, None, [item.clone()])
|
||||
@ -357,18 +357,18 @@ mod array_functions {
|
||||
.as_bool()
|
||||
.unwrap_or(false)
|
||||
{
|
||||
return Ok(true.into());
|
||||
return Ok(true);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(false.into())
|
||||
Ok(false)
|
||||
}
|
||||
#[rhai_fn(return_raw, pure)]
|
||||
pub fn all(
|
||||
ctx: NativeCallContext,
|
||||
array: &mut Array,
|
||||
filter: FnPtr,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
) -> Result<bool, Box<EvalAltResult>> {
|
||||
for (i, item) in array.iter().enumerate() {
|
||||
if !filter
|
||||
.call_dynamic(&ctx, None, [item.clone()])
|
||||
@ -391,11 +391,11 @@ mod array_functions {
|
||||
.as_bool()
|
||||
.unwrap_or(false)
|
||||
{
|
||||
return Ok(false.into());
|
||||
return Ok(false);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(true.into())
|
||||
Ok(true)
|
||||
}
|
||||
#[rhai_fn(return_raw, pure)]
|
||||
pub fn reduce(
|
||||
@ -403,7 +403,7 @@ mod array_functions {
|
||||
array: &mut Array,
|
||||
reducer: FnPtr,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
let mut result: Dynamic = Dynamic::UNIT;
|
||||
let mut result = Dynamic::UNIT;
|
||||
|
||||
for (i, item) in array.iter().enumerate() {
|
||||
result = reducer
|
||||
@ -433,16 +433,9 @@ mod array_functions {
|
||||
ctx: NativeCallContext,
|
||||
array: &mut Array,
|
||||
reducer: FnPtr,
|
||||
initial: FnPtr,
|
||||
initial: Dynamic,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
let mut result = initial.call_dynamic(&ctx, None, []).map_err(|err| {
|
||||
Box::new(EvalAltResult::ErrorInFunctionCall(
|
||||
"reduce".to_string(),
|
||||
ctx.source().unwrap_or("").to_string(),
|
||||
err,
|
||||
Position::NONE,
|
||||
))
|
||||
})?;
|
||||
let mut result = initial;
|
||||
|
||||
for (i, item) in array.iter().enumerate() {
|
||||
result = reducer
|
||||
@ -473,7 +466,7 @@ mod array_functions {
|
||||
array: &mut Array,
|
||||
reducer: FnPtr,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
let mut result: Dynamic = Dynamic::UNIT;
|
||||
let mut result = Dynamic::UNIT;
|
||||
|
||||
for (i, item) in array.iter().enumerate().rev() {
|
||||
result = reducer
|
||||
@ -503,16 +496,9 @@ mod array_functions {
|
||||
ctx: NativeCallContext,
|
||||
array: &mut Array,
|
||||
reducer: FnPtr,
|
||||
initial: FnPtr,
|
||||
initial: Dynamic,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
let mut result = initial.call_dynamic(&ctx, None, []).map_err(|err| {
|
||||
Box::new(EvalAltResult::ErrorInFunctionCall(
|
||||
"reduce_rev".to_string(),
|
||||
ctx.source().unwrap_or("").to_string(),
|
||||
err,
|
||||
Position::NONE,
|
||||
))
|
||||
})?;
|
||||
let mut result = initial;
|
||||
|
||||
for (i, item) in array.iter().enumerate().rev() {
|
||||
result = reducer
|
||||
@ -542,7 +528,7 @@ mod array_functions {
|
||||
ctx: NativeCallContext,
|
||||
array: &mut Array,
|
||||
comparer: FnPtr,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
) -> Result<(), Box<EvalAltResult>> {
|
||||
array.sort_by(|x, y| {
|
||||
comparer
|
||||
.call_dynamic(&ctx, None, [x.clone(), y.clone()])
|
||||
@ -571,15 +557,15 @@ mod array_functions {
|
||||
})
|
||||
});
|
||||
|
||||
Ok(Dynamic::UNIT)
|
||||
Ok(())
|
||||
}
|
||||
#[rhai_fn(return_raw)]
|
||||
pub fn drain(
|
||||
ctx: NativeCallContext,
|
||||
array: &mut Array,
|
||||
filter: FnPtr,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
let mut drained = Array::with_capacity(max(TYPICAL_ARRAY_SIZE, array.len()));
|
||||
) -> Result<Array, Box<EvalAltResult>> {
|
||||
let mut drained = Array::with_capacity(array.len());
|
||||
|
||||
let mut i = array.len();
|
||||
|
||||
@ -611,7 +597,7 @@ mod array_functions {
|
||||
}
|
||||
}
|
||||
|
||||
Ok(drained.into())
|
||||
Ok(drained)
|
||||
}
|
||||
#[rhai_fn(name = "drain")]
|
||||
pub fn drain_range(array: &mut Array, start: INT, len: INT) -> Array {
|
||||
@ -638,8 +624,8 @@ mod array_functions {
|
||||
ctx: NativeCallContext,
|
||||
array: &mut Array,
|
||||
filter: FnPtr,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
let mut drained = Array::with_capacity(max(TYPICAL_ARRAY_SIZE, array.len()));
|
||||
) -> Result<Array, Box<EvalAltResult>> {
|
||||
let mut drained = Array::new();
|
||||
|
||||
let mut i = array.len();
|
||||
|
||||
@ -671,7 +657,7 @@ mod array_functions {
|
||||
}
|
||||
}
|
||||
|
||||
Ok(drained.into())
|
||||
Ok(drained)
|
||||
}
|
||||
#[rhai_fn(name = "retain")]
|
||||
pub fn retain_range(array: &mut Array, start: INT, len: INT) -> Array {
|
||||
@ -701,12 +687,12 @@ mod array_functions {
|
||||
ctx: NativeCallContext,
|
||||
array: &mut Array,
|
||||
mut array2: Array,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
) -> Result<bool, Box<EvalAltResult>> {
|
||||
if array.len() != array2.len() {
|
||||
return Ok(false.into());
|
||||
return Ok(false);
|
||||
}
|
||||
if array.is_empty() {
|
||||
return Ok(true.into());
|
||||
return Ok(true);
|
||||
}
|
||||
|
||||
for (a1, a2) in array.iter_mut().zip(array2.iter_mut()) {
|
||||
@ -728,18 +714,18 @@ mod array_functions {
|
||||
.as_bool()
|
||||
.unwrap_or(false)
|
||||
{
|
||||
return Ok(Dynamic::FALSE);
|
||||
return Ok(false);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(Dynamic::TRUE)
|
||||
Ok(true)
|
||||
}
|
||||
#[rhai_fn(name = "!=", return_raw, pure)]
|
||||
pub fn not_equals(
|
||||
ctx: NativeCallContext,
|
||||
array: &mut Array,
|
||||
array2: Array,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
equals(ctx, array, array2).map(|r| (!r.as_bool().unwrap()).into())
|
||||
) -> Result<bool, Box<EvalAltResult>> {
|
||||
equals(ctx, array, array2).map(|r| !r)
|
||||
}
|
||||
}
|
||||
|
||||
@ -34,34 +34,34 @@ mod fn_ptr_functions {
|
||||
#[cfg(not(feature = "no_index"))]
|
||||
#[cfg(not(feature = "no_object"))]
|
||||
fn collect_fn_metadata(ctx: NativeCallContext) -> crate::Array {
|
||||
use crate::{ast::ScriptFnDef, stdlib::collections::HashMap, Array, Map};
|
||||
use crate::{ast::ScriptFnDef, stdlib::collections::BTreeSet, Array, Map};
|
||||
|
||||
// Create a metadata record for a function.
|
||||
fn make_metadata(
|
||||
dict: &HashMap<&str, ImmutableString>,
|
||||
dict: &BTreeSet<ImmutableString>,
|
||||
namespace: Option<ImmutableString>,
|
||||
f: &ScriptFnDef,
|
||||
) -> Map {
|
||||
let mut map = Map::with_capacity(6);
|
||||
let mut map = Map::new();
|
||||
|
||||
if let Some(ns) = namespace {
|
||||
map.insert(dict["namespace"].clone(), ns.into());
|
||||
map.insert(dict.get("namespace").unwrap().clone(), ns.into());
|
||||
}
|
||||
map.insert(dict["name"].clone(), f.name.clone().into());
|
||||
map.insert(dict.get("name").unwrap().clone(), f.name.clone().into());
|
||||
map.insert(
|
||||
dict["access"].clone(),
|
||||
dict.get("access").unwrap().clone(),
|
||||
match f.access {
|
||||
FnAccess::Public => dict["public"].clone(),
|
||||
FnAccess::Private => dict["private"].clone(),
|
||||
FnAccess::Public => dict.get("public").unwrap().clone(),
|
||||
FnAccess::Private => dict.get("private").unwrap().clone(),
|
||||
}
|
||||
.into(),
|
||||
);
|
||||
map.insert(
|
||||
dict["is_anonymous"].clone(),
|
||||
dict.get("is_anonymous").unwrap().clone(),
|
||||
f.name.starts_with(crate::engine::FN_ANONYMOUS).into(),
|
||||
);
|
||||
map.insert(
|
||||
dict["params"].clone(),
|
||||
dict.get("params").unwrap().clone(),
|
||||
f.params
|
||||
.iter()
|
||||
.cloned()
|
||||
@ -74,8 +74,7 @@ fn collect_fn_metadata(ctx: NativeCallContext) -> crate::Array {
|
||||
}
|
||||
|
||||
// Intern strings
|
||||
let mut dict = HashMap::<&str, ImmutableString>::with_capacity(8);
|
||||
[
|
||||
let dict: BTreeSet<ImmutableString> = [
|
||||
"namespace",
|
||||
"name",
|
||||
"access",
|
||||
@ -85,9 +84,8 @@ fn collect_fn_metadata(ctx: NativeCallContext) -> crate::Array {
|
||||
"params",
|
||||
]
|
||||
.iter()
|
||||
.for_each(|&s| {
|
||||
dict.insert(s, s.into());
|
||||
});
|
||||
.map(|&s| s.into())
|
||||
.collect();
|
||||
|
||||
let mut list: Array = Default::default();
|
||||
|
||||
@ -100,7 +98,7 @@ fn collect_fn_metadata(ctx: NativeCallContext) -> crate::Array {
|
||||
// Recursively scan modules for script-defined functions.
|
||||
fn scan_module(
|
||||
list: &mut Array,
|
||||
dict: &HashMap<&str, ImmutableString>,
|
||||
dict: &BTreeSet<ImmutableString>,
|
||||
namespace: ImmutableString,
|
||||
module: &Module,
|
||||
) {
|
||||
|
||||
@ -46,12 +46,12 @@ mod map_functions {
|
||||
ctx: NativeCallContext,
|
||||
map: &mut Map,
|
||||
mut map2: Map,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
) -> Result<bool, Box<EvalAltResult>> {
|
||||
if map.len() != map2.len() {
|
||||
return Ok(false.into());
|
||||
return Ok(false);
|
||||
}
|
||||
if map.is_empty() {
|
||||
return Ok(true.into());
|
||||
return Ok(true);
|
||||
}
|
||||
|
||||
for (m1, v1) in map.iter_mut() {
|
||||
@ -61,22 +61,22 @@ mod map_functions {
|
||||
.map(|v| v.as_bool().unwrap_or(false))?;
|
||||
|
||||
if !equals {
|
||||
return Ok(false.into());
|
||||
return Ok(false);
|
||||
}
|
||||
} else {
|
||||
return Ok(false.into());
|
||||
return Ok(false);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(true.into())
|
||||
Ok(true)
|
||||
}
|
||||
#[rhai_fn(name = "!=", return_raw, pure)]
|
||||
pub fn not_equals(
|
||||
ctx: NativeCallContext,
|
||||
map: &mut Map,
|
||||
map2: Map,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
equals(ctx, map, map2).map(|r| (!r.as_bool().unwrap()).into())
|
||||
) -> Result<bool, Box<EvalAltResult>> {
|
||||
equals(ctx, map, map2).map(|r| !r)
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "no_index"))]
|
||||
|
||||
@ -113,7 +113,7 @@ def_package!(crate:BasicMathPackage:"Basic mathematic functions.", lib, {
|
||||
#[export_module]
|
||||
mod int_functions {
|
||||
#[rhai_fn(name = "parse_int", return_raw)]
|
||||
pub fn parse_int_radix(s: &str, radix: INT) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn parse_int_radix(s: &str, radix: INT) -> Result<INT, Box<EvalAltResult>> {
|
||||
if radix < 2 || radix > 36 {
|
||||
return EvalAltResult::ErrorArithmetic(
|
||||
format!("Invalid radix: '{}'", radix),
|
||||
@ -122,18 +122,16 @@ mod int_functions {
|
||||
.into();
|
||||
}
|
||||
|
||||
INT::from_str_radix(s.trim(), radix as u32)
|
||||
.map(Into::<Dynamic>::into)
|
||||
.map_err(|err| {
|
||||
EvalAltResult::ErrorArithmetic(
|
||||
format!("Error parsing integer number '{}': {}", s, err),
|
||||
Position::NONE,
|
||||
)
|
||||
.into()
|
||||
})
|
||||
INT::from_str_radix(s.trim(), radix as u32).map_err(|err| {
|
||||
EvalAltResult::ErrorArithmetic(
|
||||
format!("Error parsing integer number '{}': {}", s, err),
|
||||
Position::NONE,
|
||||
)
|
||||
.into()
|
||||
})
|
||||
}
|
||||
#[rhai_fn(name = "parse_int", return_raw)]
|
||||
pub fn parse_int(s: &str) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn parse_int(s: &str) -> Result<INT, Box<EvalAltResult>> {
|
||||
parse_int_radix(s, 10)
|
||||
}
|
||||
}
|
||||
@ -261,7 +259,7 @@ mod float_functions {
|
||||
x.is_infinite()
|
||||
}
|
||||
#[rhai_fn(name = "to_int", return_raw)]
|
||||
pub fn f32_to_int(x: f32) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn f32_to_int(x: f32) -> Result<INT, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) && x > (MAX_INT as f32) {
|
||||
EvalAltResult::ErrorArithmetic(
|
||||
format!("Integer overflow: to_int({})", x),
|
||||
@ -269,11 +267,11 @@ mod float_functions {
|
||||
)
|
||||
.into()
|
||||
} else {
|
||||
Ok((x.trunc() as INT).into())
|
||||
Ok(x.trunc() as INT)
|
||||
}
|
||||
}
|
||||
#[rhai_fn(name = "to_int", return_raw)]
|
||||
pub fn f64_to_int(x: f64) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn f64_to_int(x: f64) -> Result<INT, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) && x > (MAX_INT as f64) {
|
||||
EvalAltResult::ErrorArithmetic(
|
||||
format!("Integer overflow: to_int({})", x),
|
||||
@ -281,21 +279,18 @@ mod float_functions {
|
||||
)
|
||||
.into()
|
||||
} else {
|
||||
Ok((x.trunc() as INT).into())
|
||||
Ok(x.trunc() as INT)
|
||||
}
|
||||
}
|
||||
#[rhai_fn(return_raw)]
|
||||
pub fn parse_float(s: &str) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
s.trim()
|
||||
.parse::<FLOAT>()
|
||||
.map(Into::<Dynamic>::into)
|
||||
.map_err(|err| {
|
||||
EvalAltResult::ErrorArithmetic(
|
||||
format!("Error parsing floating-point number '{}': {}", s, err),
|
||||
Position::NONE,
|
||||
)
|
||||
.into()
|
||||
})
|
||||
pub fn parse_float(s: &str) -> Result<FLOAT, Box<EvalAltResult>> {
|
||||
s.trim().parse::<FLOAT>().map_err(|err| {
|
||||
EvalAltResult::ErrorArithmetic(
|
||||
format!("Error parsing floating-point number '{}': {}", s, err),
|
||||
Position::NONE,
|
||||
)
|
||||
.into()
|
||||
})
|
||||
}
|
||||
#[cfg(not(feature = "f32_float"))]
|
||||
pub mod f32_f64 {
|
||||
@ -309,6 +304,7 @@ mod float_functions {
|
||||
#[cfg(feature = "decimal")]
|
||||
#[export_module]
|
||||
mod decimal_functions {
|
||||
use crate::stdlib::convert::TryFrom;
|
||||
use rust_decimal::{
|
||||
prelude::{FromStr, RoundingStrategy},
|
||||
Decimal,
|
||||
@ -327,10 +323,10 @@ mod decimal_functions {
|
||||
x.round()
|
||||
}
|
||||
#[rhai_fn(name = "round", return_raw)]
|
||||
pub fn round_dp(x: Decimal, dp: INT) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn round_dp(x: Decimal, dp: INT) -> Result<Decimal, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) {
|
||||
if cfg!(not(feature = "only_i32")) && dp > (u32::MAX as INT) {
|
||||
return Ok(x.into());
|
||||
return Ok(x);
|
||||
}
|
||||
if dp < 0 {
|
||||
return Err(make_err(format!(
|
||||
@ -340,13 +336,13 @@ mod decimal_functions {
|
||||
}
|
||||
}
|
||||
|
||||
Ok(x.round_dp(dp as u32).into())
|
||||
Ok(x.round_dp(dp as u32))
|
||||
}
|
||||
#[rhai_fn(return_raw)]
|
||||
pub fn round_up(x: Decimal, dp: INT) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn round_up(x: Decimal, dp: INT) -> Result<Decimal, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) {
|
||||
if cfg!(not(feature = "only_i32")) && dp > (u32::MAX as INT) {
|
||||
return Ok(x.into());
|
||||
return Ok(x);
|
||||
}
|
||||
if dp < 0 {
|
||||
return Err(make_err(format!(
|
||||
@ -356,16 +352,13 @@ mod decimal_functions {
|
||||
}
|
||||
}
|
||||
|
||||
Ok(
|
||||
x.round_dp_with_strategy(dp as u32, RoundingStrategy::RoundUp)
|
||||
.into(),
|
||||
)
|
||||
Ok(x.round_dp_with_strategy(dp as u32, RoundingStrategy::RoundUp))
|
||||
}
|
||||
#[rhai_fn(return_raw)]
|
||||
pub fn round_down(x: Decimal, dp: INT) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn round_down(x: Decimal, dp: INT) -> Result<Decimal, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) {
|
||||
if cfg!(not(feature = "only_i32")) && dp > (u32::MAX as INT) {
|
||||
return Ok(x.into());
|
||||
return Ok(x);
|
||||
}
|
||||
if dp < 0 {
|
||||
return Err(make_err(format!(
|
||||
@ -375,16 +368,13 @@ mod decimal_functions {
|
||||
}
|
||||
}
|
||||
|
||||
Ok(
|
||||
x.round_dp_with_strategy(dp as u32, RoundingStrategy::RoundDown)
|
||||
.into(),
|
||||
)
|
||||
Ok(x.round_dp_with_strategy(dp as u32, RoundingStrategy::RoundDown))
|
||||
}
|
||||
#[rhai_fn(return_raw)]
|
||||
pub fn round_half_up(x: Decimal, dp: INT) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn round_half_up(x: Decimal, dp: INT) -> Result<Decimal, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) {
|
||||
if cfg!(not(feature = "only_i32")) && dp > (u32::MAX as INT) {
|
||||
return Ok(x.into());
|
||||
return Ok(x);
|
||||
}
|
||||
if dp < 0 {
|
||||
return Err(make_err(format!(
|
||||
@ -394,16 +384,13 @@ mod decimal_functions {
|
||||
}
|
||||
}
|
||||
|
||||
Ok(
|
||||
x.round_dp_with_strategy(dp as u32, RoundingStrategy::RoundHalfUp)
|
||||
.into(),
|
||||
)
|
||||
Ok(x.round_dp_with_strategy(dp as u32, RoundingStrategy::RoundHalfUp))
|
||||
}
|
||||
#[rhai_fn(return_raw)]
|
||||
pub fn round_half_down(x: Decimal, dp: INT) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn round_half_down(x: Decimal, dp: INT) -> Result<Decimal, Box<EvalAltResult>> {
|
||||
if cfg!(not(feature = "unchecked")) {
|
||||
if cfg!(not(feature = "only_i32")) && dp > (u32::MAX as INT) {
|
||||
return Ok(x.into());
|
||||
return Ok(x);
|
||||
}
|
||||
if dp < 0 {
|
||||
return Err(make_err(format!(
|
||||
@ -413,10 +400,7 @@ mod decimal_functions {
|
||||
}
|
||||
}
|
||||
|
||||
Ok(
|
||||
x.round_dp_with_strategy(dp as u32, RoundingStrategy::RoundHalfDown)
|
||||
.into(),
|
||||
)
|
||||
Ok(x.round_dp_with_strategy(dp as u32, RoundingStrategy::RoundHalfDown))
|
||||
}
|
||||
#[rhai_fn(name = "int", get = "int")]
|
||||
pub fn int(x: Decimal) -> Decimal {
|
||||
@ -427,10 +411,9 @@ mod decimal_functions {
|
||||
x.fract()
|
||||
}
|
||||
#[rhai_fn(return_raw)]
|
||||
pub fn parse_decimal(s: &str) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn parse_decimal(s: &str) -> Result<Decimal, Box<EvalAltResult>> {
|
||||
Decimal::from_str(s)
|
||||
.or_else(|_| Decimal::from_scientific(s))
|
||||
.map(Into::<Dynamic>::into)
|
||||
.map_err(|err| {
|
||||
EvalAltResult::ErrorArithmetic(
|
||||
format!("Error parsing decimal number '{}': {}", s, err),
|
||||
@ -439,6 +422,40 @@ mod decimal_functions {
|
||||
.into()
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "no_float"))]
|
||||
pub mod float {
|
||||
#[rhai_fn(name = "to_decimal", return_raw)]
|
||||
pub fn f32_to_decimal(x: f32) -> Result<Decimal, Box<EvalAltResult>> {
|
||||
Decimal::try_from(x).map_err(|_| {
|
||||
EvalAltResult::ErrorArithmetic(
|
||||
format!("Cannot convert to Decimal: to_decimal({})", x),
|
||||
Position::NONE,
|
||||
)
|
||||
.into()
|
||||
})
|
||||
}
|
||||
#[rhai_fn(name = "to_decimal", return_raw)]
|
||||
pub fn f64_to_decimal(x: f64) -> Result<Decimal, Box<EvalAltResult>> {
|
||||
Decimal::try_from(x).map_err(|_| {
|
||||
EvalAltResult::ErrorArithmetic(
|
||||
format!("Cannot convert to Decimal: to_decimal({})", x),
|
||||
Position::NONE,
|
||||
)
|
||||
.into()
|
||||
})
|
||||
}
|
||||
#[rhai_fn(return_raw)]
|
||||
pub fn to_float(x: Decimal) -> Result<FLOAT, Box<EvalAltResult>> {
|
||||
FLOAT::try_from(x).map_err(|_| {
|
||||
EvalAltResult::ErrorArithmetic(
|
||||
format!("Cannot convert to floating-point: to_float({})", x),
|
||||
Position::NONE,
|
||||
)
|
||||
.into()
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "no_float"))]
|
||||
|
||||
@ -89,7 +89,7 @@ macro_rules! def_package {
|
||||
|
||||
impl $package {
|
||||
pub fn new() -> Self {
|
||||
let mut module = $root::Module::new_with_capacity(1024);
|
||||
let mut module = $root::Module::new();
|
||||
<Self as $root::packages::Package>::init(&mut module);
|
||||
module.build_index();
|
||||
Self(module.into())
|
||||
|
||||
@ -235,7 +235,7 @@ mod string_functions {
|
||||
string: &mut ImmutableString,
|
||||
len: INT,
|
||||
character: char,
|
||||
) -> Result<Dynamic, Box<crate::EvalAltResult>> {
|
||||
) -> Result<(), Box<crate::EvalAltResult>> {
|
||||
// Check if string will be over max size limit
|
||||
#[cfg(not(feature = "unchecked"))]
|
||||
if _ctx.engine().max_string_size() > 0 && len as usize > _ctx.engine().max_string_size() {
|
||||
@ -269,7 +269,7 @@ mod string_functions {
|
||||
}
|
||||
}
|
||||
|
||||
Ok(Dynamic::UNIT)
|
||||
Ok(())
|
||||
}
|
||||
#[rhai_fn(name = "pad", return_raw)]
|
||||
pub fn pad_with_string(
|
||||
@ -277,7 +277,7 @@ mod string_functions {
|
||||
string: &mut ImmutableString,
|
||||
len: INT,
|
||||
padding: &str,
|
||||
) -> Result<Dynamic, Box<crate::EvalAltResult>> {
|
||||
) -> Result<(), Box<crate::EvalAltResult>> {
|
||||
// Check if string will be over max size limit
|
||||
#[cfg(not(feature = "unchecked"))]
|
||||
if _ctx.engine().max_string_size() > 0 && len as usize > _ctx.engine().max_string_size() {
|
||||
@ -318,7 +318,7 @@ mod string_functions {
|
||||
}
|
||||
}
|
||||
|
||||
Ok(Dynamic::UNIT)
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "no_index"))]
|
||||
|
||||
@ -143,28 +143,28 @@ mod time_functions {
|
||||
}
|
||||
|
||||
#[rhai_fn(return_raw, name = "+")]
|
||||
pub fn add(timestamp: Instant, seconds: FLOAT) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
add_impl(timestamp, seconds).map(Into::<Dynamic>::into)
|
||||
pub fn add(timestamp: Instant, seconds: FLOAT) -> Result<Instant, Box<EvalAltResult>> {
|
||||
add_impl(timestamp, seconds)
|
||||
}
|
||||
#[rhai_fn(return_raw, name = "+=")]
|
||||
pub fn add_assign(
|
||||
timestamp: &mut Instant,
|
||||
seconds: FLOAT,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
) -> Result<(), Box<EvalAltResult>> {
|
||||
*timestamp = add_impl(*timestamp, seconds)?;
|
||||
Ok(Dynamic::UNIT)
|
||||
Ok(())
|
||||
}
|
||||
#[rhai_fn(return_raw, name = "-")]
|
||||
pub fn subtract(timestamp: Instant, seconds: FLOAT) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
subtract_impl(timestamp, seconds).map(Into::<Dynamic>::into)
|
||||
pub fn subtract(timestamp: Instant, seconds: FLOAT) -> Result<Instant, Box<EvalAltResult>> {
|
||||
subtract_impl(timestamp, seconds)
|
||||
}
|
||||
#[rhai_fn(return_raw, name = "-=")]
|
||||
pub fn subtract_assign(
|
||||
timestamp: &mut Instant,
|
||||
seconds: FLOAT,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
) -> Result<(), Box<EvalAltResult>> {
|
||||
*timestamp = subtract_impl(*timestamp, seconds)?;
|
||||
Ok(Dynamic::UNIT)
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
@ -202,28 +202,25 @@ mod time_functions {
|
||||
}
|
||||
|
||||
#[rhai_fn(return_raw, name = "+")]
|
||||
pub fn add(timestamp: Instant, seconds: INT) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
add_impl(timestamp, seconds).map(Into::<Dynamic>::into)
|
||||
pub fn add(timestamp: Instant, seconds: INT) -> Result<Instant, Box<EvalAltResult>> {
|
||||
add_impl(timestamp, seconds)
|
||||
}
|
||||
#[rhai_fn(return_raw, name = "+=")]
|
||||
pub fn add_assign(
|
||||
timestamp: &mut Instant,
|
||||
seconds: INT,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
pub fn add_assign(timestamp: &mut Instant, seconds: INT) -> Result<(), Box<EvalAltResult>> {
|
||||
*timestamp = add_impl(*timestamp, seconds)?;
|
||||
Ok(Dynamic::UNIT)
|
||||
Ok(())
|
||||
}
|
||||
#[rhai_fn(return_raw, name = "-")]
|
||||
pub fn subtract(timestamp: Instant, seconds: INT) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
subtract_impl(timestamp, seconds).map(Into::<Dynamic>::into)
|
||||
pub fn subtract(timestamp: Instant, seconds: INT) -> Result<Instant, Box<EvalAltResult>> {
|
||||
subtract_impl(timestamp, seconds)
|
||||
}
|
||||
#[rhai_fn(return_raw, name = "-=")]
|
||||
pub fn subtract_assign(
|
||||
timestamp: &mut Instant,
|
||||
seconds: INT,
|
||||
) -> Result<Dynamic, Box<EvalAltResult>> {
|
||||
) -> Result<(), Box<EvalAltResult>> {
|
||||
*timestamp = subtract_impl(*timestamp, seconds)?;
|
||||
Ok(Dynamic::UNIT)
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[rhai_fn(name = "==")]
|
||||
|
||||
@ -12,7 +12,7 @@ use crate::optimize::OptimizationLevel;
|
||||
use crate::stdlib::{
|
||||
borrow::Cow,
|
||||
boxed::Box,
|
||||
collections::HashMap,
|
||||
collections::BTreeMap,
|
||||
format,
|
||||
hash::{Hash, Hasher},
|
||||
iter::empty,
|
||||
@ -23,7 +23,7 @@ use crate::stdlib::{
|
||||
};
|
||||
use crate::syntax::{CustomSyntax, MARKER_BLOCK, MARKER_EXPR, MARKER_IDENT};
|
||||
use crate::token::{is_keyword_function, is_valid_identifier, Token, TokenStream};
|
||||
use crate::utils::{get_hasher, StraightHasherBuilder};
|
||||
use crate::utils::get_hasher;
|
||||
use crate::{
|
||||
calc_fn_hash, Dynamic, Engine, ImmutableString, LexError, ParseError, ParseErrorType, Position,
|
||||
Scope, Shared, StaticVec, AST,
|
||||
@ -37,7 +37,7 @@ use crate::FnAccess;
|
||||
|
||||
type PERR = ParseErrorType;
|
||||
|
||||
type FunctionsLib = HashMap<u64, Shared<ScriptFnDef>, StraightHasherBuilder>;
|
||||
type FunctionsLib = BTreeMap<u64, Shared<ScriptFnDef>>;
|
||||
|
||||
/// A type that encapsulates the current state of the parser.
|
||||
#[derive(Debug)]
|
||||
@ -45,14 +45,14 @@ struct ParseState<'e> {
|
||||
/// Reference to the scripting [`Engine`].
|
||||
engine: &'e Engine,
|
||||
/// Interned strings.
|
||||
strings: HashMap<String, ImmutableString>,
|
||||
interned_strings: BTreeMap<String, ImmutableString>,
|
||||
/// Encapsulates a local stack with variable names to simulate an actual runtime scope.
|
||||
stack: Vec<(ImmutableString, AccessMode)>,
|
||||
/// Size of the local variables stack upon entry of the current block scope.
|
||||
entry_stack_len: usize,
|
||||
/// Tracks a list of external variables (variables that are not explicitly declared in the scope).
|
||||
#[cfg(not(feature = "no_closure"))]
|
||||
externals: HashMap<ImmutableString, Position>,
|
||||
external_vars: BTreeMap<ImmutableString, Position>,
|
||||
/// An indicator that disables variable capturing into externals one single time
|
||||
/// up until the nearest consumed Identifier token.
|
||||
/// If set to false the next call to `access_var` will not capture the variable.
|
||||
@ -89,10 +89,10 @@ impl<'e> ParseState<'e> {
|
||||
#[cfg(not(feature = "no_function"))]
|
||||
max_function_expr_depth,
|
||||
#[cfg(not(feature = "no_closure"))]
|
||||
externals: Default::default(),
|
||||
external_vars: Default::default(),
|
||||
#[cfg(not(feature = "no_closure"))]
|
||||
allow_capture: true,
|
||||
strings: HashMap::with_capacity(64),
|
||||
interned_strings: Default::default(),
|
||||
stack: Vec::with_capacity(16),
|
||||
entry_stack_len: 0,
|
||||
#[cfg(not(feature = "no_module"))]
|
||||
@ -130,8 +130,8 @@ impl<'e> ParseState<'e> {
|
||||
|
||||
#[cfg(not(feature = "no_closure"))]
|
||||
if self.allow_capture {
|
||||
if index.is_none() && !self.externals.contains_key(name) {
|
||||
self.externals.insert(name.into(), _pos);
|
||||
if index.is_none() && !self.external_vars.contains_key(name) {
|
||||
self.external_vars.insert(name.into(), _pos);
|
||||
}
|
||||
} else {
|
||||
self.allow_capture = true
|
||||
@ -171,12 +171,13 @@ impl<'e> ParseState<'e> {
|
||||
text: impl AsRef<str> + Into<ImmutableString>,
|
||||
) -> ImmutableString {
|
||||
#[allow(clippy::map_entry)]
|
||||
if !self.strings.contains_key(text.as_ref()) {
|
||||
if !self.interned_strings.contains_key(text.as_ref()) {
|
||||
let value = text.into();
|
||||
self.strings.insert(value.clone().into(), value.clone());
|
||||
self.interned_strings
|
||||
.insert(value.clone().into(), value.clone());
|
||||
value
|
||||
} else {
|
||||
self.strings.get(text.as_ref()).unwrap().clone()
|
||||
self.interned_strings.get(text.as_ref()).unwrap().clone()
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -813,7 +814,7 @@ fn parse_switch(
|
||||
}
|
||||
}
|
||||
|
||||
let mut table = HashMap::<u64, StmtBlock>::new();
|
||||
let mut table = BTreeMap::<u64, StmtBlock>::new();
|
||||
let mut def_stmt = None;
|
||||
|
||||
loop {
|
||||
@ -902,13 +903,10 @@ fn parse_switch(
|
||||
}
|
||||
}
|
||||
|
||||
let mut final_table = HashMap::with_capacity_and_hasher(table.len(), StraightHasherBuilder);
|
||||
final_table.extend(table.into_iter());
|
||||
|
||||
Ok(Stmt::Switch(
|
||||
item,
|
||||
Box::new((
|
||||
final_table.into(),
|
||||
table,
|
||||
def_stmt.unwrap_or_else(|| Stmt::Noop(Position::NONE).into()),
|
||||
)),
|
||||
settings.pos,
|
||||
@ -1003,7 +1001,7 @@ fn parse_primary(
|
||||
let (expr, func) = parse_anon_fn(input, &mut new_state, lib, settings)?;
|
||||
|
||||
#[cfg(not(feature = "no_closure"))]
|
||||
new_state.externals.iter().for_each(|(closure, pos)| {
|
||||
new_state.external_vars.iter().for_each(|(closure, pos)| {
|
||||
state.access_var(closure, *pos);
|
||||
});
|
||||
|
||||
@ -2739,7 +2737,7 @@ fn parse_fn(
|
||||
|
||||
#[cfg(not(feature = "no_closure"))]
|
||||
let externals = state
|
||||
.externals
|
||||
.external_vars
|
||||
.iter()
|
||||
.map(|(name, _)| name)
|
||||
.filter(|name| !params.contains(name))
|
||||
@ -2860,7 +2858,7 @@ fn parse_anon_fn(
|
||||
#[cfg(not(feature = "no_closure"))]
|
||||
{
|
||||
state
|
||||
.externals
|
||||
.external_vars
|
||||
.iter()
|
||||
.map(|(name, &pos)| Ident {
|
||||
name: name.clone(),
|
||||
@ -2966,7 +2964,7 @@ impl Engine {
|
||||
input: &mut TokenStream,
|
||||
) -> Result<(Vec<Stmt>, Vec<Shared<ScriptFnDef>>), ParseError> {
|
||||
let mut statements = Vec::with_capacity(16);
|
||||
let mut functions = HashMap::with_capacity_and_hasher(16, StraightHasherBuilder);
|
||||
let mut functions = BTreeMap::new();
|
||||
let mut state = ParseState::new(
|
||||
self,
|
||||
#[cfg(not(feature = "unchecked"))]
|
||||
|
||||
@ -2,11 +2,11 @@
|
||||
|
||||
pub use crate::fn_native::{CallableFunction, FnCallArgs};
|
||||
pub use crate::stdlib::{any::TypeId, boxed::Box, format, mem, string::ToString, vec as new_vec};
|
||||
use crate::RhaiResult;
|
||||
pub use crate::{
|
||||
Dynamic, Engine, EvalAltResult, FnAccess, FnNamespace, ImmutableString, Module,
|
||||
NativeCallContext, Position,
|
||||
};
|
||||
pub type RhaiResult = Result<Dynamic, Box<EvalAltResult>>;
|
||||
|
||||
#[cfg(not(features = "no_module"))]
|
||||
pub use rhai_codegen::*;
|
||||
@ -30,12 +30,9 @@ pub trait PluginFunction {
|
||||
/// Convert a plugin function into a boxed trait object.
|
||||
fn clone_boxed(&self) -> Box<dyn PluginFunction>;
|
||||
|
||||
/// Return a boxed slice of the names of the function's parameters.
|
||||
fn input_names(&self) -> Box<[&'static str]>;
|
||||
/// Return a boxed slice of the names of the function's parameters and return type.
|
||||
fn param_names(&self) -> Box<[&'static str]>;
|
||||
|
||||
/// Return a boxed slice of type ID's of the function's parameters.
|
||||
fn input_types(&self) -> Box<[TypeId]>;
|
||||
|
||||
/// Return a string slice of the function's return type.
|
||||
fn return_type(&self) -> &'static str;
|
||||
}
|
||||
|
||||
@ -390,7 +390,7 @@ impl Serializer for &mut DynamicSerializer {
|
||||
#[cfg(not(feature = "no_object"))]
|
||||
return Ok(StructVariantSerializer {
|
||||
variant: _variant,
|
||||
map: Map::with_capacity(_len),
|
||||
map: Default::default(),
|
||||
});
|
||||
#[cfg(feature = "no_object")]
|
||||
return EvalAltResult::ErrorMismatchDataType(
|
||||
@ -691,7 +691,7 @@ impl serde::ser::SerializeStructVariant for StructVariantSerializer {
|
||||
|
||||
#[cfg(not(feature = "no_object"))]
|
||||
fn make_variant(variant: &'static str, value: Dynamic) -> RhaiResult {
|
||||
let mut map = Map::with_capacity(1);
|
||||
let mut map = Map::new();
|
||||
map.insert(variant.into(), value);
|
||||
Ok(map.into())
|
||||
}
|
||||
|
||||
@ -19,7 +19,8 @@ mod inner {
|
||||
pub use core_error as error;
|
||||
|
||||
pub mod collections {
|
||||
pub use hashbrown::{hash_map, hash_set, HashMap, HashSet};
|
||||
pub use alloc::collections::btree_map::BTreeMap;
|
||||
pub use alloc::collections::btree_set::BTreeSet;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ use crate::stdlib::{
|
||||
|
||||
/// Cast a type into another type.
|
||||
#[inline(always)]
|
||||
pub fn unsafe_try_cast<A: Any, B: Any>(a: A) -> Option<B> {
|
||||
pub fn unsafe_try_cast<A: Any, B: Any>(a: A) -> Result<B, A> {
|
||||
if TypeId::of::<B>() == a.type_id() {
|
||||
// SAFETY: Just checked we have the right type. We explicitly forget the
|
||||
// value immediately after moving out, removing any chance of a destructor
|
||||
@ -17,10 +17,10 @@ pub fn unsafe_try_cast<A: Any, B: Any>(a: A) -> Option<B> {
|
||||
unsafe {
|
||||
let ret: B = ptr::read(&a as *const _ as *const B);
|
||||
mem::forget(a);
|
||||
Some(ret)
|
||||
Ok(ret)
|
||||
}
|
||||
} else {
|
||||
None
|
||||
Err(a)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
60
src/utils.rs
60
src/utils.rs
@ -6,15 +6,13 @@ use crate::stdlib::{
|
||||
borrow::Borrow,
|
||||
boxed::Box,
|
||||
cmp::Ordering,
|
||||
collections::HashMap,
|
||||
fmt,
|
||||
fmt::{Debug, Display},
|
||||
hash::{BuildHasher, Hash, Hasher},
|
||||
iter::FromIterator,
|
||||
ops::{Add, AddAssign, Deref, DerefMut, Sub, SubAssign},
|
||||
ops::{Add, AddAssign, Deref, Sub, SubAssign},
|
||||
str::FromStr,
|
||||
string::{String, ToString},
|
||||
vec::Vec,
|
||||
};
|
||||
use crate::Shared;
|
||||
|
||||
@ -106,62 +104,6 @@ pub(crate) fn combine_hashes(a: u64, b: u64) -> u64 {
|
||||
a ^ b
|
||||
}
|
||||
|
||||
/// _(INTERNALS)_ A type that wraps a [`HashMap`] and implements [`Hash`].
|
||||
/// Exported under the `internals` feature only.
|
||||
#[derive(Clone, Default)]
|
||||
pub struct HashableHashMap<K, T, H: BuildHasher>(HashMap<K, T, H>);
|
||||
|
||||
impl<K, T, H: BuildHasher> From<HashMap<K, T, H>> for HashableHashMap<K, T, H> {
|
||||
#[inline(always)]
|
||||
fn from(value: HashMap<K, T, H>) -> Self {
|
||||
Self(value)
|
||||
}
|
||||
}
|
||||
impl<K, T, H: BuildHasher> AsRef<HashMap<K, T, H>> for HashableHashMap<K, T, H> {
|
||||
#[inline(always)]
|
||||
fn as_ref(&self) -> &HashMap<K, T, H> {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl<K, T, H: BuildHasher> AsMut<HashMap<K, T, H>> for HashableHashMap<K, T, H> {
|
||||
#[inline(always)]
|
||||
fn as_mut(&mut self) -> &mut HashMap<K, T, H> {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl<K, T, H: BuildHasher> Deref for HashableHashMap<K, T, H> {
|
||||
type Target = HashMap<K, T, H>;
|
||||
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl<K, T, H: BuildHasher> DerefMut for HashableHashMap<K, T, H> {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl<K: Debug, T: Debug, H: BuildHasher> Debug for HashableHashMap<K, T, H> {
|
||||
#[inline(always)]
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
self.0.fmt(f)
|
||||
}
|
||||
}
|
||||
impl<K: Hash + Ord, T: Hash, H: BuildHasher> Hash for HashableHashMap<K, T, H> {
|
||||
#[inline(always)]
|
||||
fn hash<B: Hasher>(&self, state: &mut B) {
|
||||
let mut keys: Vec<_> = self.0.keys().collect();
|
||||
keys.sort();
|
||||
|
||||
keys.into_iter().for_each(|key| {
|
||||
key.hash(state);
|
||||
self.0.get(&key).unwrap().hash(state);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/// The system immutable string type.
|
||||
///
|
||||
/// An [`ImmutableString`] wraps an [`Rc`][std::rc::Rc]`<`[`String`]`>`
|
||||
|
||||
Loading…
Reference in New Issue
Block a user