diff --git a/Cargo.toml b/Cargo.toml index d7c17ec9..6f3509be 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "rhai" -version = "0.14.1" +version = "0.14.2" edition = "2018" authors = ["Jonathan Turner", "Lukáš Hozda", "Stephen Chung"] description = "Embedded scripting for Rust" diff --git a/README.md b/README.md index a8329aa3..8673aba5 100644 --- a/README.md +++ b/README.md @@ -13,24 +13,30 @@ to add scripting to any application. Rhai's current features set: -* Easy-to-use language similar to JS+Rust -* Easy integration with Rust [native functions](#working-with-functions) and [types](#custom-types-and-methods), - including [getters/setters](#getters-and-setters), [methods](#members-and-methods) and [indexers](#indexers) -* Easily [call a script-defined function](#calling-rhai-functions-from-rust) from Rust -* Freely pass variables/constants into a script via an external [`Scope`] -* Fairly efficient (1 million iterations in 0.75 sec on my 5 year old laptop) -* Low compile-time overhead (~0.6 sec debug/~3 sec release for script runner app) -* [`no-std`](#optional-features) support -* Support for [function overloading](#function-overloading) -* Support for [operator overloading](#operator-overloading) -* Support for loading external [modules] -* Compiled script is [optimized](#script-optimization) for repeat evaluations -* Support for [minimal builds](#minimal-builds) by excluding unneeded language [features](#optional-features) +* Easy-to-use language similar to JS+Rust with dynamic typing but _no_ garbage collector. +* Tight integration with native Rust [functions](#working-with-functions) and [types](#custom-types-and-methods), + including [getters/setters](#getters-and-setters), [methods](#members-and-methods) and [indexers](#indexers). +* Freely pass Rust variables/constants into a script via an external [`Scope`]. +* Easily [call a script-defined function](#calling-rhai-functions-from-rust) from Rust. +* Low compile-time overhead (~0.6 sec debug/~3 sec release for `rhai_runner` sample app). +* Fairly efficient evaluation (1 million iterations in 0.75 sec on my 5 year old laptop). +* Relatively little `unsafe` code (yes there are some for performance reasons, and most `unsafe` code is limited to + one single source file, all with names starting with `"unsafe_"`). +* Re-entrant scripting [`Engine`] can be made `Send + Sync` (via the [`sync`] feature). +* Sand-boxed - the scripting [`Engine`], if declared immutable, cannot mutate the containing environment without explicit permission. +* Rugged (protection against [stack-overflow](#maximum-call-stack-depth) and [runaway scripts](#maximum-number-of-operations) etc.). +* Track script evaluation [progress](#tracking-progress) and manually terminate a script run. +* [`no-std`](#optional-features) support. +* [Function overloading](#function-overloading). +* [Operator overloading](#operator-overloading). +* Organize code base with dynamically-loadable [Modules]. +* Compiled script is [optimized](#script-optimization) for repeated evaluations. +* Support for [minimal builds](#minimal-builds) by excluding unneeded language [features](#optional-features). * Very few additional dependencies (right now only [`num-traits`](https://crates.io/crates/num-traits/) to do checked arithmetic operations); for [`no-std`](#optional-features) builds, a number of additional dependencies are pulled in to provide for functionalities that used to be in `std`. -**Note:** Currently, the version is 0.14.1, so the language and API's may change before they stabilize. +**Note:** Currently, the version is 0.14.2, so the language and API's may change before they stabilize. Installation ------------ @@ -39,7 +45,7 @@ Install the Rhai crate by adding this line to `dependencies`: ```toml [dependencies] -rhai = "0.14.1" +rhai = "0.14.2" ``` Use the latest released crate version on [`crates.io`](https::/crates.io/crates/rhai/): @@ -62,23 +68,24 @@ Beware that in order to use pre-releases (e.g. alpha and beta), the exact versio Optional features ----------------- -| Feature | Description | -| ------------- | ------------------------------------------------------------------------------------------------------------------------------------- | -| `unchecked` | Exclude arithmetic checking (such as overflows and division by zero). Beware that a bad script may panic the entire system! | -| `no_function` | Disable script-defined functions if not needed. | -| `no_index` | Disable [arrays] and indexing features if not needed. | -| `no_object` | Disable support for custom types and objects. | -| `no_float` | Disable floating-point numbers and math if not needed. | -| `no_optimize` | Disable the script optimizer. | -| `no_module` | Disable modules. | -| `only_i32` | Set the system integer type to `i32` and disable all other integer types. `INT` is set to `i32`. | -| `only_i64` | Set the system integer type to `i64` and disable all other integer types. `INT` is set to `i64`. | -| `no_std` | Build for `no-std`. Notice that additional dependencies will be pulled in to replace `std` features. | -| `sync` | Restrict all values types to those that are `Send + Sync`. Under this feature, [`Engine`], [`Scope`] and `AST` are all `Send + Sync`. | +| Feature | Description | +| ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `unchecked` | Exclude arithmetic checking (such as over-flows and division by zero), stack depth limit and operations count limit. Beware that a bad script may panic the entire system! | +| `no_function` | Disable script-defined functions. | +| `no_index` | Disable [arrays] and indexing features. | +| `no_object` | Disable support for custom types and object maps. | +| `no_float` | Disable floating-point numbers and math. | +| `no_optimize` | Disable the script optimizer. | +| `no_module` | Disable modules. | +| `only_i32` | Set the system integer type to `i32` and disable all other integer types. `INT` is set to `i32`. | +| `only_i64` | Set the system integer type to `i64` and disable all other integer types. `INT` is set to `i64`. | +| `no_std` | Build for `no-std`. Notice that additional dependencies will be pulled in to replace `std` features. | +| `sync` | Restrict all values types to those that are `Send + Sync`. Under this feature, all Rhai types, including [`Engine`], [`Scope`] and `AST`, are all `Send + Sync`. | By default, Rhai includes all the standard functionalities in a small, tight package. Most features are here to opt-**out** of certain functionalities that are not needed. -Excluding unneeded functionalities can result in smaller, faster builds as well as less bugs due to a more restricted language. +Excluding unneeded functionalities can result in smaller, faster builds +as well as more control over what a script can (or cannot) do. [`unchecked`]: #optional-features [`no_index`]: #optional-features @@ -104,7 +111,7 @@ requiring more CPU cycles to complete. Also, turning on `no_float`, and `only_i32` makes the key [`Dynamic`] data type only 8 bytes small on 32-bit targets while normally it can be up to 16 bytes (e.g. on x86/x64 CPU's) in order to hold an `i64` or `f64`. -Making [`Dynamic`] small helps performance due to more caching efficiency. +Making [`Dynamic`] small helps performance due to better cache efficiency. ### Minimal builds @@ -113,6 +120,8 @@ the correct linker flags are used in `cargo.toml`: ```toml [profile.release] +lto = "fat" # turn on Link-Time Optimizations +codegen-units = 1 # trade compile time with maximum optimization opt-level = "z" # optimize for size ``` @@ -126,7 +135,8 @@ Disable script-defined functions (`no_function`) only when the feature is not ne [`Engine::new_raw`](#raw-engine) creates a _raw_ engine which does not register _any_ utility functions. This makes the scripting language quite useless as even basic arithmetic operators are not supported. -Selectively include the necessary operators by loading specific [packages](#packages) while minimizing the code footprint. +Selectively include the necessary functionalities by loading specific [packages] to minimize the footprint. +Packages are sharable (even across threads via the [`sync`] feature), so they only have to be created once. Related ------- @@ -267,7 +277,7 @@ let ast = engine.compile_file("hello_world.rhai".into())?; ### Calling Rhai functions from Rust -Rhai also allows working _backwards_ from the other direction - i.e. calling a Rhai-scripted function from Rust via `call_fn`. +Rhai also allows working _backwards_ from the other direction - i.e. calling a Rhai-scripted function from Rust via `Engine::call_fn`. Functions declared with `private` are hidden and cannot be called from Rust (see also [modules]). ```rust @@ -370,8 +380,11 @@ Use `Engine::new_raw` to create a _raw_ `Engine`, in which _nothing_ is added, n ### Packages -Rhai functional features are provided in different _packages_ that can be loaded via a call to `load_package`. -Packages reside under `rhai::packages::*` and the trait `rhai::packages::Package` must be imported in order for +[package]: #packages +[packages]: #packages + +Rhai functional features are provided in different _packages_ that can be loaded via a call to `Engine::load_package`. +Packages reside under `rhai::packages::*` and the trait `rhai::packages::Package` must be loaded in order for packages to be used. ```rust @@ -382,7 +395,7 @@ use rhai::packages::CorePackage; // the 'core' package contains b let mut engine = Engine::new_raw(); // create a 'raw' Engine let package = CorePackage::new(); // create a package - can be shared among multiple `Engine` instances -engine.load_package(package.get()); // load the package manually +engine.load_package(package.get()); // load the package manually. 'get' returns a reference to the shared package ``` The follow packages are available: @@ -398,9 +411,24 @@ The follow packages are available: | `BasicMathPackage` | Basic math functions (e.g. `sin`, `sqrt`) | No | Yes | | `BasicArrayPackage` | Basic [array] functions | No | Yes | | `BasicMapPackage` | Basic [object map] functions | No | Yes | +| `EvalPackage` | Disable [`eval`] | No | No | | `CorePackage` | Basic essentials | | | | `StandardPackage` | Standard library | | | +Packages typically contain Rust functions that are callable within a Rhai script. +All functions registered in a package is loaded under the _global namespace_ (i.e. they're available without module qualifiers). +Once a package is created (e.g. via `new`), it can be _shared_ (via `get`) among multiple instances of [`Engine`], +even across threads (if the [`sync`] feature is turned on). +Therefore, a package only has to be created _once_. + +Packages are actually implemented as [modules], so they share a lot of behavior and characteristics. +The main difference is that a package loads under the _global_ namespace, while a module loads under its own +namespace alias specified in an [`import`] statement (see also [modules]). +A package is _static_ (i.e. pre-loaded into an [`Engine`]), while a module is _dynamic_ (i.e. loaded with +the `import` statement). + +Custom packages can also be created. See the macro [`def_package!`](https://docs.rs/rhai/0.13.0/rhai/macro.def_package.html). + Evaluate expressions only ------------------------- @@ -743,7 +771,7 @@ Because they [_short-circuit_](#boolean-operators), `&&` and `||` are handled sp overriding them has no effect at all. Operator functions cannot be defined as a script function (because operators syntax are not valid function names). -However, operator functions _can_ be registered to the [`Engine`] via `register_fn`, `register_result_fn` etc. +However, operator functions _can_ be registered to the [`Engine`] via the methods `Engine::register_fn`, `Engine::register_result_fn` etc. When a custom operator function is registered with the same name as an operator, it _overloads_ (or overrides) the built-in version. ```rust @@ -762,11 +790,17 @@ println!("result: {}", result); // prints 42 let result: f64 = engine.eval("1.0 + 0.0"); // '+' operator for two floats not overloaded println!("result: {}", result); // prints 1.0 + +fn mixed_add(a: i64, b: f64) -> f64 { (a as f64) + b } + +engine.register_fn("+", mixed_add); // register '+' operator for an integer and a float + +let result: i64 = engine.eval("1 + 1.0"); // prints 2.0 (normally an error) ``` -Use operator overloading for custom types (described below) only. Be very careful when overloading built-in operators because -script writers expect standard operators to behave in a consistent and predictable manner, and will be annoyed if a calculation -for '+' turns into a subtraction, for example. +Use operator overloading for custom types (described below) only. +Be very careful when overloading built-in operators because script writers expect standard operators to behave in a +consistent and predictable manner, and will be annoyed if a calculation for '`+`' turns into a subtraction, for example. Operator overloading also impacts script optimization when using [`OptimizationLevel::Full`]. See the [relevant section](#script-optimization) for more details. @@ -941,7 +975,7 @@ Indexers -------- Custom types can also expose an _indexer_ by registering an indexer function. -A custom with an indexer function defined can use the bracket '`[]`' notation to get a property value +A custom type with an indexer function defined can use the bracket '`[]`' notation to get a property value (but not update it - indexers are read-only). ```rust @@ -1036,12 +1070,13 @@ fn main() -> Result<(), Box> Engine configuration options --------------------------- -| Method | Description | -| ------------------------ | ---------------------------------------------------------------------------------------- | -| `set_optimization_level` | Set the amount of script _optimizations_ performed. See [`script optimization`]. | -| `set_max_call_levels` | Set the maximum number of function call levels (default 50) to avoid infinite recursion. | - -[`script optimization`]: #script-optimization +| Method | Description | +| ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------- | +| `set_optimization_level` | Set the amount of script _optimizations_ performed. See [script optimization]. | +| `set_max_expr_depths` | Set the maximum nesting levels of an expression/statement. See [maximum statement depth](#maximum-statement-depth). | +| `set_max_call_levels` | Set the maximum number of function call levels (default 50) to avoid infinite recursion. See [maximum call stack depth](#maximum-call-stack-depth). | +| `set_max_operations` | Set the maximum number of _operations_ that a script is allowed to consume. See [maximum number of operations](#maximum-number-of-operations). | +| `set_max_modules` | Set the maximum number of [modules] that a script is allowed to load. See [maximum number of modules](#maximum-number-of-modules). | ------- @@ -1328,7 +1363,7 @@ The following standard methods (defined in the [`MoreStringPackage`](#packages) | `index_of` | character/sub-string to search for, start index _(optional)_ | returns the index that a certain character or sub-string occurs in the string, or -1 if not found | | `sub_string` | start index, length _(optional)_ | extracts a sub-string (to the end of the string if length is not specified) | | `crop` | start index, length _(optional)_ | retains only a portion of the string (to the end of the string if length is not specified) | -| `replace` | target sub-string, replacement string | replaces a sub-string with another | +| `replace` | target character/sub-string, replacement character/string | replaces a sub-string with another | | `trim` | _none_ | trims the string of whitespace at the beginning and end | ### Examples @@ -2021,7 +2056,7 @@ debug("world!"); // prints "world!" to stdout using debug formatting ### Overriding `print` and `debug` with callback functions When embedding Rhai into an application, it is usually necessary to trap `print` and `debug` output -(for logging into a tracking log, for example). +(for logging into a tracking log, for example) with the `Engine::on_print` and `Engine::on_debug` methods: ```rust // Any function or closure that takes an '&str' argument can be used to override @@ -2048,21 +2083,21 @@ for entry in logbook.read().unwrap().iter() { } ``` -Using external modules ----------------------- +Modules +------- -[module]: #using-external-modules -[modules]: #using-external-modules +[module]: #modules +[modules]: #modules -Rhai allows organizing code (functions and variables) into _modules_. +Rhai allows organizing code (functions, both Rust-based or script-based, and variables) into _modules_. Modules can be disabled via the [`no_module`] feature. -### Exporting variables and functions +### Exporting variables and functions from modules -A module is a single script (or pre-compiled `AST`) containing global variables and functions. +A _module_ is a single script (or pre-compiled `AST`) containing global variables and functions. The `export` statement, which can only be at global level, exposes selected variables as members of a module. -Variables not exported are private and invisible to the outside. -All functions are automatically exported, unless it is prefixed with `private`. +Variables not exported are _private_ and invisible to the outside. +On the other hand, all functions are automatically exported, _unless_ it is explicitly opt-out with the `private` prefix. Functions declared `private` are invisible to the outside. Everything exported from a module is **constant** (**read-only**). @@ -2070,11 +2105,11 @@ Everything exported from a module is **constant** (**read-only**). ```rust // This is a module script. -fn inc(x) { x + 1 } // public function +fn inc(x) { x + 1 } // script-defined function - default public private fn foo() {} // private function - invisible to outside -let private = 123; // variable not exported - invisible to outside +let private = 123; // variable not exported - default invisible to outside let x = 42; // this will be exported below export x; // the variable 'x' is exported under its own name @@ -2085,19 +2120,27 @@ export x as answer; // the variable 'x' is exported under the alias 'ans ### Importing modules -A module can be _imported_ via the `import` statement, and its members accessed via '`::`' similar to C++. +[`import`]: #importing-modules + +A module can be _imported_ via the `import` statement, and its members are accessed via '`::`' similar to C++. ```rust import "crypto" as crypto; // import the script file 'crypto.rhai' as a module crypto::encrypt(secret); // use functions defined under the module via '::' +crypto::hash::sha256(key); // sub-modules are also supported + print(crypto::status); // module variables are constants -crypto::hash::sha256(key); // sub-modules are also supported +crypto::status = "off"; // <- runtime error - cannot modify a constant ``` `import` statements are _scoped_, meaning that they are only accessible inside the scope that they're imported. +They can appear anywhere a normal statement can be, but in the vast majority of cases `import` statements are +group at the beginning of a script. It is not advised to deviate from this common practice unless there is +a _Very Good Reason™_. Especially, do not place an `import` statement within a loop; doing so will repeatedly +re-load the same module during every iteration of the loop! ```rust let mod = "crypto"; @@ -2110,9 +2153,15 @@ if secured { // new block scope crypto::encrypt(others); // <- this causes a run-time error because the 'crypto' module // is no longer available! + +for x in range(0, 1000) { + import "crypto" as c; // <- importing a module inside a loop is a Very Bad Idea™ + + c.encrypt(something); +} ``` -### Creating custom modules from Rust +### Creating custom modules with Rust To load a custom module (written in Rust) into an [`Engine`], first create a `Module` type, add variables/functions into it, then finally push it into a custom [`Scope`]. This has the equivalent effect of putting an `import` statement @@ -2141,8 +2190,9 @@ engine.eval_expression_with_scope::(&scope, "question::inc(question::answer ### Creating a module from an `AST` -It is easy to convert a pre-compiled `AST` into a module, just use `Module::eval_ast_as_new`. -Don't forget the `export` statement, otherwise there will be nothing inside the module! +It is easy to convert a pre-compiled `AST` into a module: just use `Module::eval_ast_as_new`. +Don't forget the `export` statement, otherwise there will be no variables exposed by the module +other than non-`private` functions (unless that's intentional). ```rust use rhai::{Engine, Module}; @@ -2202,7 +2252,7 @@ Built-in module resolvers are grouped under the `rhai::module_resolvers` module | `FileModuleResolver` | The default module resolution service, not available under the [`no_std`] feature. Loads a script file (based off the current directory) with `.rhai` extension.
The base directory can be changed via the `FileModuleResolver::new_with_path()` constructor function.
`FileModuleResolver::create_module()` loads a script file and returns a module. | | `StaticModuleResolver` | Loads modules that are statically added. This can be used when the [`no_std`] feature is turned on. | -An [`Engine`]'s module resolver is set via a call to `set_module_resolver`: +An [`Engine`]'s module resolver is set via a call to `Engine::set_module_resolver`: ```rust // Use the 'StaticModuleResolver' @@ -2213,9 +2263,186 @@ engine.set_module_resolver(Some(resolver)); engine.set_module_resolver(None); ``` +Ruggedization - protect against DoS attacks +------------------------------------------ + +For scripting systems open to user-land scripts, it is always best to limit the amount of resources used by a script +so that it does not consume more resources that it is allowed to. + +The most important resources to watch out for are: + +* **Memory**: A malignant script may continuously grow an [array] or [object map] until all memory is consumed. + It may also create a large [array] or [objecct map] literal that exhausts all memory during parsing. +* **CPU**: A malignant script may run an infinite tight loop that consumes all CPU cycles. +* **Time**: A malignant script may run indefinitely, thereby blocking the calling system which is waiting for a result. +* **Stack**: A malignant script may attempt an infinite recursive call that exhausts the call stack. + Alternatively, it may create a degenerated deep expression with so many levels that the parser exhausts the call stack + when parsing the expression; or even deeply-nested statement blocks, if nested deep enough. +* **Overflows**: A malignant script may deliberately cause numeric over-flows and/or under-flows, divide by zero, and/or + create bad floating-point representations, in order to crash the system. +* **Files**: A malignant script may continuously [`import`] an external module within an infinite loop, + thereby putting heavy load on the file-system (or even the network if the file is not local). + Even when modules are not created from files, they still typically consume a lot of resources to load. +* **Data**: A malignant script may attempt to read from and/or write to data that it does not own. If this happens, + it is a severe security breach and may put the entire system at risk. + +### Maximum number of operations + +Rhai by default does not limit how much time or CPU a script consumes. +This can be changed via the `Engine::set_max_operations` method, with zero being unlimited (the default). + +```rust +let mut engine = Engine::new(); + +engine.set_max_operations(500); // allow only up to 500 operations for this script + +engine.set_max_operations(0); // allow unlimited operations +``` + +The concept of one single _operation_ in Rhai is volatile - it roughly equals one expression node, +loading one variable/constant, one operator call, one iteration of a loop, or one function call etc. +with sub-expressions, statements and function calls executed inside these contexts accumulated on top. +A good rule-of-thumb is that one simple non-trivial expression consumes on average 5-10 operations. + +One _operation_ can take an unspecified amount of time and real CPU cycles, depending on the particulars. +For example, loading a constant consumes very few CPU cycles, while calling an external Rust function, +though also counted as only one operation, may consume much more computing resources. +If it helps to visualize, think of an _operation_ as roughly equals to one _instruction_ of a hypothetical CPU. + +The _operation count_ is intended to be a very course-grained measurement of the amount of CPU that a script +is consuming, and allows the system to impose a hard upper limit. + +A script exceeding the maximum operations count will terminate with an error result. +This check can be disabled via the [`unchecked`] feature for higher performance +(but higher risks as well). + +### Tracking progress + +To track script evaluation progress and to force-terminate a script prematurely (for any reason), +provide a closure to the `Engine::on_progress` method: + +```rust +let mut engine = Engine::new(); + +engine.on_progress(|count| { // 'count' is the number of operations performed + if count % 1000 == 0 { + println!("{}", count); // print out a progress log every 1,000 operations + } + true // return 'true' to continue the script + // returning 'false' will terminate the script +}); +``` + +The closure passed to `Engine::on_progress` will be called once every operation. +Return `false` to terminate the script immediately. + +### Maximum number of modules + +Rhai by default does not limit how many [modules] are loaded via the [`import`] statement. +This can be changed via the `Engine::set_max_modules` method, with zero being unlimited (the default). + +```rust +let mut engine = Engine::new(); + +engine.set_max_modules(5); // allow loading only up to 5 modules + +engine.set_max_modules(0); // allow unlimited modules +``` + +### Maximum call stack depth + +Rhai by default limits function calls to a maximum depth of 128 levels (16 levels in debug build). +This limit may be changed via the `Engine::set_max_call_levels` method. + +When setting this limit, care must be also taken to the evaluation depth of each _statement_ +within the function. It is entirely possible for a malignant script to embed an recursive call deep +inside a nested expression or statement block (see [maximum statement depth](#maximum-statement-depth)). + +The limit can be disabled via the [`unchecked`] feature for higher performance +(but higher risks as well). + +```rust +let mut engine = Engine::new(); + +engine.set_max_call_levels(10); // allow only up to 10 levels of function calls + +engine.set_max_call_levels(0); // allow no function calls at all (max depth = zero) +``` + +A script exceeding the maximum call stack depth will terminate with an error result. + +### Maximum statement depth + +Rhai by default limits statements and expressions nesting to a maximum depth of 128 +(which should be plenty) when they are at _global_ level, but only a depth of 32 +when they are within function bodies. For debug builds, these limits are set further +downwards to 32 and 16 respectively. + +That is because it is possible to overflow the [`Engine`]'s stack when it tries to +recursively parse an extremely deeply-nested code stream. + +```rust +// The following, if long enough, can easily cause stack overflow during parsing. +let a = (1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(...)+1))))))))))); +``` + +This limit may be changed via the `Engine::set_max_expr_depths` method. There are two limits to set, +one for the maximum depth at global level, and the other for function bodies. + +```rust +let mut engine = Engine::new(); + +engine.set_max_expr_depths(50, 5); // allow nesting up to 50 layers of expressions/statements + // at global level, but only 5 inside functions +``` + +Beware that there may be multiple layers for a simple language construct, even though it may correspond +to only one AST node. That is because the Rhai _parser_ internally runs a recursive chain of function calls +and it is important that a malignant script does not panic the parser in the first place. + +Functions are placed under stricter limits because of the multiplicative effect of recursion. +A script can effectively call itself while deep inside an expression chain within the function body, +thereby overflowing the stack even when the level of recursion is within limit. + +Make sure that `C x ( 5 + F ) + S` layered calls do not cause a stack overflow, where: + +* `C` = maximum call stack depth, +* `F` = maximum statement depth for functions, +* `S` = maximum statement depth at global level. + +A script exceeding the maximum nesting depths will terminate with a parsing error. +The malignant `AST` will not be able to get past parsing in the first place. + +The limits can be disabled via the [`unchecked`] feature for higher performance +(but higher risks as well). + +### Checked arithmetic + +By default, all arithmetic calculations in Rhai are _checked_, meaning that the script terminates +with an error whenever it detects a numeric over-flow/under-flow condition or an invalid +floating-point operation, instead of crashing the entire system. This checking can be turned off +via the [`unchecked`] feature for higher performance (but higher risks as well). + +### Blocking access to external data + +Rhai is _sand-boxed_ so a script can never read from outside its own environment. +Furthermore, an [`Engine`] created non-`mut` cannot mutate any state outside of itself; +so it is highly recommended that [`Engine`]'s are created immutable as much as possible. + +```rust +let mut engine = Engine::new(); // create mutable 'Engine' + +engine.register_get("add", add); // configure 'engine' + +let engine = engine; // shadow the variable so that 'engine' is now immutable +``` + + Script optimization =================== +[script optimization]: #script-optimization + Rhai includes an _optimizer_ that tries to optimize a script after parsing. This can reduce resource utilization and increase execution speed. Script optimization can be turned off via the [`no_optimize`] feature. @@ -2323,7 +2550,7 @@ There are actually three levels of optimizations: `None`, `Simple` and `Full`. * `Full` is _much_ more aggressive, _including_ running functions on constant arguments to determine their result. One benefit to this is that many more optimization opportunities arise, especially with regards to comparison operators. -An [`Engine`]'s optimization level is set via a call to `set_optimization_level`: +An [`Engine`]'s optimization level is set via a call to `Engine::set_optimization_level`: ```rust // Turn on aggressive optimizations @@ -2446,6 +2673,8 @@ engine.set_optimization_level(rhai::OptimizationLevel::None); `eval` - or "How to Shoot Yourself in the Foot even Easier" --------------------------------------------------------- +[`eval`]: #eval---or-how-to-shoot-yourself-in-the-foot-even-easier + Saving the best for last: in addition to script optimizations, there is the ever-dreaded... `eval` function! ```rust @@ -2501,9 +2730,11 @@ let x = eval("40 + 2"); // 'eval' here throws "eval is evil! I refuse to run Or override it from Rust: ```rust -fn alt_eval(script: String) -> Result<(), EvalAltResult> { +fn alt_eval(script: String) -> Result<(), Box> { Err(format!("eval is evil! I refuse to run {}", script).into()) } engine.register_result_fn("eval", alt_eval); ``` + +There is even a [package] named `EvalPackage` which implements the disabling override. diff --git a/RELEASES.md b/RELEASES.md new file mode 100644 index 00000000..8d01f9f5 --- /dev/null +++ b/RELEASES.md @@ -0,0 +1,80 @@ +Rhai Release Notes +================== + +Version 0.14.2 +============== + +Regression +---------- + +* Do not optimize script with `eval_expression` - it is assumed to be one-off and short. + +New features +------------ + +* Set limits on maximum level of nesting expressions and statements to avoid panics during parsing. + + +Version 0.14.1 +============== + +The major features for this release is modules, script resource limits, and speed improvements +(mainly due to avoiding allocations). + +New features +------------ + +* Modules and _module resolvers_ allow loading external scripts under a module namespace. + A module can contain constant variables, Rust functions and Rhai functions. +* `export` variables and `private` functions. +* _Indexers_ for Rust types. +* Track script evaluation progress and terminate script run. +* Set limit on maximum number of operations allowed per script run. +* Set limit on maximum number of modules loaded per script run. +* A new API, `Engine::compile_scripts_with_scope`, can compile a list of script segments without needing to + first concatenate them together into one large string. +* Stepped `range` function with a custom step. + +Speed improvements +------------------ + +### `StaticVec` + +A script contains many lists - statements in a block, arguments to a function call etc. +In a typical script, most of these lists tend to be short - e.g. the vast majority of function calls contain +fewer than 4 arguments, while most statement blocks have fewer than 4-5 statements, with one or two being +the most common. Before, dynamic `Vec`'s are used to hold these short lists for very brief periods of time, +causing allocations churn. + +In this version, large amounts of allocations are avoided by converting to a `StaticVec` - +a list type based on a static array for a small number of items (currently four) - +wherever possible plus other tricks. Most real-life scripts should see material speed increases. + +### Pre-computed variable lookups + +Almost all variable lookups, as well as lookups in loaded modules, are now pre-computed. +A variable's name is almost never used to search for the variable in the current scope. + +_Getters_ and _setter_ function names are also pre-computed and cached, so no string allocations are +performed during a property get/set call. + +### Pre-computed function call hashes + +Lookup of all function calls, including Rust and Rhai ones, are now through pre-computed hashes. +The function name is no longer used to search for a function, making function call dispatches +much faster. + +### Large Boxes for expressions and statements + +The expression (`Expr`) and statement (`Stmt`) types are modified so that all of the variants contain only +one single `Box` to a large allocated structure containing _all_ the fields. This makes the `Expr` and +`Stmt` types very small (only one single pointer) and improves evaluation speed due to cache efficiency. + +Error handling +-------------- + +Previously, when an error occurs inside a function call, the error position reported is the function +call site. This makes it difficult to diagnose the actual location of the error within the function. + +A new error variant `EvalAltResult::ErrorInFunctionCall` is added in this version. +It wraps the internal error returned by the called function, including the error position within the function. diff --git a/benches/eval_expression.rs b/benches/eval_expression.rs index 131d3bb5..c647c1b5 100644 --- a/benches/eval_expression.rs +++ b/benches/eval_expression.rs @@ -41,3 +41,67 @@ fn bench_eval_expression_number_operators(bench: &mut Bencher) { bench.iter(|| engine.consume_ast(&ast).unwrap()); } + +#[bench] +fn bench_eval_expression_optimized_simple(bench: &mut Bencher) { + let script = r#" + 2 > 1 && + "something" != "nothing" || + "2014-01-20" < "Wed Jul 8 23:07:35 MDT 2015" && + [array, with, spaces].len() <= #{prop:name}.len() && + modifierTest + 1000 / 2 > (80 * 100 % 2) + "#; + + let mut engine = Engine::new(); + engine.set_optimization_level(OptimizationLevel::Simple); + let ast = engine.compile_expression(script).unwrap(); + + bench.iter(|| engine.consume_ast(&ast).unwrap()); +} + +#[bench] +fn bench_eval_expression_optimized_full(bench: &mut Bencher) { + let script = r#" + 2 > 1 && + "something" != "nothing" || + "2014-01-20" < "Wed Jul 8 23:07:35 MDT 2015" && + [array, with, spaces].len() <= #{prop:name}.len() && + modifierTest + 1000 / 2 > (80 * 100 % 2) + "#; + + let mut engine = Engine::new(); + engine.set_optimization_level(OptimizationLevel::Full); + let ast = engine.compile_expression(script).unwrap(); + + bench.iter(|| engine.consume_ast(&ast).unwrap()); +} + +#[bench] +fn bench_eval_call_expression(bench: &mut Bencher) { + let script = r#" + 2 > 1 && + "something" != "nothing" || + "2014-01-20" < "Wed Jul 8 23:07:35 MDT 2015" && + [array, with, spaces].len() <= #{prop:name}.len() && + modifierTest + 1000 / 2 > (80 * 100 % 2) + "#; + + let mut engine = Engine::new(); + + bench.iter(|| engine.eval_expression::(script).unwrap()); +} + +#[bench] +fn bench_eval_call(bench: &mut Bencher) { + let script = r#" + 2 > 1 && + "something" != "nothing" || + "2014-01-20" < "Wed Jul 8 23:07:35 MDT 2015" && + [array, with, spaces].len() <= #{prop:name}.len() && + modifierTest + 1000 / 2 > (80 * 100 % 2) + "#; + + let mut engine = Engine::new(); + + bench.iter(|| engine.eval::(script).unwrap()); +} diff --git a/benches/parsing.rs b/benches/parsing.rs index c4486bd5..01011877 100644 --- a/benches/parsing.rs +++ b/benches/parsing.rs @@ -102,3 +102,35 @@ fn bench_parse_primes(bench: &mut Bencher) { bench.iter(|| engine.compile(script).unwrap()); } + +#[bench] +fn bench_parse_optimize_simple(bench: &mut Bencher) { + let script = r#" + 2 > 1 && + "something" != "nothing" || + "2014-01-20" < "Wed Jul 8 23:07:35 MDT 2015" && + [array, with, spaces].len() <= #{prop:name}.len() && + modifierTest + 1000 / 2 > (80 * 100 % 2) + "#; + + let mut engine = Engine::new(); + engine.set_optimization_level(OptimizationLevel::Simple); + + bench.iter(|| engine.compile_expression(script).unwrap()); +} + +#[bench] +fn bench_parse_optimize_full(bench: &mut Bencher) { + let script = r#" + 2 > 1 && + "something" != "nothing" || + "2014-01-20" < "Wed Jul 8 23:07:35 MDT 2015" && + [array, with, spaces].len() <= #{prop:name}.len() && + modifierTest + 1000 / 2 > (80 * 100 % 2) + "#; + + let mut engine = Engine::new(); + engine.set_optimization_level(OptimizationLevel::Full); + + bench.iter(|| engine.compile_expression(script).unwrap()); +} diff --git a/examples/hello.rs b/examples/hello.rs index edec8cb8..af5e8b9c 100644 --- a/examples/hello.rs +++ b/examples/hello.rs @@ -1,5 +1,4 @@ use rhai::{packages::*, Engine, EvalAltResult, INT}; -use std::rc::Rc; fn main() -> Result<(), Box> { let mut engine = Engine::new_raw(); diff --git a/examples/repl.rs b/examples/repl.rs index a8763e28..f980a98e 100644 --- a/examples/repl.rs +++ b/examples/repl.rs @@ -1,12 +1,9 @@ -use rhai::{Dynamic, Engine, EvalAltResult, Scope, AST, INT}; +use rhai::{Dynamic, Engine, EvalAltResult, Scope, AST}; #[cfg(not(feature = "no_optimize"))] use rhai::OptimizationLevel; -use std::{ - io::{stdin, stdout, Write}, - iter, -}; +use std::io::{stdin, stdout, Write}; fn print_error(input: &str, err: EvalAltResult) { let lines: Vec<_> = input.trim().split('\n').collect(); diff --git a/examples/rhai_runner.rs b/examples/rhai_runner.rs index 2bc273e2..c5c5128d 100644 --- a/examples/rhai_runner.rs +++ b/examples/rhai_runner.rs @@ -3,7 +3,7 @@ use rhai::{Engine, EvalAltResult}; #[cfg(not(feature = "no_optimize"))] use rhai::OptimizationLevel; -use std::{env, fs::File, io::Read, iter, process::exit}; +use std::{env, fs::File, io::Read, process::exit}; fn eprint_error(input: &str, err: EvalAltResult) { fn eprint_line(lines: &[&str], line: usize, pos: usize, err: &str) { diff --git a/scripts/fibonacci.rhai b/scripts/fibonacci.rhai index a9a54c3a..730dadae 100644 --- a/scripts/fibonacci.rhai +++ b/scripts/fibonacci.rhai @@ -3,8 +3,6 @@ const target = 30; -let now = timestamp(); - fn fib(n) { if n < 2 { n @@ -15,8 +13,14 @@ fn fib(n) { print("Ready... Go!"); +let now = timestamp(); + let result = fib(target); +print("Finished. Run time = " + now.elapsed() + " seconds."); + print("Fibonacci number #" + target + " = " + result); -print("Finished. Run time = " + now.elapsed() + " seconds."); +if result != 832_040 { + print("The answer is WRONG! Should be 832,040!"); +} \ No newline at end of file diff --git a/scripts/primes.rhai b/scripts/primes.rhai index 668fa250..2b67ec50 100644 --- a/scripts/primes.rhai +++ b/scripts/primes.rhai @@ -27,3 +27,7 @@ for p in range(2, MAX_NUMBER_TO_CHECK) { print("Total " + total_primes_found + " primes <= " + MAX_NUMBER_TO_CHECK); print("Run time = " + now.elapsed() + " seconds."); + +if total_primes_found != 9_592 { + print("The answer is WRONG! Should be 9,592!"); +} \ No newline at end of file diff --git a/src/any.rs b/src/any.rs index a96bcca2..7f209685 100644 --- a/src/any.rs +++ b/src/any.rs @@ -1,10 +1,11 @@ //! Helper module which defines the `Any` trait to to allow dynamic value handling. +use crate::parser::INT; +use crate::r#unsafe::{unsafe_cast_box, unsafe_try_cast}; + #[cfg(not(feature = "no_module"))] use crate::module::Module; -use crate::parser::INT; - #[cfg(not(feature = "no_float"))] use crate::parser::FLOAT; @@ -18,7 +19,7 @@ use crate::stdlib::{ any::{type_name, Any, TypeId}, boxed::Box, collections::HashMap, - fmt, mem, ptr, + fmt, string::String, vec::Vec, }; @@ -26,7 +27,7 @@ use crate::stdlib::{ #[cfg(not(feature = "no_std"))] use crate::stdlib::time::Instant; -/// A trait to represent any type. +/// Trait to represent any type. /// /// Currently, `Variant` is not `Send` nor `Sync`, so it can practically be any type. /// Turn on the `sync` feature to restrict it to only types that implement `Send + Sync`. @@ -80,7 +81,7 @@ impl Variant for T { } } -/// A trait to represent any type. +/// Trait to represent any type. /// /// `From<_>` is implemented for `i64` (`i32` if `only_i32`), `f64` (if not `no_float`), /// `bool`, `String`, `char`, `Vec` (into `Array`) and `HashMap` (into `Map`). @@ -93,7 +94,7 @@ pub trait Variant: Any + Send + Sync { fn as_mut_any(&mut self) -> &mut dyn Any; /// Convert this `Variant` trait object to an `Any` trait object. - fn as_box_any(self) -> Box; + fn as_box_any(self: Box) -> Box; /// Get the name of this type. fn type_name(&self) -> &'static str; @@ -141,7 +142,7 @@ impl dyn Variant { } } -/// A dynamic type containing any value. +/// Dynamic type containing any value. pub struct Dynamic(pub(crate) Union); /// Internal `Dynamic` representation. @@ -298,37 +299,6 @@ impl Default for Dynamic { } } -/// Cast a type into another type. -fn try_cast(a: A) -> Option { - if TypeId::of::() == 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 - // running or value otherwise being used again. - unsafe { - let ret: B = ptr::read(&a as *const _ as *const B); - mem::forget(a); - Some(ret) - } - } else { - None - } -} - -/// Cast a Boxed type into another type. -fn cast_box(item: Box) -> Result, Box> { - // Only allow casting to the exact same type - if TypeId::of::() == TypeId::of::() { - // SAFETY: just checked whether we are pointing to the correct type - unsafe { - let raw: *mut dyn Any = Box::into_raw(item as Box); - Ok(Box::from_raw(raw as *mut T)) - } - } else { - // Return the consumed item for chaining. - Err(item) - } -} - impl Dynamic { /// Create a `Dynamic` from any type. A `Dynamic` value is simply returned as is. /// @@ -383,17 +353,17 @@ impl Dynamic { let mut var = Box::new(value); - var = match cast_box::<_, Dynamic>(var) { + var = match unsafe_cast_box::<_, Dynamic>(var) { Ok(d) => return *d, Err(var) => var, }; - var = match cast_box::<_, String>(var) { + var = match unsafe_cast_box::<_, String>(var) { Ok(s) => return Self(Union::Str(s)), Err(var) => var, }; #[cfg(not(feature = "no_index"))] { - var = match cast_box::<_, Array>(var) { + var = match unsafe_cast_box::<_, Array>(var) { Ok(array) => return Self(Union::Array(array)), Err(var) => var, }; @@ -401,7 +371,7 @@ impl Dynamic { #[cfg(not(feature = "no_object"))] { - var = match cast_box::<_, Map>(var) { + var = match unsafe_cast_box::<_, Map>(var) { Ok(map) => return Self(Union::Map(map)), Err(var) => var, } @@ -426,23 +396,23 @@ impl Dynamic { /// ``` pub fn try_cast(self) -> Option { if TypeId::of::() == TypeId::of::() { - return cast_box::<_, T>(Box::new(self)).ok().map(|v| *v); + return unsafe_cast_box::<_, T>(Box::new(self)).ok().map(|v| *v); } match self.0 { - Union::Unit(value) => try_cast(value), - Union::Bool(value) => try_cast(value), - Union::Str(value) => cast_box::<_, T>(value).ok().map(|v| *v), - Union::Char(value) => try_cast(value), - Union::Int(value) => try_cast(value), + Union::Unit(value) => unsafe_try_cast(value), + Union::Bool(value) => unsafe_try_cast(value), + Union::Str(value) => unsafe_cast_box::<_, T>(value).ok().map(|v| *v), + Union::Char(value) => unsafe_try_cast(value), + Union::Int(value) => unsafe_try_cast(value), #[cfg(not(feature = "no_float"))] - Union::Float(value) => try_cast(value), + Union::Float(value) => unsafe_try_cast(value), #[cfg(not(feature = "no_index"))] - Union::Array(value) => cast_box::<_, T>(value).ok().map(|v| *v), + Union::Array(value) => unsafe_cast_box::<_, T>(value).ok().map(|v| *v), #[cfg(not(feature = "no_object"))] - Union::Map(value) => cast_box::<_, T>(value).ok().map(|v| *v), + Union::Map(value) => unsafe_cast_box::<_, T>(value).ok().map(|v| *v), #[cfg(not(feature = "no_module"))] - Union::Module(value) => cast_box::<_, T>(value).ok().map(|v| *v), + Union::Module(value) => unsafe_cast_box::<_, T>(value).ok().map(|v| *v), Union::Variant(value) => (*value).as_box_any().downcast().map(|x| *x).ok(), } } @@ -467,23 +437,23 @@ impl Dynamic { //self.try_cast::().unwrap() if TypeId::of::() == TypeId::of::() { - return *cast_box::<_, T>(Box::new(self)).unwrap(); + return *unsafe_cast_box::<_, T>(Box::new(self)).unwrap(); } match self.0 { - Union::Unit(value) => try_cast(value).unwrap(), - Union::Bool(value) => try_cast(value).unwrap(), - Union::Str(value) => *cast_box::<_, T>(value).unwrap(), - Union::Char(value) => try_cast(value).unwrap(), - Union::Int(value) => try_cast(value).unwrap(), + Union::Unit(value) => unsafe_try_cast(value).unwrap(), + Union::Bool(value) => unsafe_try_cast(value).unwrap(), + Union::Str(value) => *unsafe_cast_box::<_, T>(value).unwrap(), + Union::Char(value) => unsafe_try_cast(value).unwrap(), + Union::Int(value) => unsafe_try_cast(value).unwrap(), #[cfg(not(feature = "no_float"))] - Union::Float(value) => try_cast(value).unwrap(), + Union::Float(value) => unsafe_try_cast(value).unwrap(), #[cfg(not(feature = "no_index"))] - Union::Array(value) => *cast_box::<_, T>(value).unwrap(), + Union::Array(value) => *unsafe_cast_box::<_, T>(value).unwrap(), #[cfg(not(feature = "no_object"))] - Union::Map(value) => *cast_box::<_, T>(value).unwrap(), + Union::Map(value) => *unsafe_cast_box::<_, T>(value).unwrap(), #[cfg(not(feature = "no_module"))] - Union::Module(value) => *cast_box::<_, T>(value).unwrap(), + Union::Module(value) => *unsafe_cast_box::<_, T>(value).unwrap(), Union::Variant(value) => (*value).as_box_any().downcast().map(|x| *x).unwrap(), } } diff --git a/src/api.rs b/src/api.rs index 1918b487..48052e85 100644 --- a/src/api.rs +++ b/src/api.rs @@ -4,6 +4,7 @@ use crate::any::{Dynamic, Variant}; use crate::engine::{make_getter, make_setter, Engine, State, FUNC_INDEXER}; use crate::error::ParseError; use crate::fn_call::FuncArgs; +use crate::fn_native::{IteratorFn, ObjectGetCallback, ObjectIndexerCallback, ObjectSetCallback}; use crate::fn_register::RegisterFn; use crate::optimize::{optimize_into_ast, OptimizationLevel}; use crate::parser::{parse, parse_global_expr, AST}; @@ -18,60 +19,13 @@ use crate::engine::Map; use crate::stdlib::{ any::{type_name, TypeId}, boxed::Box, - collections::HashMap, mem, string::{String, ToString}, }; + #[cfg(not(feature = "no_std"))] use crate::stdlib::{fs::File, io::prelude::*, path::PathBuf}; -// Define callback function types -#[cfg(feature = "sync")] -pub trait ObjectGetCallback: Fn(&mut T) -> U + Send + Sync + 'static {} -#[cfg(feature = "sync")] -impl U + Send + Sync + 'static, T, U> ObjectGetCallback for F {} - -#[cfg(not(feature = "sync"))] -pub trait ObjectGetCallback: Fn(&mut T) -> U + 'static {} -#[cfg(not(feature = "sync"))] -impl U + 'static, T, U> ObjectGetCallback for F {} - -#[cfg(feature = "sync")] -pub trait ObjectSetCallback: Fn(&mut T, U) + Send + Sync + 'static {} -#[cfg(feature = "sync")] -impl ObjectSetCallback for F {} - -#[cfg(not(feature = "sync"))] -pub trait ObjectSetCallback: Fn(&mut T, U) + 'static {} -#[cfg(not(feature = "sync"))] -impl ObjectSetCallback for F {} - -#[cfg(feature = "sync")] -pub trait ObjectIndexerCallback: Fn(&mut T, X) -> U + Send + Sync + 'static {} -#[cfg(feature = "sync")] -impl U + Send + Sync + 'static, T, X, U> ObjectIndexerCallback for F {} - -#[cfg(not(feature = "sync"))] -pub trait ObjectIndexerCallback: Fn(&mut T, X) -> U + 'static {} -#[cfg(not(feature = "sync"))] -impl U + 'static, T, X, U> ObjectIndexerCallback for F {} - -#[cfg(feature = "sync")] -pub trait IteratorCallback: - Fn(Dynamic) -> Box> + Send + Sync + 'static -{ -} -#[cfg(feature = "sync")] -impl Box> + Send + Sync + 'static> IteratorCallback - for F -{ -} - -#[cfg(not(feature = "sync"))] -pub trait IteratorCallback: Fn(Dynamic) -> Box> + 'static {} -#[cfg(not(feature = "sync"))] -impl Box> + 'static> IteratorCallback for F {} - /// Engine public API impl Engine { /// Register a custom type for use with the `Engine`. @@ -167,10 +121,8 @@ impl Engine { /// Register an iterator adapter for a type with the `Engine`. /// This is an advanced feature. - pub fn register_iterator(&mut self, f: F) { - self.base_package - .type_iterators - .insert(TypeId::of::(), Box::new(f)); + pub fn register_iterator(&mut self, f: IteratorFn) { + self.global_module.set_iter(TypeId::of::(), f); } /// Register a getter function for a member of a registered type with the `Engine`. @@ -387,6 +339,7 @@ impl Engine { } /// Compile a string into an `AST` using own scope, which can be used later for evaluation. + /// /// The scope is useful for passing constants into the script for optimization /// when using `OptimizationLevel::Full`. /// @@ -424,19 +377,79 @@ impl Engine { /// # } /// ``` pub fn compile_with_scope(&self, scope: &Scope, script: &str) -> Result> { - self.compile_with_scope_and_optimization_level(scope, script, self.optimization_level) + self.compile_scripts_with_scope(scope, &[script]) } - /// Compile a string into an `AST` using own scope at a specific optimization level. + /// When passed a list of strings, first join the strings into one large script, + /// and then compile them into an `AST` using own scope, which can be used later for evaluation. + /// + /// The scope is useful for passing constants into the script for optimization + /// when using `OptimizationLevel::Full`. + /// + /// ## Note + /// + /// All strings are simply parsed one after another with nothing inserted in between, not even + /// a newline or space. + /// + /// # Example + /// + /// ``` + /// # fn main() -> Result<(), Box> { + /// # #[cfg(not(feature = "no_optimize"))] + /// # { + /// use rhai::{Engine, Scope, OptimizationLevel}; + /// + /// let mut engine = Engine::new(); + /// + /// // Set optimization level to 'Full' so the Engine can fold constants + /// // into function calls and operators. + /// engine.set_optimization_level(OptimizationLevel::Full); + /// + /// // Create initialized scope + /// let mut scope = Scope::new(); + /// scope.push_constant("x", 42_i64); // 'x' is a constant + /// + /// // Compile a script made up of script segments to an AST and store it for later evaluation. + /// // Notice that `Full` optimization is on, so constants are folded + /// // into function calls and operators. + /// let ast = engine.compile_scripts_with_scope(&mut scope, &[ + /// "if x > 40", // all 'x' are replaced with 42 + /// "{ x } el", + /// "se { 0 }" // segments do not need to be valid scripts! + /// ])?; + /// + /// // Normally this would have failed because no scope is passed into the 'eval_ast' + /// // call and so the variable 'x' does not exist. Here, it passes because the script + /// // has been optimized and all references to 'x' are already gone. + /// assert_eq!(engine.eval_ast::(&ast)?, 42); + /// # } + /// # Ok(()) + /// # } + /// ``` + pub fn compile_scripts_with_scope( + &self, + scope: &Scope, + scripts: &[&str], + ) -> Result> { + self.compile_with_scope_and_optimization_level(scope, scripts, self.optimization_level) + } + + /// Join a list of strings and compile into an `AST` using own scope at a specific optimization level. pub(crate) fn compile_with_scope_and_optimization_level( &self, scope: &Scope, - script: &str, + scripts: &[&str], optimization_level: OptimizationLevel, ) -> Result> { - let scripts = [script]; - let stream = lex(&scripts); - parse(&mut stream.peekable(), self, scope, optimization_level) + let stream = lex(scripts); + + parse( + &mut stream.peekable(), + self, + scope, + optimization_level, + (self.max_expr_depth, self.max_function_expr_depth), + ) } /// Read the contents of a file into a string. @@ -489,6 +502,7 @@ impl Engine { } /// Compile a script file into an `AST` using own scope, which can be used later for evaluation. + /// /// The scope is useful for passing constants into the script for optimization /// when using `OptimizationLevel::Full`. /// @@ -562,6 +576,7 @@ impl Engine { self, &scope, OptimizationLevel::None, + self.max_expr_depth, )?; // Handle null - map to () @@ -643,7 +658,16 @@ impl Engine { let scripts = [script]; let stream = lex(&scripts); - parse_global_expr(&mut stream.peekable(), self, scope, self.optimization_level) + { + let mut peekable = stream.peekable(); + parse_global_expr( + &mut peekable, + self, + scope, + self.optimization_level, + self.max_expr_depth, + ) + } } /// Evaluate a script file. @@ -739,9 +763,11 @@ impl Engine { scope: &mut Scope, script: &str, ) -> Result> { - // Since the AST will be thrown away afterwards, don't bother to optimize it - let ast = - self.compile_with_scope_and_optimization_level(scope, script, OptimizationLevel::None)?; + let ast = self.compile_with_scope_and_optimization_level( + scope, + &[script], + self.optimization_level, + )?; self.eval_ast_with_scope(scope, &ast) } @@ -791,8 +817,15 @@ impl Engine { ) -> Result> { let scripts = [script]; let stream = lex(&scripts); - // Since the AST will be thrown away afterwards, don't bother to optimize it - let ast = parse_global_expr(&mut stream.peekable(), self, scope, OptimizationLevel::None)?; + + let ast = parse_global_expr( + &mut stream.peekable(), + self, + scope, + OptimizationLevel::None, // No need to optimize a lone expression + self.max_expr_depth, + )?; + self.eval_ast_with_scope(scope, &ast) } @@ -852,13 +885,13 @@ impl Engine { scope: &mut Scope, ast: &AST, ) -> Result> { - let result = self.eval_ast_with_scope_raw(scope, ast)?; + let (result, _) = self.eval_ast_with_scope_raw(scope, ast)?; let return_type = self.map_type_name(result.type_name()); return result.try_cast::().ok_or_else(|| { Box::new(EvalAltResult::ErrorMismatchOutputType( - return_type.to_string(), + return_type.into(), Position::none(), )) }); @@ -868,7 +901,7 @@ impl Engine { &self, scope: &mut Scope, ast: &AST, - ) -> Result> { + ) -> Result<(Dynamic, u64), Box> { let mut state = State::new(ast.fn_lib()); ast.statements() @@ -880,6 +913,7 @@ impl Engine { EvalAltResult::Return(out, _) => Ok(out), _ => Err(err), }) + .map(|v| (v, state.operations)) } /// Evaluate a file, but throw away the result and only return error (if any). @@ -916,8 +950,13 @@ impl Engine { let scripts = [script]; let stream = lex(&scripts); - // Since the AST will be thrown away afterwards, don't bother to optimize it - let ast = parse(&mut stream.peekable(), self, scope, OptimizationLevel::None)?; + let ast = parse( + &mut stream.peekable(), + self, + scope, + self.optimization_level, + (self.max_expr_depth, self.max_function_expr_depth), + )?; self.consume_ast_with_scope(scope, &ast) } @@ -1000,11 +1039,12 @@ impl Engine { let fn_def = fn_lib .get_function_by_signature(name, args.len(), true) - .ok_or_else(|| Box::new(EvalAltResult::ErrorFunctionNotFound(name.to_string(), pos)))?; + .ok_or_else(|| Box::new(EvalAltResult::ErrorFunctionNotFound(name.into(), pos)))?; let state = State::new(fn_lib); + let args = args.as_mut(); - let result = self.call_script_fn(Some(scope), &state, fn_def, args.as_mut(), pos, 0)?; + let (result, _) = self.call_script_fn(Some(scope), state, name, fn_def, args, pos, 0)?; let return_type = self.map_type_name(result.type_name()); @@ -1044,6 +1084,84 @@ impl Engine { optimize_into_ast(self, scope, stmt, fn_lib, optimization_level) } + /// Register a callback for script evaluation progress. + /// + /// # Example + /// + /// ``` + /// # fn main() -> Result<(), Box> { + /// # use std::sync::RwLock; + /// # use std::sync::Arc; + /// use rhai::Engine; + /// + /// let result = Arc::new(RwLock::new(0_u64)); + /// let logger = result.clone(); + /// + /// let mut engine = Engine::new(); + /// + /// engine.on_progress(move |ops| { + /// if ops > 10000 { + /// false + /// } else if ops % 800 == 0 { + /// *logger.write().unwrap() = ops; + /// true + /// } else { + /// true + /// } + /// }); + /// + /// engine.consume("for x in range(0, 50000) {}") + /// .expect_err("should error"); + /// + /// assert_eq!(*result.read().unwrap(), 9600); + /// + /// # Ok(()) + /// # } + /// ``` + #[cfg(feature = "sync")] + pub fn on_progress(&mut self, callback: impl Fn(u64) -> bool + Send + Sync + 'static) { + self.progress = Some(Box::new(callback)); + } + + /// Register a callback for script evaluation progress. + /// + /// # Example + /// + /// ``` + /// # fn main() -> Result<(), Box> { + /// # use std::cell::Cell; + /// # use std::rc::Rc; + /// use rhai::Engine; + /// + /// let result = Rc::new(Cell::new(0_u64)); + /// let logger = result.clone(); + /// + /// let mut engine = Engine::new(); + /// + /// engine.on_progress(move |ops| { + /// if ops > 10000 { + /// false + /// } else if ops % 800 == 0 { + /// logger.set(ops); + /// true + /// } else { + /// true + /// } + /// }); + /// + /// engine.consume("for x in range(0, 50000) {}") + /// .expect_err("should error"); + /// + /// assert_eq!(result.get(), 9600); + /// + /// # Ok(()) + /// # } + /// ``` + #[cfg(not(feature = "sync"))] + pub fn on_progress(&mut self, callback: impl Fn(u64) -> bool + 'static) { + self.progress = Some(Box::new(callback)); + } + /// Override default action of `print` (print to stdout using `println!`) /// /// # Example @@ -1078,21 +1196,21 @@ impl Engine { /// /// ``` /// # fn main() -> Result<(), Box> { - /// # use std::sync::RwLock; - /// # use std::sync::Arc; + /// # use std::cell::RefCell; + /// # use std::rc::Rc; /// use rhai::Engine; /// - /// let result = Arc::new(RwLock::new(String::from(""))); + /// let result = Rc::new(RefCell::new(String::from(""))); /// /// let mut engine = Engine::new(); /// /// // Override action of 'print' function /// let logger = result.clone(); - /// engine.on_print(move |s| logger.write().unwrap().push_str(s)); + /// engine.on_print(move |s| logger.borrow_mut().push_str(s)); /// /// engine.consume("print(40 + 2);")?; /// - /// assert_eq!(*result.read().unwrap(), "42"); + /// assert_eq!(*result.borrow(), "42"); /// # Ok(()) /// # } /// ``` @@ -1135,21 +1253,21 @@ impl Engine { /// /// ``` /// # fn main() -> Result<(), Box> { - /// # use std::sync::RwLock; - /// # use std::sync::Arc; + /// # use std::cell::RefCell; + /// # use std::rc::Rc; /// use rhai::Engine; /// - /// let result = Arc::new(RwLock::new(String::from(""))); + /// let result = Rc::new(RefCell::new(String::from(""))); /// /// let mut engine = Engine::new(); /// /// // Override action of 'print' function /// let logger = result.clone(); - /// engine.on_debug(move |s| logger.write().unwrap().push_str(s)); + /// engine.on_debug(move |s| logger.borrow_mut().push_str(s)); /// /// engine.consume(r#"debug("hello");"#)?; /// - /// assert_eq!(*result.read().unwrap(), r#""hello""#); + /// assert_eq!(*result.borrow(), r#""hello""#); /// # Ok(()) /// # } /// ``` diff --git a/src/engine.rs b/src/engine.rs index 8428de09..cb3b0e8c 100644 --- a/src/engine.rs +++ b/src/engine.rs @@ -3,18 +3,19 @@ use crate::any::{Dynamic, Union}; use crate::calc_fn_hash; use crate::error::ParseErrorType; +use crate::fn_native::{FnCallArgs, PrintCallback, ProgressCallback, SharedFnDef}; +use crate::module::Module; use crate::optimize::OptimizationLevel; -use crate::packages::{ - CorePackage, Package, PackageLibrary, PackageStore, PackagesCollection, StandardPackage, -}; +use crate::packages::{CorePackage, Package, PackageLibrary, PackagesCollection, StandardPackage}; use crate::parser::{Expr, FnAccess, FnDef, ReturnType, Stmt, AST}; +use crate::r#unsafe::unsafe_cast_var_name_to_lifetime; use crate::result::EvalAltResult; use crate::scope::{EntryType as ScopeEntryType, Scope}; use crate::token::Position; -use crate::utils::{StaticVec, EMPTY_TYPE_ID}; +use crate::utils::StaticVec; #[cfg(not(feature = "no_module"))] -use crate::module::{resolvers, Module, ModuleRef, ModuleResolver}; +use crate::module::{resolvers, ModuleRef, ModuleResolver}; #[cfg(feature = "no_module")] use crate::parser::ModuleRef; @@ -24,7 +25,7 @@ use crate::stdlib::{ boxed::Box, collections::HashMap, format, - iter::{empty, once, repeat}, + iter::{empty, once}, mem, num::NonZeroUsize, ops::{Deref, DerefMut}, @@ -34,36 +35,44 @@ use crate::stdlib::{ vec::Vec, }; -/// An dynamic array of `Dynamic` values. +/// Variable-sized array of `Dynamic` values. /// /// Not available under the `no_index` feature. #[cfg(not(feature = "no_index"))] pub type Array = Vec; -/// An dynamic hash map of `Dynamic` values with `String` keys. +/// Hash map of `Dynamic` values with `String` keys. /// /// Not available under the `no_object` feature. #[cfg(not(feature = "no_object"))] pub type Map = HashMap; -pub type FnCallArgs<'a> = [&'a mut Dynamic]; - -#[cfg(feature = "sync")] -pub type FnAny = - dyn Fn(&mut FnCallArgs, Position) -> Result> + Send + Sync; -#[cfg(not(feature = "sync"))] -pub type FnAny = dyn Fn(&mut FnCallArgs, Position) -> Result>; - -#[cfg(feature = "sync")] -pub type IteratorFn = dyn Fn(Dynamic) -> Box> + Send + Sync; -#[cfg(not(feature = "sync"))] -pub type IteratorFn = dyn Fn(Dynamic) -> Box>; - +#[cfg(not(feature = "unchecked"))] #[cfg(debug_assertions)] -pub const MAX_CALL_STACK_DEPTH: usize = 28; +pub const MAX_CALL_STACK_DEPTH: usize = 16; +#[cfg(not(feature = "unchecked"))] +#[cfg(debug_assertions)] +pub const MAX_EXPR_DEPTH: usize = 32; +#[cfg(not(feature = "unchecked"))] +#[cfg(debug_assertions)] +pub const MAX_FUNCTION_EXPR_DEPTH: usize = 16; +#[cfg(not(feature = "unchecked"))] #[cfg(not(debug_assertions))] -pub const MAX_CALL_STACK_DEPTH: usize = 256; +pub const MAX_CALL_STACK_DEPTH: usize = 128; +#[cfg(not(feature = "unchecked"))] +#[cfg(not(debug_assertions))] +pub const MAX_EXPR_DEPTH: usize = 128; +#[cfg(not(feature = "unchecked"))] +#[cfg(not(debug_assertions))] +pub const MAX_FUNCTION_EXPR_DEPTH: usize = 32; + +#[cfg(feature = "unchecked")] +pub const MAX_CALL_STACK_DEPTH: usize = usize::MAX; +#[cfg(feature = "unchecked")] +pub const MAX_EXPR_DEPTH: usize = usize::MAX; +#[cfg(feature = "unchecked")] +pub const MAX_FUNCTION_EXPR_DEPTH: usize = usize::MAX; pub const KEYWORD_PRINT: &str = "print"; pub const KEYWORD_DEBUG: &str = "debug"; @@ -79,19 +88,36 @@ enum Target<'a> { /// The target is a mutable reference to a `Dynamic` value somewhere. Ref(&'a mut Dynamic), /// The target is a temporary `Dynamic` value (i.e. the mutation can cause no side effects). - Value(Box), + Value(Dynamic), /// The target is a character inside a String. /// This is necessary because directly pointing to a char inside a String is impossible. - StringChar(Box<(&'a mut Dynamic, usize, Dynamic)>), + StringChar(&'a mut Dynamic, usize, Dynamic), } impl Target<'_> { - /// Get the value of the `Target` as a `Dynamic`. + /// Is the `Target` a reference pointing to other data? + pub fn is_ref(&self) -> bool { + match self { + Target::Ref(_) => true, + Target::Value(_) | Target::StringChar(_, _, _) => false, + } + } + + /// Get the value of the `Target` as a `Dynamic`, cloning a referenced value if necessary. pub fn clone_into_dynamic(self) -> Dynamic { match self { - Target::Ref(r) => r.clone(), - Target::Value(v) => *v, - Target::StringChar(s) => s.2, + Target::Ref(r) => r.clone(), // Referenced value is cloned + Target::Value(v) => v, // Owned value is simply taken + Target::StringChar(_, _, ch) => ch, // Character is taken + } + } + + /// Get a mutable reference from the `Target`. + pub fn as_mut(&mut self) -> &mut Dynamic { + match self { + Target::Ref(r) => *r, + Target::Value(ref mut r) => r, + Target::StringChar(_, _, ref mut r) => r, } } @@ -102,25 +128,23 @@ impl Target<'_> { Target::Value(_) => { return Err(Box::new(EvalAltResult::ErrorAssignmentToUnknownLHS(pos))) } - Target::StringChar(x) => match x.0 { - Dynamic(Union::Str(s)) => { - // Replace the character at the specified index position - let new_ch = new_val - .as_char() - .map_err(|_| EvalAltResult::ErrorCharMismatch(pos))?; + Target::StringChar(Dynamic(Union::Str(s)), index, _) => { + // Replace the character at the specified index position + let new_ch = new_val + .as_char() + .map_err(|_| EvalAltResult::ErrorCharMismatch(pos))?; - let mut chars: StaticVec = s.chars().collect(); - let ch = *chars.get_ref(x.1); + let mut chars: StaticVec = s.chars().collect(); + let ch = chars[*index]; - // See if changed - if so, update the String - if ch != new_ch { - *chars.get_mut(x.1) = new_ch; - s.clear(); - chars.iter().for_each(|&ch| s.push(ch)); - } + // See if changed - if so, update the String + if ch != new_ch { + chars[*index] = new_ch; + s.clear(); + chars.iter().for_each(|&ch| s.push(ch)); } - _ => unreachable!(), - }, + } + _ => unreachable!(), } Ok(()) @@ -134,11 +158,16 @@ impl<'a> From<&'a mut Dynamic> for Target<'a> { } impl> From for Target<'_> { fn from(value: T) -> Self { - Self::Value(Box::new(value.into())) + Self::Value(value.into()) } } /// A type that holds all the current states of the Engine. +/// +/// # Safety +/// +/// This type uses some unsafe code, mainly for avoiding cloning of local variable names via +/// direct lifetime casting. #[derive(Debug, Clone, Copy)] pub struct State<'a> { /// Global script-defined functions. @@ -148,14 +177,27 @@ pub struct State<'a> { /// In some situation, e.g. after running an `eval` statement, subsequent offsets may become mis-aligned. /// When that happens, this flag is turned on to force a scope lookup by name. pub always_search: bool, + + /// Level of the current scope. The global (root) level is zero, a new block (or function call) + /// is one level higher, and so on. + pub scope_level: usize, + + /// Number of operations performed. + pub operations: u64, + + /// Number of modules loaded. + pub modules: u64, } impl<'a> State<'a> { /// Create a new `State`. pub fn new(fn_lib: &'a FunctionsLib) -> Self { Self { - always_search: false, fn_lib, + always_search: false, + scope_level: 0, + operations: 0, + modules: 0, } } /// Does a certain script-defined function exist in the `State`? @@ -164,33 +206,18 @@ impl<'a> State<'a> { } /// Get a script-defined function definition from the `State`. pub fn get_function(&self, hash: u64) -> Option<&FnDef> { - self.fn_lib.get(&hash).map(|f| f.as_ref()) + self.fn_lib.get(&hash).map(|fn_def| fn_def.as_ref()) } } -/// An external native Rust function. -#[cfg(not(feature = "sync"))] -pub type NativeFunction = Rc>; -/// An external native Rust function. -#[cfg(feature = "sync")] -pub type NativeFunction = Arc>; - -/// A sharable script-defined function. -#[cfg(feature = "sync")] -pub type ScriptedFunction = Arc; -/// A sharable script-defined function. -#[cfg(not(feature = "sync"))] -pub type ScriptedFunction = Rc; - /// A type that holds a library (`HashMap`) of script-defined functions. /// /// Since script-defined functions have `Dynamic` parameters, functions with the same name /// and number of parameters are considered equivalent. /// -/// The key of the `HashMap` is a `u64` hash calculated by the function `calc_fn_hash` -/// with dummy parameter types `EMPTY_TYPE_ID()` repeated the correct number of times. +/// The key of the `HashMap` is a `u64` hash calculated by the function `calc_fn_hash`. #[derive(Debug, Clone, Default)] -pub struct FunctionsLib(HashMap); +pub struct FunctionsLib(HashMap); impl FunctionsLib { /// Create a new `FunctionsLib` from a collection of `FnDef`. @@ -198,21 +225,9 @@ impl FunctionsLib { FunctionsLib( vec.into_iter() .map(|fn_def| { - // Qualifiers (none) + function name + placeholders (one for each parameter). - let hash = calc_fn_hash( - empty(), - &fn_def.name, - repeat(EMPTY_TYPE_ID()).take(fn_def.params.len()), - ); - - #[cfg(feature = "sync")] - { - (hash, Arc::new(fn_def)) - } - #[cfg(not(feature = "sync"))] - { - (hash, Rc::new(fn_def)) - } + // Qualifiers (none) + function name + number of arguments. + let hash = calc_fn_hash(empty(), &fn_def.name, fn_def.params.len(), empty()); + (hash, fn_def.into()) }) .collect(), ) @@ -220,14 +235,14 @@ impl FunctionsLib { /// Does a certain function exist in the `FunctionsLib`? /// /// The `u64` hash is calculated by the function `crate::calc_fn_hash`. - pub fn has_function(&self, hash: u64) -> bool { - self.contains_key(&hash) + pub fn has_function(&self, hash_fn_def: u64) -> bool { + self.contains_key(&hash_fn_def) } /// Get a function definition from the `FunctionsLib`. /// /// The `u64` hash is calculated by the function `crate::calc_fn_hash`. - pub fn get_function(&self, hash: u64) -> Option<&FnDef> { - self.get(&hash).map(|fn_def| fn_def.as_ref()) + pub fn get_function(&self, hash_fn_def: u64) -> Option<&FnDef> { + self.get(&hash_fn_def).map(|fn_def| fn_def.as_ref()) } /// Get a function definition from the `FunctionsLib`. pub fn get_function_by_signature( @@ -236,15 +251,14 @@ impl FunctionsLib { params: usize, public_only: bool, ) -> Option<&FnDef> { - // Qualifiers (none) + function name + placeholders (one for each parameter). - let hash = calc_fn_hash(empty(), name, repeat(EMPTY_TYPE_ID()).take(params)); - let fn_def = self.get_function(hash); + // Qualifiers (none) + function name + number of arguments. + let hash_fn_def = calc_fn_hash(empty(), name, params, empty()); + let fn_def = self.get_function(hash_fn_def); match fn_def.as_ref().map(|f| f.access) { None => None, Some(FnAccess::Private) if public_only => None, - Some(FnAccess::Private) => fn_def, - Some(FnAccess::Public) => fn_def, + Some(FnAccess::Private) | Some(FnAccess::Public) => fn_def, } } /// Merge another `FunctionsLib` into this `FunctionsLib`. @@ -261,8 +275,8 @@ impl FunctionsLib { } } -impl From> for FunctionsLib { - fn from(values: Vec<(u64, ScriptedFunction)>) -> Self { +impl From> for FunctionsLib { + fn from(values: Vec<(u64, SharedFnDef)>) -> Self { FunctionsLib(values.into_iter().collect()) } } @@ -306,10 +320,10 @@ impl DerefMut for FunctionsLib { /// /// Currently, `Engine` is neither `Send` nor `Sync`. Turn on the `sync` feature to make it `Send + Sync`. pub struct Engine { - /// A collection of all library packages loaded into the engine. + /// A module containing all functions directly loaded into the Engine. + pub(crate) global_module: Module, + /// A collection of all library packages loaded into the Engine. pub(crate) packages: PackagesCollection, - /// A collection of all library packages loaded into the engine. - pub(crate) base_package: PackageStore, /// A module resolution service. #[cfg(not(feature = "no_module"))] @@ -319,26 +333,26 @@ pub struct Engine { pub(crate) type_names: HashMap, /// Closure for implementing the `print` command. - #[cfg(feature = "sync")] - pub(crate) print: Box, - /// Closure for implementing the `print` command. - #[cfg(not(feature = "sync"))] - pub(crate) print: Box, - + pub(crate) print: Box, /// Closure for implementing the `debug` command. - #[cfg(feature = "sync")] - pub(crate) debug: Box, - /// Closure for implementing the `debug` command. - #[cfg(not(feature = "sync"))] - pub(crate) debug: Box, + pub(crate) debug: Box, + /// Closure for progress reporting. + pub(crate) progress: Option>, /// Optimize the AST after compilation. pub(crate) optimization_level: OptimizationLevel, - /// Maximum levels of call-stack to prevent infinite recursion. /// - /// Defaults to 28 for debug builds and 256 for non-debug builds. + /// Defaults to 16 for debug builds and 128 for non-debug builds. pub(crate) max_call_stack_depth: usize, + /// Maximum depth of statements/expressions at global level. + pub(crate) max_expr_depth: usize, + /// Maximum depth of statements/expressions in functions. + pub(crate) max_function_expr_depth: usize, + /// Maximum number of operations allowed to run. + pub(crate) max_operations: u64, + /// Maximum number of modules allowed to load. + pub(crate) max_modules: u64, } impl Default for Engine { @@ -346,7 +360,7 @@ impl Default for Engine { // Create the new scripting Engine let mut engine = Self { packages: Default::default(), - base_package: Default::default(), + global_module: Default::default(), #[cfg(not(feature = "no_module"))] #[cfg(not(feature = "no_std"))] @@ -361,6 +375,9 @@ impl Default for Engine { print: Box::new(default_print), debug: Box::new(default_print), + // progress callback + progress: None, + // optimization level #[cfg(feature = "no_optimize")] optimization_level: OptimizationLevel::None, @@ -374,6 +391,10 @@ impl Default for Engine { optimization_level: OptimizationLevel::Full, max_call_stack_depth: MAX_CALL_STACK_DEPTH, + max_expr_depth: MAX_EXPR_DEPTH, + max_function_expr_depth: MAX_FUNCTION_EXPR_DEPTH, + max_operations: u64::MAX, + max_modules: u64::MAX, }; #[cfg(feature = "no_stdlib")] @@ -445,9 +466,7 @@ fn search_scope<'a>( ) -> Result<(&'a mut Dynamic, ScopeEntryType), Box> { #[cfg(not(feature = "no_module"))] { - if let Some((modules, hash)) = modules { - let (id, root_pos) = modules.get_ref(0); - + if let Some((modules, hash_var)) = modules { let module = if let Some(index) = modules.index() { scope .get_mut(scope.len() - index.get()) @@ -455,16 +474,15 @@ fn search_scope<'a>( .downcast_mut::() .unwrap() } else { + let (id, root_pos) = modules.get(0); + scope.find_module(id).ok_or_else(|| { - Box::new(EvalAltResult::ErrorModuleNotFound( - id.to_string(), - *root_pos, - )) + Box::new(EvalAltResult::ErrorModuleNotFound(id.into(), *root_pos)) })? }; return Ok(( - module.get_qualified_var_mut(name, hash, pos)?, + module.get_qualified_var_mut(name, hash_var, pos)?, // Module variables are constant ScopeEntryType::Constant, )); @@ -494,7 +512,7 @@ impl Engine { pub fn new_raw() -> Self { Self { packages: Default::default(), - base_package: Default::default(), + global_module: Default::default(), #[cfg(not(feature = "no_module"))] module_resolver: None, @@ -502,6 +520,7 @@ impl Engine { type_names: Default::default(), print: Box::new(|_| {}), debug: Box::new(|_| {}), + progress: None, #[cfg(feature = "no_optimize")] optimization_level: OptimizationLevel::None, @@ -515,6 +534,10 @@ impl Engine { optimization_level: OptimizationLevel::Full, max_call_stack_depth: MAX_CALL_STACK_DEPTH, + max_expr_depth: MAX_EXPR_DEPTH, + max_function_expr_depth: MAX_FUNCTION_EXPR_DEPTH, + max_operations: u64::MAX, + max_modules: u64::MAX, } } @@ -546,10 +569,35 @@ impl Engine { /// Set the maximum levels of function calls allowed for a script in order to avoid /// infinite recursion and stack overflows. + #[cfg(not(feature = "unchecked"))] pub fn set_max_call_levels(&mut self, levels: usize) { self.max_call_stack_depth = levels } + /// Set the maximum number of operations allowed for a script to run to avoid + /// consuming too much resources (0 for unlimited). + #[cfg(not(feature = "unchecked"))] + pub fn set_max_operations(&mut self, operations: u64) { + self.max_operations = if operations == 0 { + u64::MAX + } else { + operations + }; + } + + /// Set the maximum number of imported modules allowed for a script (0 for unlimited). + #[cfg(not(feature = "unchecked"))] + pub fn set_max_modules(&mut self, modules: u64) { + self.max_modules = if modules == 0 { u64::MAX } else { modules }; + } + + /// Set the depth limits for expressions/statements. + #[cfg(not(feature = "unchecked"))] + pub fn set_max_expr_depths(&mut self, max_expr_depth: usize, max_function_expr_depth: usize) { + self.max_expr_depth = max_expr_depth; + self.max_function_expr_depth = max_function_expr_depth; + } + /// Set the module resolution service used by the `Engine`. /// /// Not available under the `no_module` feature. @@ -568,59 +616,90 @@ impl Engine { pub(crate) fn call_fn_raw( &self, scope: Option<&mut Scope>, - state: &State, + state: &mut State, fn_name: &str, - hash_fn_spec: u64, - hash_fn_def: u64, + hashes: (u64, u64), args: &mut FnCallArgs, + is_ref: bool, def_val: Option<&Dynamic>, pos: Position, level: usize, - ) -> Result> { + ) -> Result<(Dynamic, bool), Box> { + self.inc_operations(state, pos)?; + // Check for stack overflow if level > self.max_call_stack_depth { return Err(Box::new(EvalAltResult::ErrorStackOverflow(pos))); } // First search in script-defined functions (can override built-in) - if hash_fn_def > 0 { - if let Some(fn_def) = state.get_function(hash_fn_def) { - return self.call_script_fn(scope, state, fn_def, args, pos, level); + if hashes.1 > 0 { + if let Some(fn_def) = state.get_function(hashes.1) { + let (result, state2) = + self.call_script_fn(scope, *state, fn_name, fn_def, args, pos, level)?; + *state = state2; + return Ok((result, false)); } } // Search built-in's and external functions if let Some(func) = self - .base_package - .get_function(hash_fn_spec) - .or_else(|| self.packages.get_function(hash_fn_spec)) + .global_module + .get_fn(hashes.0) + .or_else(|| self.packages.get_fn(hashes.0)) { + // Calling pure function in method-call? + let backup: Option = if func.is_pure() && is_ref && args.len() > 0 { + // Backup the original value. It'll be consumed because the function + // is pure and doesn't know that the first value is a reference (i.e. `is_ref`) + Some(args[0].clone()) + } else { + None + }; + // Run external function - let result = func(args, pos)?; + let result = match func.get_native_fn()(args) { + Ok(r) => { + // Restore the backup value for the first argument since it has been consumed! + if let Some(backup) = backup { + *args[0] = backup; + } + r + } + Err(err) => { + return Err(err.new_position(pos)); + } + }; // See if the function match print/debug (which requires special processing) return Ok(match fn_name { - KEYWORD_PRINT => (self.print)(result.as_str().map_err(|type_name| { - Box::new(EvalAltResult::ErrorMismatchOutputType( - type_name.into(), - pos, - )) - })?) - .into(), - KEYWORD_DEBUG => (self.debug)(result.as_str().map_err(|type_name| { - Box::new(EvalAltResult::ErrorMismatchOutputType( - type_name.into(), - pos, - )) - })?) - .into(), - _ => result, + KEYWORD_PRINT => ( + (self.print)(result.as_str().map_err(|type_name| { + Box::new(EvalAltResult::ErrorMismatchOutputType( + type_name.into(), + pos, + )) + })?) + .into(), + false, + ), + KEYWORD_DEBUG => ( + (self.debug)(result.as_str().map_err(|type_name| { + Box::new(EvalAltResult::ErrorMismatchOutputType( + type_name.into(), + pos, + )) + })?) + .into(), + false, + ), + _ => (result, func.is_method()), }); } // Return default value (if any) if let Some(val) = def_val { - return Ok(val.clone()); + return Ok((val.clone(), false)); } // Getter function not found? @@ -666,31 +745,36 @@ impl Engine { /// Function call arguments may be _consumed_ when the function requires them to be passed by value. /// All function arguments not in the first position are always passed by value and thus consumed. /// **DO NOT** reuse the argument values unless for the first `&mut` argument - all others are silently replaced by `()`! - pub(crate) fn call_script_fn<'a>( + pub(crate) fn call_script_fn<'s>( &self, scope: Option<&mut Scope>, - state: &State, + mut state: State<'s>, + fn_name: &str, fn_def: &FnDef, args: &mut FnCallArgs, pos: Position, level: usize, - ) -> Result> { + ) -> Result<(Dynamic, State<'s>), Box> { + let orig_scope_level = state.scope_level; + state.scope_level += 1; + match scope { // Extern scope passed in which is not empty Some(scope) if scope.len() > 0 => { let scope_len = scope.len(); - let mut state = State::new(state.fn_lib); - // Put arguments into scope as variables - variable name is copied + // Put arguments into scope as variables + // Actually consume the arguments instead of cloning them scope.extend( fn_def .params .iter() - .zip( - // Actually consume the arguments instead of cloning them - args.into_iter().map(|v| mem::take(*v)), - ) - .map(|(name, value)| (name.clone(), ScopeEntryType::Normal, value)), + .zip(args.iter_mut().map(|v| mem::take(*v))) + .map(|(name, value)| { + let var_name = + unsafe_cast_var_name_to_lifetime(name.as_str(), &mut state); + (var_name, ScopeEntryType::Normal, value) + }), ); // Evaluate the function at one higher level of call depth @@ -699,50 +783,74 @@ impl Engine { .or_else(|err| match *err { // Convert return statement to return value EvalAltResult::Return(x, _) => Ok(x), - _ => Err(EvalAltResult::set_position(err, pos)), + EvalAltResult::ErrorInFunctionCall(name, err, _) => { + Err(Box::new(EvalAltResult::ErrorInFunctionCall( + format!("{} > {}", fn_name, name), + err, + pos, + ))) + } + _ => Err(Box::new(EvalAltResult::ErrorInFunctionCall( + fn_name.to_string(), + err, + pos, + ))), }); + // Remove all local variables scope.rewind(scope_len); + state.scope_level = orig_scope_level; - return result; + return result.map(|v| (v, state)); } // No new scope - create internal scope _ => { let mut scope = Scope::new(); - let mut state = State::new(state.fn_lib); // Put arguments into scope as variables + // Actually consume the arguments instead of cloning them scope.extend( fn_def .params .iter() - .zip( - // Actually consume the arguments instead of cloning them - args.into_iter().map(|v| mem::take(*v)), - ) + .zip(args.iter_mut().map(|v| mem::take(*v))) .map(|(name, value)| (name, ScopeEntryType::Normal, value)), ); // Evaluate the function at one higher level of call depth - return self + let result = self .eval_stmt(&mut scope, &mut state, &fn_def.body, level + 1) .or_else(|err| match *err { // Convert return statement to return value EvalAltResult::Return(x, _) => Ok(x), - _ => Err(EvalAltResult::set_position(err, pos)), + EvalAltResult::ErrorInFunctionCall(name, err, _) => { + Err(Box::new(EvalAltResult::ErrorInFunctionCall( + format!("{} > {}", fn_name, name), + err, + pos, + ))) + } + _ => Err(Box::new(EvalAltResult::ErrorInFunctionCall( + fn_name.to_string(), + err, + pos, + ))), }); + + state.scope_level = orig_scope_level; + return result.map(|v| (v, state)); } } } // Has a system function an override? - fn has_override(&self, state: &State, hash_fn_spec: u64, hash_fn_def: u64) -> bool { + fn has_override(&self, state: &State, hashes: (u64, u64)) -> bool { // First check registered functions - self.base_package.contains_function(hash_fn_spec) + self.global_module.contains_fn(hashes.0) // Then check packages - || self.packages.contains_function(hash_fn_spec) + || self.packages.contains_fn(hashes.0) // Then check script-defined functions - || state.has_function(hash_fn_def) + || state.has_function(hashes.1) } // Perform an actual function call, taking care of special functions @@ -754,46 +862,42 @@ impl Engine { /// **DO NOT** reuse the argument values unless for the first `&mut` argument - all others are silently replaced by `()`! fn exec_fn_call( &self, - state: &State, + state: &mut State, fn_name: &str, hash_fn_def: u64, args: &mut FnCallArgs, + is_ref: bool, def_val: Option<&Dynamic>, pos: Position, level: usize, - ) -> Result> { - // Qualifiers (none) + function name + argument `TypeId`'s. - let hash_fn_spec = calc_fn_hash(empty(), fn_name, args.iter().map(|a| a.type_id())); + ) -> Result<(Dynamic, bool), Box> { + // Qualifiers (none) + function name + number of arguments + argument `TypeId`'s. + let hash_fn = calc_fn_hash( + empty(), + fn_name, + args.len(), + args.iter().map(|a| a.type_id()), + ); + let hashes = (hash_fn, hash_fn_def); match fn_name { // type_of - KEYWORD_TYPE_OF - if args.len() == 1 && !self.has_override(state, hash_fn_spec, hash_fn_def) => - { - Ok(self.map_type_name(args[0].type_name()).to_string().into()) - } + KEYWORD_TYPE_OF if args.len() == 1 && !self.has_override(state, hashes) => Ok(( + self.map_type_name(args[0].type_name()).to_string().into(), + false, + )), // eval - reaching this point it must be a method-style call - KEYWORD_EVAL - if args.len() == 1 && !self.has_override(state, hash_fn_spec, hash_fn_def) => - { + KEYWORD_EVAL if args.len() == 1 && !self.has_override(state, hashes) => { Err(Box::new(EvalAltResult::ErrorRuntime( "'eval' should not be called in method style. Try eval(...);".into(), pos, ))) } - // Normal method call + // Normal function call _ => self.call_fn_raw( - None, - state, - fn_name, - hash_fn_spec, - hash_fn_def, - args, - def_val, - pos, - level, + None, state, fn_name, hashes, args, is_ref, def_val, pos, level, ), } } @@ -802,7 +906,7 @@ impl Engine { fn eval_script_expr( &self, scope: &mut Scope, - state: &State, + state: &mut State, script: &Dynamic, pos: Position, ) -> Result> { @@ -814,7 +918,7 @@ impl Engine { // No optimizations because we only run it once let mut ast = self.compile_with_scope_and_optimization_level( &Scope::new(), - script, + &[script], OptimizationLevel::None, )?; @@ -829,15 +933,21 @@ impl Engine { let ast = AST::new(statements, state.fn_lib.clone()); // Evaluate the AST - self.eval_ast_with_scope_raw(scope, &ast) - .map_err(|err| EvalAltResult::set_position(err, pos)) + let (result, operations) = self + .eval_ast_with_scope_raw(scope, &ast) + .map_err(|err| err.new_position(pos))?; + + state.operations += operations; + self.inc_operations(state, pos)?; + + return Ok(result); } /// Chain-evaluate a dot/index chain. fn eval_dot_index_chain_helper( &self, - state: &State, - mut target: Target, + state: &mut State, + target: &mut Target, rhs: &Expr, idx_values: &mut StaticVec, is_index: bool, @@ -845,12 +955,10 @@ impl Engine { level: usize, mut new_val: Option, ) -> Result<(Dynamic, bool), Box> { + let is_ref = target.is_ref(); + // Get a reference to the mutation target Dynamic - let obj = match target { - Target::Ref(r) => r, - Target::Value(ref mut r) => r.as_mut(), - Target::StringChar(ref mut x) => &mut x.2, - }; + let obj = target.as_mut(); // Pop the last index value let mut idx_val = idx_values.pop(); @@ -859,40 +967,37 @@ impl Engine { match rhs { // xxx[idx].dot_rhs... | xxx[idx][dot_rhs]... Expr::Dot(x) | Expr::Index(x) => { - let is_index = matches!(rhs, Expr::Index(_)); + let is_idx = matches!(rhs, Expr::Index(_)); + let pos = x.0.position(); + let this_ptr = &mut self + .get_indexed_mut(state, obj, is_ref, idx_val, pos, op_pos, false)?; - let indexed_val = - self.get_indexed_mut(state, obj, idx_val, x.0.position(), op_pos, false)?; self.eval_dot_index_chain_helper( - state, - indexed_val, - &x.1, - idx_values, - is_index, - x.2, - level, - new_val, + state, this_ptr, &x.1, idx_values, is_idx, x.2, level, new_val, ) } // xxx[rhs] = new_val _ if new_val.is_some() => { - let mut indexed_val = - self.get_indexed_mut(state, obj, idx_val, rhs.position(), op_pos, true)?; - indexed_val.set_value(new_val.unwrap(), rhs.position())?; + let pos = rhs.position(); + let this_ptr = &mut self + .get_indexed_mut(state, obj, is_ref, idx_val, pos, op_pos, true)?; + + this_ptr.set_value(new_val.unwrap(), rhs.position())?; Ok((Default::default(), true)) } // xxx[rhs] _ => self - .get_indexed_mut(state, obj, idx_val, rhs.position(), op_pos, false) + .get_indexed_mut(state, obj, is_ref, idx_val, rhs.position(), op_pos, false) .map(|v| (v.clone_into_dynamic(), false)), } } else { match rhs { // xxx.fn_name(arg_expr_list) Expr::FnCall(x) if x.1.is_none() => { - let ((name, pos), _, hash, _, def_val) = x.as_ref(); + let ((name, pos), _, hash_fn_def, _, def_val) = x.as_ref(); + let def_val = def_val.as_ref(); - let mut args: StaticVec<_> = once(obj) + let mut arg_values: StaticVec<_> = once(obj) .chain( idx_val .downcast_mut::>() @@ -900,103 +1005,97 @@ impl Engine { .iter_mut(), ) .collect(); - // A function call is assumed to have side effects, so the value is changed - // TODO - Remove assumption of side effects by checking whether the first parameter is &mut - self.exec_fn_call(state, name, *hash, args.as_mut(), def_val.as_ref(), *pos, 0) - .map(|v| (v, true)) + let args = arg_values.as_mut(); + + self.exec_fn_call(state, name, *hash_fn_def, args, is_ref, def_val, *pos, 0) } // xxx.module::fn_name(...) - syntax error Expr::FnCall(_) => unreachable!(), // {xxx:map}.id = ??? #[cfg(not(feature = "no_object"))] Expr::Property(x) if obj.is::() && new_val.is_some() => { - let index = x.0.clone().into(); - let mut indexed_val = - self.get_indexed_mut(state, obj, index, x.1, op_pos, true)?; - indexed_val.set_value(new_val.unwrap(), rhs.position())?; + let ((prop, _, _), pos) = x.as_ref(); + let index = prop.clone().into(); + let mut val = + self.get_indexed_mut(state, obj, is_ref, index, *pos, op_pos, true)?; + + val.set_value(new_val.unwrap(), rhs.position())?; Ok((Default::default(), true)) } // {xxx:map}.id #[cfg(not(feature = "no_object"))] Expr::Property(x) if obj.is::() => { - let index = x.0.clone().into(); - let indexed_val = - self.get_indexed_mut(state, obj, index, x.1, op_pos, false)?; - Ok((indexed_val.clone_into_dynamic(), false)) + let ((prop, _, _), pos) = x.as_ref(); + let index = prop.clone().into(); + let val = + self.get_indexed_mut(state, obj, is_ref, index, *pos, op_pos, false)?; + + Ok((val.clone_into_dynamic(), false)) } - // xxx.id = ??? a + // xxx.id = ??? Expr::Property(x) if new_val.is_some() => { - let fn_name = make_setter(&x.0); + let ((_, _, setter), pos) = x.as_ref(); let mut args = [obj, new_val.as_mut().unwrap()]; - self.exec_fn_call(state, &fn_name, 0, &mut args, None, x.1, 0) - .map(|v| (v, true)) + self.exec_fn_call(state, setter, 0, &mut args, is_ref, None, *pos, 0) + .map(|(v, _)| (v, true)) } // xxx.id Expr::Property(x) => { - let fn_name = make_getter(&x.0); + let ((_, getter, _), pos) = x.as_ref(); let mut args = [obj]; - self.exec_fn_call(state, &fn_name, 0, &mut args, None, x.1, 0) - .map(|v| (v, false)) + self.exec_fn_call(state, getter, 0, &mut args, is_ref, None, *pos, 0) + .map(|(v, _)| (v, false)) } #[cfg(not(feature = "no_object"))] // {xxx:map}.idx_lhs[idx_expr] | {xxx:map}.dot_lhs.rhs Expr::Index(x) | Expr::Dot(x) if obj.is::() => { - let is_index = matches!(rhs, Expr::Index(_)); + let is_idx = matches!(rhs, Expr::Index(_)); - let indexed_val = if let Expr::Property(p) = &x.0 { - let index = p.0.clone().into(); - self.get_indexed_mut(state, obj, index, x.2, op_pos, false)? + let mut val = if let Expr::Property(p) = &x.0 { + let ((prop, _, _), _) = p.as_ref(); + let index = prop.clone().into(); + self.get_indexed_mut(state, obj, is_ref, index, x.2, op_pos, false)? } else { // Syntax error return Err(Box::new(EvalAltResult::ErrorDotExpr( - "".to_string(), + "".into(), rhs.position(), ))); }; + self.eval_dot_index_chain_helper( - state, - indexed_val, - &x.1, - idx_values, - is_index, - x.2, - level, - new_val, + state, &mut val, &x.1, idx_values, is_idx, x.2, level, new_val, ) } // xxx.idx_lhs[idx_expr] | xxx.dot_lhs.rhs Expr::Index(x) | Expr::Dot(x) => { - let is_index = matches!(rhs, Expr::Index(_)); - let mut args = [obj, &mut Default::default()]; + let is_idx = matches!(rhs, Expr::Index(_)); + let args = &mut [obj, &mut Default::default()]; - let indexed_val = &mut (if let Expr::Property(p) = &x.0 { - let fn_name = make_getter(&p.0); - self.exec_fn_call(state, &fn_name, 0, &mut args[..1], None, x.2, 0)? + let (mut val, updated) = if let Expr::Property(p) = &x.0 { + let ((_, getter, _), _) = p.as_ref(); + self.exec_fn_call(state, getter, 0, &mut args[..1], is_ref, None, x.2, 0)? } else { // Syntax error return Err(Box::new(EvalAltResult::ErrorDotExpr( - "".to_string(), + "".into(), rhs.position(), ))); - }); + }; + let val = &mut val; + let target = &mut val.into(); + let (result, may_be_changed) = self.eval_dot_index_chain_helper( - state, - indexed_val.into(), - &x.1, - idx_values, - is_index, - x.2, - level, - new_val, + state, target, &x.1, idx_values, is_idx, x.2, level, new_val, )?; // Feed the value back via a setter just in case it has been updated - if may_be_changed { + if updated || may_be_changed { if let Expr::Property(p) = &x.0 { - let fn_name = make_setter(&p.0); + let ((_, _, setter), _) = p.as_ref(); // Re-use args because the first &mut parameter will not be consumed - args[1] = indexed_val; - self.exec_fn_call(state, &fn_name, 0, &mut args, None, x.2, 0) + args[1] = val; + self.exec_fn_call(state, setter, 0, args, is_ref, None, x.2, 0) .or_else(|err| match *err { // If there is no setter, no need to feed it back because the property is read-only EvalAltResult::ErrorDotExpr(_, _) => Ok(Default::default()), @@ -1009,7 +1108,7 @@ impl Engine { } // Syntax error _ => Err(Box::new(EvalAltResult::ErrorDotExpr( - "".to_string(), + "".into(), rhs.position(), ))), } @@ -1035,10 +1134,11 @@ impl Engine { match dot_lhs { // id.??? or id[???] Expr::Variable(x) => { - let ((name, pos), modules, hash, index) = x.as_ref(); + let ((name, pos), modules, hash_var, index) = x.as_ref(); let index = if state.always_search { None } else { *index }; - let mod_and_hash = modules.as_ref().map(|m| (m, *hash)); + let mod_and_hash = modules.as_ref().map(|m| (m, *hash_var)); let (target, typ) = search_scope(scope, &name, mod_and_hash, index, *pos)?; + self.inc_operations(state, *pos)?; // Constants cannot be modified match typ { @@ -1052,7 +1152,7 @@ impl Engine { ScopeEntryType::Constant | ScopeEntryType::Normal => (), } - let this_ptr = target.into(); + let this_ptr = &mut target.into(); self.eval_dot_index_chain_helper( state, this_ptr, dot_rhs, idx_values, is_index, op_pos, level, new_val, ) @@ -1067,7 +1167,7 @@ impl Engine { // {expr}.??? or {expr}[???] expr => { let val = self.eval_expr(scope, state, expr, level)?; - let this_ptr = val.into(); + let this_ptr = &mut val.into(); self.eval_dot_index_chain_helper( state, this_ptr, dot_rhs, idx_values, is_index, op_pos, level, new_val, ) @@ -1090,13 +1190,14 @@ impl Engine { size: usize, level: usize, ) -> Result<(), Box> { + self.inc_operations(state, expr.position())?; + match expr { Expr::FnCall(x) if x.1.is_none() => { - let mut arg_values = StaticVec::::new(); - - for arg_expr in x.3.iter() { - arg_values.push(self.eval_expr(scope, state, arg_expr, level)?); - } + let arg_values = + x.3.iter() + .map(|arg_expr| self.eval_expr(scope, state, arg_expr, level)) + .collect::, _>>()?; idx_values.push(Dynamic::from(arg_values)); } @@ -1123,14 +1224,15 @@ impl Engine { /// Get the value at the indexed position of a base type fn get_indexed_mut<'a>( &self, - state: &State, + state: &mut State, val: &'a mut Dynamic, + is_ref: bool, mut idx: Dynamic, idx_pos: Position, op_pos: Position, create: bool, ) -> Result, Box> { - let type_name = self.map_type_name(val.type_name()); + self.inc_operations(state, op_pos)?; match val { #[cfg(not(feature = "no_index"))] @@ -1174,43 +1276,31 @@ impl Engine { #[cfg(not(feature = "no_index"))] Dynamic(Union::Str(s)) => { // val_string[idx] + let chars_len = s.chars().count(); let index = idx .as_int() .map_err(|_| EvalAltResult::ErrorNumericIndexExpr(idx_pos))?; if index >= 0 { - let ch = s.chars().nth(index as usize).ok_or_else(|| { - Box::new(EvalAltResult::ErrorStringBounds( - s.chars().count(), - index, - idx_pos, - )) + let offset = index as usize; + let ch = s.chars().nth(offset).ok_or_else(|| { + Box::new(EvalAltResult::ErrorStringBounds(chars_len, index, idx_pos)) })?; - - Ok(Target::StringChar(Box::new(( - val, - index as usize, - ch.into(), - )))) + Ok(Target::StringChar(val, offset, ch.into())) } else { Err(Box::new(EvalAltResult::ErrorStringBounds( - s.chars().count(), - index, - idx_pos, + chars_len, index, idx_pos, ))) } } _ => { + let type_name = self.map_type_name(val.type_name()); let args = &mut [val, &mut idx]; - self.exec_fn_call(state, FUNC_INDEXER, 0, args, None, op_pos, 0) - .map(|v| v.into()) + self.exec_fn_call(state, FUNC_INDEXER, 0, args, is_ref, None, op_pos, 0) + .map(|(v, _)| v.into()) .map_err(|_| { - Box::new(EvalAltResult::ErrorIndexingType( - // Error - cannot be indexed - type_name.to_string(), - op_pos, - )) + Box::new(EvalAltResult::ErrorIndexingType(type_name.into(), op_pos)) }) } } @@ -1225,35 +1315,32 @@ impl Engine { rhs: &Expr, level: usize, ) -> Result> { - let lhs_value = self.eval_expr(scope, state, lhs, level)?; + self.inc_operations(state, rhs.position())?; + + let mut lhs_value = self.eval_expr(scope, state, lhs, level)?; let rhs_value = self.eval_expr(scope, state, rhs, level)?; match rhs_value { #[cfg(not(feature = "no_index"))] - Dynamic(Union::Array(rhs_value)) => { + Dynamic(Union::Array(mut rhs_value)) => { let op = "=="; let def_value = false.into(); - let fn_def = calc_fn_hash(empty(), op, repeat(EMPTY_TYPE_ID()).take(2)); + let hash_fn_def = calc_fn_hash(empty(), op, 2, empty()); // Call the `==` operator to compare each value - for value in rhs_value.iter() { - // WARNING - Always clone the values here because they'll be consumed by the function call. - // Do not pass the `&mut` straight through because the `==` implementation - // very likely takes parameters passed by value! - let args = &mut [&mut lhs_value.clone(), &mut value.clone()]; + for value in rhs_value.iter_mut() { + let args = &mut [&mut lhs_value, value]; let def_value = Some(&def_value); let pos = rhs.position(); // Qualifiers (none) + function name + argument `TypeId`'s. - let fn_spec = calc_fn_hash(empty(), op, args.iter().map(|a| a.type_id())); + let hash_fn = + calc_fn_hash(empty(), op, args.len(), args.iter().map(|a| a.type_id())); + let hashes = (hash_fn, hash_fn_def); - if self - .call_fn_raw( - None, state, op, fn_spec, fn_def, args, def_value, pos, level, - )? - .as_bool() - .unwrap_or(false) - { + let (r, _) = self + .call_fn_raw(None, state, op, hashes, args, true, def_value, pos, level)?; + if r.as_bool().unwrap_or(false) { return Ok(true.into()); } } @@ -1263,13 +1350,13 @@ impl Engine { #[cfg(not(feature = "no_object"))] Dynamic(Union::Map(rhs_value)) => match lhs_value { // Only allows String or char - Dynamic(Union::Str(s)) => Ok(rhs_value.contains_key(s.as_ref()).into()), + Dynamic(Union::Str(s)) => Ok(rhs_value.contains_key(s.as_str()).into()), Dynamic(Union::Char(c)) => Ok(rhs_value.contains_key(&c.to_string()).into()), _ => Err(Box::new(EvalAltResult::ErrorInExpr(lhs.position()))), }, Dynamic(Union::Str(rhs_value)) => match lhs_value { // Only allows String or char - Dynamic(Union::Str(s)) => Ok(rhs_value.contains(s.as_ref()).into()), + Dynamic(Union::Str(s)) => Ok(rhs_value.contains(s.as_str()).into()), Dynamic(Union::Char(c)) => Ok(rhs_value.contains(c).into()), _ => Err(Box::new(EvalAltResult::ErrorInExpr(lhs.position()))), }, @@ -1285,6 +1372,8 @@ impl Engine { expr: &Expr, level: usize, ) -> Result> { + self.inc_operations(state, expr.position())?; + match expr { Expr::IntegerConstant(x) => Ok(x.0.into()), #[cfg(not(feature = "no_float"))] @@ -1292,9 +1381,9 @@ impl Engine { Expr::StringConstant(x) => Ok(x.0.to_string().into()), Expr::CharConstant(x) => Ok(x.0.into()), Expr::Variable(x) => { - let ((name, pos), modules, hash, index) = x.as_ref(); + let ((name, pos), modules, hash_var, index) = x.as_ref(); let index = if state.always_search { None } else { *index }; - let mod_and_hash = modules.as_ref().map(|m| (m, *hash)); + let mod_and_hash = modules.as_ref().map(|m| (m, *hash_var)); let (val, _) = search_scope(scope, name, mod_and_hash, index, *pos)?; Ok(val.clone()) } @@ -1311,17 +1400,18 @@ impl Engine { match &x.0 { // name = rhs Expr::Variable(x) => { - let ((name, pos), modules, hash, index) = x.as_ref(); + let ((name, pos), modules, hash_var, index) = x.as_ref(); let index = if state.always_search { None } else { *index }; - let mod_and_hash = modules.as_ref().map(|m| (m, *hash)); - let (value_ptr, typ) = - search_scope(scope, name, mod_and_hash, index, *pos)?; + let mod_and_hash = modules.as_ref().map(|m| (m, *hash_var)); + let (lhs_ptr, typ) = search_scope(scope, name, mod_and_hash, index, *pos)?; + self.inc_operations(state, *pos)?; + match typ { ScopeEntryType::Constant => Err(Box::new( EvalAltResult::ErrorAssignmentToConstant(name.clone(), *pos), )), ScopeEntryType::Normal => { - *value_ptr = rhs_val; + *lhs_ptr = rhs_val; Ok(Default::default()) } // End variable cannot be a module @@ -1390,6 +1480,7 @@ impl Engine { // Normal function call Expr::FnCall(x) if x.1.is_none() => { let ((name, pos), _, hash_fn_def, args_expr, def_val) = x.as_ref(); + let def_val = def_val.as_ref(); let mut arg_values = args_expr .iter() @@ -1398,39 +1489,31 @@ impl Engine { let mut args: StaticVec<_> = arg_values.iter_mut().collect(); - let hash_fn_spec = - calc_fn_hash(empty(), KEYWORD_EVAL, once(TypeId::of::())); + if name == KEYWORD_EVAL && args.len() == 1 && args.get(0).is::() { + let hash_fn = calc_fn_hash(empty(), name, 1, once(TypeId::of::())); - if name == KEYWORD_EVAL - && args.len() == 1 - && !self.has_override(state, hash_fn_spec, *hash_fn_def) - { - // eval - only in function call style - let prev_len = scope.len(); + if !self.has_override(state, (hash_fn, *hash_fn_def)) { + // eval - only in function call style + let prev_len = scope.len(); + let pos = args_expr.get(0).position(); - // Evaluate the text string as a script - let result = - self.eval_script_expr(scope, state, args.pop(), args_expr[0].position()); + // Evaluate the text string as a script + let result = self.eval_script_expr(scope, state, args.pop(), pos); - if scope.len() != prev_len { - // IMPORTANT! If the eval defines new variables in the current scope, - // all variable offsets from this point on will be mis-aligned. - state.always_search = true; + if scope.len() != prev_len { + // IMPORTANT! If the eval defines new variables in the current scope, + // all variable offsets from this point on will be mis-aligned. + state.always_search = true; + } + + return result; } - - result - } else { - // Normal function call - except for eval (handled above) - self.exec_fn_call( - state, - name, - *hash_fn_def, - args.as_mut(), - def_val.as_ref(), - *pos, - level, - ) } + + // Normal function call - except for eval (handled above) + let args = args.as_mut(); + self.exec_fn_call(state, name, *hash_fn_def, args, false, def_val, *pos, level) + .map(|(v, _)| v) } // Module-qualified function call @@ -1446,7 +1529,7 @@ impl Engine { let mut args: StaticVec<_> = arg_values.iter_mut().collect(); - let (id, root_pos) = modules.get_ref(0); // First module + let (id, root_pos) = modules.get(0); // First module let module = if let Some(index) = modules.index() { scope @@ -1461,25 +1544,43 @@ impl Engine { }; // First search in script-defined functions (can override built-in) - if let Some(fn_def) = module.get_qualified_scripted_fn(*hash_fn_def) { - self.call_script_fn(None, state, fn_def, args.as_mut(), *pos, level) - } else { - // Then search in Rust functions + let func = match module.get_qualified_fn(name, *hash_fn_def) { + Err(err) if matches!(*err, EvalAltResult::ErrorFunctionNotFound(_, _)) => { + // Then search in Rust functions + self.inc_operations(state, *pos)?; - // Rust functions are indexed in two steps: - // 1) Calculate a hash in a similar manner to script-defined functions, - // i.e. qualifiers + function name + dummy parameter types (one for each parameter). - // 2) Calculate a second hash with no qualifiers, empty function name, and - // the actual list of parameter `TypeId`'.s - let hash_fn_args = calc_fn_hash(empty(), "", args.iter().map(|a| a.type_id())); - // 3) The final hash is the XOR of the two hashes. - let hash = *hash_fn_def ^ hash_fn_args; + // Rust functions are indexed in two steps: + // 1) Calculate a hash in a similar manner to script-defined functions, + // i.e. qualifiers + function name + number of arguments. + // 2) Calculate a second hash with no qualifiers, empty function name, + // zero number of arguments, and the actual list of argument `TypeId`'.s + let hash_fn_args = + calc_fn_hash(empty(), "", 0, args.iter().map(|a| a.type_id())); + // 3) The final hash is the XOR of the two hashes. + let hash_fn_native = *hash_fn_def ^ hash_fn_args; - match module.get_qualified_fn(name, hash, *pos) { - Ok(func) => func(args.as_mut(), *pos), - Err(_) if def_val.is_some() => Ok(def_val.clone().unwrap()), - Err(err) => Err(err), + module.get_qualified_fn(name, hash_fn_native) } + r => r, + }; + + match func { + Ok(x) if x.is_script() => { + let args = args.as_mut(); + let fn_def = x.get_fn_def(); + let (result, state2) = + self.call_script_fn(None, *state, name, fn_def, args, *pos, level)?; + *state = state2; + Ok(result) + } + Ok(x) => x.get_native_fn()(args.as_mut()).map_err(|err| err.new_position(*pos)), + Err(err) + if def_val.is_some() + && matches!(*err, EvalAltResult::ErrorFunctionNotFound(_, _)) => + { + Ok(def_val.clone().unwrap()) + } + Err(err) => Err(err), } } @@ -1530,13 +1631,15 @@ impl Engine { } /// Evaluate a statement - pub(crate) fn eval_stmt( + pub(crate) fn eval_stmt<'s>( &self, - scope: &mut Scope, + scope: &mut Scope<'s>, state: &mut State, stmt: &Stmt, level: usize, ) -> Result> { + self.inc_operations(state, stmt.position())?; + match stmt { // No-op Stmt::Noop(_) => Ok(Default::default()), @@ -1545,23 +1648,24 @@ impl Engine { Stmt::Expr(expr) => { let result = self.eval_expr(scope, state, expr, level)?; - Ok(if let Expr::Assignment(_) = *expr.as_ref() { + Ok(match expr.as_ref() { // If it is an assignment, erase the result at the root - Default::default() - } else { - result + Expr::Assignment(_) => Default::default(), + _ => result, }) } // Block scope Stmt::Block(x) => { let prev_len = scope.len(); + state.scope_level += 1; let result = x.0.iter().try_fold(Default::default(), |_, stmt| { self.eval_stmt(scope, state, stmt, level) }); scope.rewind(prev_len); + state.scope_level -= 1; // The impact of an eval statement goes away at the end of a block // because any new variables introduced will go out of scope @@ -1571,24 +1675,29 @@ impl Engine { } // If-else statement - Stmt::IfThenElse(x) => self - .eval_expr(scope, state, &x.0, level)? - .as_bool() - .map_err(|_| Box::new(EvalAltResult::ErrorLogicGuard(x.0.position()))) - .and_then(|guard_val| { - if guard_val { - self.eval_stmt(scope, state, &x.1, level) - } else if let Some(stmt) = &x.2 { - self.eval_stmt(scope, state, stmt, level) - } else { - Ok(Default::default()) - } - }), + Stmt::IfThenElse(x) => { + let (expr, if_block, else_block) = x.as_ref(); + + self.eval_expr(scope, state, expr, level)? + .as_bool() + .map_err(|_| Box::new(EvalAltResult::ErrorLogicGuard(expr.position()))) + .and_then(|guard_val| { + if guard_val { + self.eval_stmt(scope, state, if_block, level) + } else if let Some(stmt) = else_block { + self.eval_stmt(scope, state, stmt, level) + } else { + Ok(Default::default()) + } + }) + } // While loop Stmt::While(x) => loop { - match self.eval_expr(scope, state, &x.0, level)?.as_bool() { - Ok(true) => match self.eval_stmt(scope, state, &x.1, level) { + let (expr, body) = x.as_ref(); + + match self.eval_expr(scope, state, expr, level)?.as_bool() { + Ok(true) => match self.eval_stmt(scope, state, body, level) { Ok(_) => (), Err(err) => match *err { EvalAltResult::ErrorLoopBreak(false, _) => (), @@ -1597,7 +1706,9 @@ impl Engine { }, }, Ok(false) => return Ok(Default::default()), - Err(_) => return Err(Box::new(EvalAltResult::ErrorLogicGuard(x.0.position()))), + Err(_) => { + return Err(Box::new(EvalAltResult::ErrorLogicGuard(expr.position()))) + } } }, @@ -1615,23 +1726,26 @@ impl Engine { // For loop Stmt::For(x) => { - let iter_type = self.eval_expr(scope, state, &x.1, level)?; + let (name, expr, stmt) = x.as_ref(); + let iter_type = self.eval_expr(scope, state, expr, level)?; let tid = iter_type.type_id(); - if let Some(iter_fn) = self - .base_package - .get_iterator(tid) - .or_else(|| self.packages.get_iterator(tid)) + if let Some(func) = self + .global_module + .get_iter(tid) + .or_else(|| self.packages.get_iter(tid)) { // Add the loop variable - let name = x.0.clone(); - scope.push(name, ()); + let var_name = unsafe_cast_var_name_to_lifetime(name, &state); + scope.push(var_name, ()); let index = scope.len() - 1; + state.scope_level += 1; - for a in iter_fn(iter_type) { - *scope.get_mut(index).0 = a; + for loop_var in func(iter_type) { + *scope.get_mut(index).0 = loop_var; + self.inc_operations(state, stmt.position())?; - match self.eval_stmt(scope, state, &x.2, level) { + match self.eval_stmt(scope, state, stmt, level) { Ok(_) => (), Err(err) => match *err { EvalAltResult::ErrorLoopBreak(false, _) => (), @@ -1642,6 +1756,7 @@ impl Engine { } scope.rewind(scope.len() - 1); + state.scope_level -= 1; Ok(Default::default()) } else { Err(Box::new(EvalAltResult::ErrorFor(x.1.position()))) @@ -1671,7 +1786,7 @@ impl Engine { Stmt::ReturnWithVal(x) if x.1.is_some() && (x.0).0 == ReturnType::Exception => { let val = self.eval_expr(scope, state, x.1.as_ref().unwrap(), level)?; Err(Box::new(EvalAltResult::ErrorRuntime( - val.take_string().unwrap_or_else(|_| "".to_string()), + val.take_string().unwrap_or_else(|_| "".into()), (x.0).1, ))) } @@ -1687,15 +1802,15 @@ impl Engine { Stmt::Let(x) if x.1.is_some() => { let ((var_name, _), expr) = x.as_ref(); let val = self.eval_expr(scope, state, expr.as_ref().unwrap(), level)?; - // TODO - avoid copying variable name in inner block? - scope.push_dynamic_value(var_name.clone(), ScopeEntryType::Normal, val, false); + let var_name = unsafe_cast_var_name_to_lifetime(var_name, &state); + scope.push_dynamic_value(var_name, ScopeEntryType::Normal, val, false); Ok(Default::default()) } Stmt::Let(x) => { let ((var_name, _), _) = x.as_ref(); - // TODO - avoid copying variable name in inner block? - scope.push(var_name.clone(), ()); + let var_name = unsafe_cast_var_name_to_lifetime(var_name, &state); + scope.push(var_name, ()); Ok(Default::default()) } @@ -1703,8 +1818,8 @@ impl Engine { Stmt::Const(x) if x.1.is_constant() => { let ((var_name, _), expr) = x.as_ref(); let val = self.eval_expr(scope, state, &expr, level)?; - // TODO - avoid copying variable name in inner block? - scope.push_dynamic_value(var_name.clone(), ScopeEntryType::Constant, val, true); + let var_name = unsafe_cast_var_name_to_lifetime(var_name, &state); + scope.push_dynamic_value(var_name, ScopeEntryType::Constant, val, true); Ok(Default::default()) } @@ -1713,25 +1828,32 @@ impl Engine { // Import statement Stmt::Import(x) => { - let (expr, (name, _)) = x.as_ref(); - #[cfg(feature = "no_module")] unreachable!(); #[cfg(not(feature = "no_module"))] { + let (expr, (name, pos)) = x.as_ref(); + + // Guard against too many modules + if state.modules >= self.max_modules { + return Err(Box::new(EvalAltResult::ErrorTooManyModules(*pos))); + } + if let Some(path) = self .eval_expr(scope, state, &expr, level)? .try_cast::() { - if let Some(resolver) = self.module_resolver.as_ref() { + if let Some(resolver) = &self.module_resolver { // Use an empty scope to create a module let module = resolver.resolve(self, Scope::new(), &path, expr.position())?; - // TODO - avoid copying module name in inner block? - let mod_name = name.clone(); + let mod_name = unsafe_cast_var_name_to_lifetime(name, &state); scope.push_module(mod_name, module); + + state.modules += 1; + Ok(Default::default()) } else { Err(Box::new(EvalAltResult::ErrorModuleNotFound( @@ -1747,9 +1869,7 @@ impl Engine { // Export statement Stmt::Export(list) => { - for ((id, id_pos), rename) in list.as_ref() { - let mut found = false; - + for ((id, id_pos), rename) in list.iter() { // Mark scope variables as public if let Some(index) = scope .get_index(id) @@ -1762,10 +1882,7 @@ impl Engine { .unwrap_or_else(|| id.clone()); scope.set_entry_alias(index, alias); - found = true; - } - - if !found { + } else { return Err(Box::new(EvalAltResult::ErrorVariableNotFound( id.into(), *id_pos, @@ -1777,6 +1894,29 @@ impl Engine { } } + /// Check if the number of operations stay within limit. + fn inc_operations(&self, state: &mut State, pos: Position) -> Result<(), Box> { + state.operations += 1; + + #[cfg(not(feature = "unchecked"))] + { + // Guard against too many operations + if state.operations > self.max_operations { + return Err(Box::new(EvalAltResult::ErrorTooManyOperations(pos))); + } + } + + // Report progress - only in steps + if let Some(progress) = &self.progress { + if !progress(state.operations) { + // Terminate script if progress returns false + return Err(Box::new(EvalAltResult::ErrorTerminated(pos))); + } + } + + Ok(()) + } + /// Map a type_name into a pretty-print name pub(crate) fn map_type_name<'a>(&'a self, name: &'a str) -> &'a str { self.type_names diff --git a/src/error.rs b/src/error.rs index ee3f87f7..8e180c25 100644 --- a/src/error.rs +++ b/src/error.rs @@ -110,6 +110,10 @@ pub enum ParseErrorType { AssignmentToCopy, /// Assignment to an a constant variable. AssignmentToConstant(String), + /// Expression exceeding the maximum levels of complexity. + /// + /// Never appears under the `unchecked` feature. + ExprTooDeep, /// Break statement not inside a loop. LoopBreak, } @@ -122,7 +126,7 @@ impl ParseErrorType { } /// Error when parsing a script. -#[derive(Debug, PartialEq, Eq, Clone, Hash)] +#[derive(Debug, Eq, PartialEq, Clone, Hash)] pub struct ParseError(pub(crate) ParseErrorType, pub(crate) Position); impl ParseError { @@ -158,7 +162,8 @@ impl ParseError { ParseErrorType::DuplicatedExport(_) => "Duplicated variable/function in export statement", ParseErrorType::WrongExport => "Export statement can only appear at global level", ParseErrorType::AssignmentToCopy => "Only a copy of the value is change with this assignment", - ParseErrorType::AssignmentToConstant(_) => "Cannot assign to a constant value.", + ParseErrorType::AssignmentToConstant(_) => "Cannot assign to a constant value", + ParseErrorType::ExprTooDeep => "Expression exceeds maximum complexity", ParseErrorType::LoopBreak => "Break statement should only be used inside a loop" } } diff --git a/src/fn_call.rs b/src/fn_call.rs index e1da767b..58711ebb 100644 --- a/src/fn_call.rs +++ b/src/fn_call.rs @@ -9,7 +9,7 @@ use crate::utils::StaticVec; /// Any data type that can be converted into a `Vec` can be used /// as arguments to a function call. pub trait FuncArgs { - /// Convert to a `Vec` of the function call arguments. + /// Convert to a `StaticVec` of the function call arguments. fn into_vec(self) -> StaticVec; } diff --git a/src/fn_func.rs b/src/fn_func.rs index af538306..f606b794 100644 --- a/src/fn_func.rs +++ b/src/fn_func.rs @@ -11,7 +11,7 @@ use crate::scope::Scope; use crate::stdlib::{boxed::Box, string::ToString}; -/// A trait to create a Rust anonymous function from a script. +/// Trait to create a Rust anonymous function from a script. pub trait Func { type Output; @@ -92,15 +92,14 @@ macro_rules! def_anonymous_fn { { #[cfg(feature = "sync")] type Output = Box Result> + Send + Sync>; - #[cfg(not(feature = "sync"))] type Output = Box Result>>; fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output { - let name = entry_point.to_string(); + let fn_name = entry_point.to_string(); Box::new(move |$($par: $par),*| { - self.call_fn(&mut Scope::new(), &ast, &name, ($($par,)*)) + self.call_fn(&mut Scope::new(), &ast, &fn_name, ($($par,)*)) }) } diff --git a/src/fn_native.rs b/src/fn_native.rs new file mode 100644 index 00000000..262bad7c --- /dev/null +++ b/src/fn_native.rs @@ -0,0 +1,151 @@ +use crate::any::Dynamic; +use crate::parser::FnDef; +use crate::result::EvalAltResult; + +use crate::stdlib::{boxed::Box, rc::Rc, sync::Arc}; + +pub type FnCallArgs<'a> = [&'a mut Dynamic]; + +#[cfg(feature = "sync")] +pub type FnAny = dyn Fn(&mut FnCallArgs) -> Result> + Send + Sync; +#[cfg(not(feature = "sync"))] +pub type FnAny = dyn Fn(&mut FnCallArgs) -> Result>; + +pub type IteratorFn = fn(Dynamic) -> Box>; + +#[cfg(feature = "sync")] +pub type PrintCallback = dyn Fn(&str) + Send + Sync + 'static; +#[cfg(not(feature = "sync"))] +pub type PrintCallback = dyn Fn(&str) + 'static; + +#[cfg(feature = "sync")] +pub type ProgressCallback = dyn Fn(u64) -> bool + Send + Sync + 'static; +#[cfg(not(feature = "sync"))] +pub type ProgressCallback = dyn Fn(u64) -> bool + 'static; + +// Define callback function types +#[cfg(feature = "sync")] +pub trait ObjectGetCallback: Fn(&mut T) -> U + Send + Sync + 'static {} +#[cfg(feature = "sync")] +impl U + Send + Sync + 'static, T, U> ObjectGetCallback for F {} + +#[cfg(not(feature = "sync"))] +pub trait ObjectGetCallback: Fn(&mut T) -> U + 'static {} +#[cfg(not(feature = "sync"))] +impl U + 'static, T, U> ObjectGetCallback for F {} + +#[cfg(feature = "sync")] +pub trait ObjectSetCallback: Fn(&mut T, U) + Send + Sync + 'static {} +#[cfg(feature = "sync")] +impl ObjectSetCallback for F {} + +#[cfg(not(feature = "sync"))] +pub trait ObjectSetCallback: Fn(&mut T, U) + 'static {} +#[cfg(not(feature = "sync"))] +impl ObjectSetCallback for F {} + +#[cfg(feature = "sync")] +pub trait ObjectIndexerCallback: Fn(&mut T, X) -> U + Send + Sync + 'static {} +#[cfg(feature = "sync")] +impl U + Send + Sync + 'static, T, X, U> ObjectIndexerCallback for F {} + +#[cfg(not(feature = "sync"))] +pub trait ObjectIndexerCallback: Fn(&mut T, X) -> U + 'static {} +#[cfg(not(feature = "sync"))] +impl U + 'static, T, X, U> ObjectIndexerCallback for F {} + +#[cfg(not(feature = "sync"))] +pub type SharedNativeFunction = Rc; +#[cfg(feature = "sync")] +pub type SharedNativeFunction = Arc; + +#[cfg(feature = "sync")] +pub type SharedFnDef = Arc; +#[cfg(not(feature = "sync"))] +pub type SharedFnDef = Rc; + +/// A type encapsulating a function callable by Rhai. +#[derive(Clone)] +pub enum CallableFunction { + /// A pure native Rust function with all arguments passed by value. + Pure(SharedNativeFunction), + /// A native Rust object method with the first argument passed by reference, + /// and the rest passed by value. + Method(SharedNativeFunction), + /// An iterator function. + Iterator(IteratorFn), + /// A script-defined function. + Script(SharedFnDef), +} + +impl CallableFunction { + /// Is this a pure native Rust function? + pub fn is_pure(&self) -> bool { + match self { + Self::Pure(_) => true, + Self::Method(_) | Self::Iterator(_) | Self::Script(_) => false, + } + } + /// Is this a pure native Rust method-call? + pub fn is_method(&self) -> bool { + match self { + Self::Method(_) => true, + Self::Pure(_) | Self::Iterator(_) | Self::Script(_) => false, + } + } + /// Is this an iterator function? + pub fn is_iter(&self) -> bool { + match self { + Self::Iterator(_) => true, + Self::Pure(_) | Self::Method(_) | Self::Script(_) => false, + } + } + /// Is this a Rhai-scripted function? + pub fn is_script(&self) -> bool { + match self { + Self::Script(_) => true, + Self::Pure(_) | Self::Method(_) | Self::Iterator(_) => false, + } + } + /// Get a reference to a native Rust function. + /// + /// # Panics + /// + /// Panics if the `CallableFunction` is not `Pure` or `Method`. + pub fn get_native_fn(&self) -> &FnAny { + match self { + Self::Pure(f) | Self::Method(f) => f.as_ref(), + Self::Iterator(_) | Self::Script(_) => panic!(), + } + } + /// Get a reference to a script-defined function definition. + /// + /// # Panics + /// + /// Panics if the `CallableFunction` is not `Script`. + pub fn get_fn_def(&self) -> &FnDef { + match self { + Self::Pure(_) | Self::Method(_) | Self::Iterator(_) => panic!(), + Self::Script(f) => f, + } + } + /// Get a reference to an iterator function. + /// + /// # Panics + /// + /// Panics if the `CallableFunction` is not `Iterator`. + pub fn get_iter_fn(&self) -> IteratorFn { + match self { + Self::Iterator(f) => *f, + Self::Pure(_) | Self::Method(_) | Self::Script(_) => panic!(), + } + } + /// Create a new `CallableFunction::Pure`. + pub fn from_pure(func: Box) -> Self { + Self::Pure(func.into()) + } + /// Create a new `CallableFunction::Method`. + pub fn from_method(func: Box) -> Self { + Self::Method(func.into()) + } +} diff --git a/src/fn_register.rs b/src/fn_register.rs index 0f012c7c..4b98f184 100644 --- a/src/fn_register.rs +++ b/src/fn_register.rs @@ -3,12 +3,12 @@ #![allow(non_snake_case)] use crate::any::{Dynamic, Variant}; -use crate::engine::{Engine, FnCallArgs}; +use crate::engine::Engine; +use crate::fn_native::{CallableFunction, FnAny, FnCallArgs}; +use crate::parser::FnAccess; use crate::result::EvalAltResult; -use crate::token::Position; -use crate::utils::calc_fn_spec; -use crate::stdlib::{any::TypeId, boxed::Box, iter::empty, mem, string::ToString}; +use crate::stdlib::{any::TypeId, boxed::Box, mem, string::ToString}; /// A trait to register custom plugins with the `Engine`. /// @@ -53,7 +53,7 @@ pub trait RegisterPlugin { fn register_plugin(&mut self, plugin: PL); } -/// A trait to register custom functions with the `Engine`. +/// Trait to register custom functions with the `Engine`. pub trait RegisterFn { /// Register a custom function with the `Engine`. /// @@ -85,7 +85,7 @@ pub trait RegisterFn { fn register_fn(&mut self, name: &str, f: FN); } -/// A trait to register custom functions that return `Dynamic` values with the `Engine`. +/// Trait to register custom functions that return `Dynamic` values with the `Engine`. pub trait RegisterDynamicFn { /// Register a custom function returning `Dynamic` values with the `Engine`. /// @@ -112,7 +112,7 @@ pub trait RegisterDynamicFn { fn register_dynamic_fn(&mut self, name: &str, f: FN); } -/// A trait to register fallible custom functions returning `Result<_, Box>` with the `Engine`. +/// Trait to register fallible custom functions returning `Result<_, Box>` with the `Engine`. pub trait RegisterResultFn { /// Register a custom fallible function with the `Engine`. /// @@ -169,15 +169,15 @@ pub struct Mut(T); //pub struct Ref(T); /// Dereference into &mut. -#[inline] -pub fn by_ref(data: &mut Dynamic) -> &mut T { +#[inline(always)] +pub fn by_ref(data: &mut Dynamic) -> &mut T { // Directly cast the &mut Dynamic into &mut T to access the underlying data. data.downcast_mut::().unwrap() } /// Dereference into value. -#[inline] -pub fn by_value(data: &mut Dynamic) -> T { +#[inline(always)] +pub fn by_value(data: &mut Dynamic) -> T { // We consume the argument and then replace it with () - the argument is not supposed to be used again. // This way, we avoid having to clone the argument again, because it is already a clone when passed here. mem::take(data).cast::() @@ -198,20 +198,14 @@ macro_rules! count_args { /// This macro creates a closure wrapping a registered function. macro_rules! make_func { - ($fn_name:ident : $fn:ident : $map:expr ; $($par:ident => $convert:expr),*) => { -// ^ function name -// ^ function pointer -// ^ result mapping function -// ^ function parameter generic type name (A, B, C etc.) -// ^ dereferencing function + ($fn:ident : $map:expr ; $($par:ident => $convert:expr),*) => { +// ^ function pointer +// ^ result mapping function +// ^ function parameter generic type name (A, B, C etc.) +// ^ dereferencing function - move |args: &mut FnCallArgs, pos: Position| { - // Check for length at the beginning to avoid per-element bound checks. - const NUM_ARGS: usize = count_args!($($par)*); - - if args.len() != NUM_ARGS { - return Err(Box::new(EvalAltResult::ErrorFunctionArgsMismatch($fn_name.clone(), NUM_ARGS, args.len(), pos))); - } + Box::new(move |args: &mut FnCallArgs| { + // The arguments are assumed to be of the correct number and types! #[allow(unused_variables, unused_mut)] let mut drain = args.iter_mut(); @@ -225,45 +219,41 @@ macro_rules! make_func { let r = $fn($($par),*); // Map the result - $map(r, pos) - }; + $map(r) + }) as Box }; } /// To Dynamic mapping function. -#[inline] -pub fn map_dynamic( - data: T, - _pos: Position, -) -> Result> { +#[inline(always)] +pub fn map_dynamic(data: T) -> Result> { Ok(data.into_dynamic()) } /// To Dynamic mapping function. -#[inline] -pub fn map_identity(data: Dynamic, _pos: Position) -> Result> { +#[inline(always)] +pub fn map_identity(data: Dynamic) -> Result> { Ok(data) } /// To `Result>` mapping function. -#[inline] +#[inline(always)] pub fn map_result( data: Result>, - pos: Position, ) -> Result> { data.map(|v| v.into_dynamic()) - .map_err(|err| EvalAltResult::set_position(err, pos)) } macro_rules! def_register { () => { - def_register!(imp); + def_register!(imp from_pure :); }; - (imp $($par:ident => $mark:ty => $param:ty => $clone:expr),*) => { - // ^ function parameter generic type name (A, B, C etc.) - // ^ function parameter marker type (T, Ref or Mut) - // ^ function parameter actual type (T, &T or &mut T) - // ^ dereferencing function + (imp $abi:ident : $($par:ident => $mark:ty => $param:ty => $clone:expr),*) => { + // ^ function ABI type + // ^ function parameter generic type name (A, B, C etc.) + // ^ function parameter marker type (T, Ref or Mut) + // ^ function parameter actual type (T, &T or &mut T) + // ^ dereferencing function impl< $($par: Variant + Clone,)* @@ -277,10 +267,10 @@ macro_rules! def_register { > RegisterFn for Engine { fn register_fn(&mut self, name: &str, f: FN) { - let fn_name = name.to_string(); - let func = make_func!(fn_name : f : map_dynamic ; $($par => $clone),*); - let hash = calc_fn_spec(empty(), name, [$(TypeId::of::<$par>()),*].iter().cloned()); - self.base_package.functions.insert(hash, Box::new(func)); + self.global_module.set_fn(name.to_string(), FnAccess::Public, + &[$(TypeId::of::<$par>()),*], + CallableFunction::$abi(make_func!(f : map_dynamic ; $($par => $clone),*)) + ); } } @@ -295,10 +285,10 @@ macro_rules! def_register { > RegisterDynamicFn for Engine { fn register_dynamic_fn(&mut self, name: &str, f: FN) { - let fn_name = name.to_string(); - let func = make_func!(fn_name : f : map_identity ; $($par => $clone),*); - let hash = calc_fn_spec(empty(), name, [$(TypeId::of::<$par>()),*].iter().cloned()); - self.base_package.functions.insert(hash, Box::new(func)); + self.global_module.set_fn(name.to_string(), FnAccess::Public, + &[$(TypeId::of::<$par>()),*], + CallableFunction::$abi(make_func!(f : map_identity ; $($par => $clone),*)) + ); } } @@ -314,20 +304,21 @@ macro_rules! def_register { > RegisterResultFn for Engine { fn register_result_fn(&mut self, name: &str, f: FN) { - let fn_name = name.to_string(); - let func = make_func!(fn_name : f : map_result ; $($par => $clone),*); - let hash = calc_fn_spec(empty(), name, [$(TypeId::of::<$par>()),*].iter().cloned()); - self.base_package.functions.insert(hash, Box::new(func)); + self.global_module.set_fn(name.to_string(), FnAccess::Public, + &[$(TypeId::of::<$par>()),*], + CallableFunction::$abi(make_func!(f : map_result ; $($par => $clone),*)) + ); } } //def_register!(imp_pop $($par => $mark => $param),*); }; ($p0:ident $(, $p:ident)*) => { - def_register!(imp $p0 => $p0 => $p0 => by_value $(, $p => $p => $p => by_value)*); - def_register!(imp $p0 => Mut<$p0> => &mut $p0 => by_ref $(, $p => $p => $p => by_value)*); - // handle the first parameter ^ first parameter passed through - // ^ others passed by value (by_value) + def_register!(imp from_pure : $p0 => $p0 => $p0 => by_value $(, $p => $p => $p => by_value)*); + def_register!(imp from_method : $p0 => Mut<$p0> => &mut $p0 => by_ref $(, $p => $p => $p => by_value)*); + // ^ CallableFunction + // handle the first parameter ^ first parameter passed through + // ^ others passed by value (by_value) // Currently does not support first argument which is a reference, as there will be // conflicting implementations since &T: Any and T: Any cannot be distinguished diff --git a/src/lib.rs b/src/lib.rs index 84c45628..9b2b0229 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -75,6 +75,7 @@ mod engine; mod error; mod fn_call; mod fn_func; +mod fn_native; mod fn_register; mod module; mod optimize; @@ -84,15 +85,16 @@ mod result; mod scope; mod stdlib; mod token; +mod r#unsafe; mod utils; pub use any::Dynamic; pub use engine::Engine; pub use error::{ParseError, ParseErrorType}; -pub use fn_call::FuncArgs; -pub use fn_register::{RegisterDynamicFn, RegisterFn, RegisterResultFn}; #[cfg(feature = "plugins")] pub use fn_register::{Plugin, RegisterPlugin}; +pub use fn_register::{RegisterDynamicFn, RegisterFn, RegisterResultFn}; +pub use module::Module; pub use parser::{AST, INT}; pub use result::EvalAltResult; pub use scope::Scope; @@ -112,8 +114,9 @@ pub use engine::Map; pub use parser::FLOAT; #[cfg(not(feature = "no_module"))] -pub use module::{Module, ModuleResolver}; +pub use module::ModuleResolver; +/// Module containing all built-in _module resolvers_ available to Rhai. #[cfg(not(feature = "no_module"))] pub mod module_resolvers { pub use crate::module::resolvers::*; diff --git a/src/module.rs b/src/module.rs index 0519a44b..48e6e936 100644 --- a/src/module.rs +++ b/src/module.rs @@ -1,51 +1,41 @@ //! Module defining external-loaded modules for Rhai. -#![cfg(not(feature = "no_module"))] use crate::any::{Dynamic, Variant}; use crate::calc_fn_hash; -use crate::engine::{Engine, FnAny, FnCallArgs, FunctionsLib, NativeFunction, ScriptedFunction}; -use crate::parser::{FnAccess, FnDef, AST}; +use crate::engine::{Engine, FunctionsLib}; +use crate::fn_native::{CallableFunction as CF, FnCallArgs, IteratorFn}; +use crate::parser::{ + FnAccess, + FnAccess::{Private, Public}, + AST, +}; use crate::result::EvalAltResult; use crate::scope::{Entry as ScopeEntry, EntryType as ScopeEntryType, Scope}; use crate::token::{Position, Token}; -use crate::utils::{StaticVec, EMPTY_TYPE_ID}; +use crate::utils::StaticVec; use crate::stdlib::{ any::TypeId, boxed::Box, collections::HashMap, fmt, - iter::{empty, repeat}, + iter::empty, mem, num::NonZeroUsize, ops::{Deref, DerefMut}, - rc::Rc, string::{String, ToString}, - sync::Arc, vec, vec::Vec, }; -/// A trait that encapsulates a module resolution service. -pub trait ModuleResolver { - /// Resolve a module based on a path string. - fn resolve( - &self, - engine: &Engine, - scope: Scope, - path: &str, - pos: Position, - ) -> Result>; -} - /// Return type of module-level Rust function. -type FuncReturn = Result>; +pub type FuncReturn = Result>; /// An imported module, which may contain variables, sub-modules, /// external Rust functions, and script-defined functions. /// /// Not available under the `no_module` feature. -#[derive(Default, Clone)] +#[derive(Clone, Default)] pub struct Module { /// Sub-modules. modules: HashMap, @@ -57,16 +47,17 @@ pub struct Module { all_variables: HashMap, /// External Rust functions. - functions: HashMap, NativeFunction)>, - - /// Flattened collection of all external Rust functions, including those in sub-modules. - all_functions: HashMap, + functions: HashMap, CF)>, /// Script-defined functions. fn_lib: FunctionsLib, - /// Flattened collection of all script-defined functions, including those in sub-modules. - all_fn_lib: FunctionsLib, + /// Iterator functions, keyed by the type producing the iterator. + type_iterators: HashMap, + + /// Flattened collection of all external Rust functions, native or scripted, + /// including those in sub-modules. + all_functions: HashMap, } impl fmt::Debug for Module { @@ -97,6 +88,24 @@ impl Module { Default::default() } + /// Create a new module with a specified capacity for native Rust functions. + /// + /// # Examples + /// + /// ``` + /// use rhai::Module; + /// + /// let mut module = Module::new(); + /// module.set_var("answer", 42_i64); + /// assert_eq!(module.get_var_value::("answer").unwrap(), 42); + /// ``` + pub fn new_with_capacity(capacity: usize) -> Self { + Self { + functions: HashMap::with_capacity(capacity), + ..Default::default() + } + } + /// Does a variable exist in the module? /// /// # Examples @@ -155,8 +164,8 @@ impl Module { /// module.set_var("answer", 42_i64); /// assert_eq!(module.get_var_value::("answer").unwrap(), 42); /// ``` - pub fn set_var, T: Into>(&mut self, name: K, value: T) { - self.variables.insert(name.into(), value.into()); + pub fn set_var, T: Variant + Clone>(&mut self, name: K, value: T) { + self.variables.insert(name.into(), Dynamic::from(value)); } /// Get a mutable reference to a modules-qualified variable. @@ -165,11 +174,11 @@ impl Module { pub(crate) fn get_qualified_var_mut( &mut self, name: &str, - hash: u64, + hash_var: u64, pos: Position, ) -> Result<&mut Dynamic, Box> { self.all_variables - .get_mut(&hash) + .get_mut(&hash_var) .ok_or_else(|| Box::new(EvalAltResult::ErrorVariableNotFound(name.to_string(), pos))) } @@ -253,30 +262,22 @@ impl Module { /// let hash = module.set_fn_0("calc", || Ok(42_i64)); /// assert!(module.contains_fn(hash)); /// ``` - pub fn contains_fn(&self, hash: u64) -> bool { - self.functions.contains_key(&hash) + pub fn contains_fn(&self, hash_fn: u64) -> bool { + self.functions.contains_key(&hash_fn) } /// Set a Rust function into the module, returning a hash key. /// /// If there is an existing Rust function of the same hash, it is replaced. - pub fn set_fn( - &mut self, - fn_name: String, - access: FnAccess, - params: Vec, - func: Box, - ) -> u64 { - let hash = calc_fn_hash(empty(), &fn_name, params.iter().cloned()); + pub fn set_fn(&mut self, name: String, access: FnAccess, params: &[TypeId], func: CF) -> u64 { + let hash_fn = calc_fn_hash(empty(), &name, params.len(), params.iter().cloned()); - #[cfg(not(feature = "sync"))] - self.functions - .insert(hash, (fn_name, access, params, Rc::new(func))); - #[cfg(feature = "sync")] - self.functions - .insert(hash, (fn_name, access, params, Arc::new(func))); + let params = params.into_iter().cloned().collect(); - hash + self.functions + .insert(hash_fn, (name, access, params, func.into())); + + hash_fn } /// Set a Rust function taking no parameters into the module, returning a hash key. @@ -292,19 +293,15 @@ impl Module { /// let hash = module.set_fn_0("calc", || Ok(42_i64)); /// assert!(module.get_fn(hash).is_some()); /// ``` - pub fn set_fn_0, T: Into>( + pub fn set_fn_0, T: Variant + Clone>( &mut self, - fn_name: K, + name: K, #[cfg(not(feature = "sync"))] func: impl Fn() -> FuncReturn + 'static, #[cfg(feature = "sync")] func: impl Fn() -> FuncReturn + Send + Sync + 'static, ) -> u64 { - let f = move |_: &mut FnCallArgs, pos| { - func() - .map(|v| v.into()) - .map_err(|err| EvalAltResult::set_position(err, pos)) - }; - let arg_types = vec![]; - self.set_fn(fn_name.into(), FnAccess::Public, arg_types, Box::new(f)) + let f = move |_: &mut FnCallArgs| func().map(Dynamic::from); + let args = []; + self.set_fn(name.into(), Public, &args, CF::from_pure(Box::new(f))) } /// Set a Rust function taking one parameter into the module, returning a hash key. @@ -320,19 +317,16 @@ impl Module { /// let hash = module.set_fn_1("calc", |x: i64| Ok(x + 1)); /// assert!(module.get_fn(hash).is_some()); /// ``` - pub fn set_fn_1, A: Variant + Clone, T: Into>( + pub fn set_fn_1, A: Variant + Clone, T: Variant + Clone>( &mut self, - fn_name: K, + name: K, #[cfg(not(feature = "sync"))] func: impl Fn(A) -> FuncReturn + 'static, #[cfg(feature = "sync")] func: impl Fn(A) -> FuncReturn + Send + Sync + 'static, ) -> u64 { - let f = move |args: &mut FnCallArgs, pos| { - func(mem::take(args[0]).cast::()) - .map(|v| v.into()) - .map_err(|err| EvalAltResult::set_position(err, pos)) - }; - let arg_types = vec![TypeId::of::()]; - self.set_fn(fn_name.into(), FnAccess::Public, arg_types, Box::new(f)) + let f = + move |args: &mut FnCallArgs| func(mem::take(args[0]).cast::()).map(Dynamic::from); + let args = [TypeId::of::()]; + self.set_fn(name.into(), Public, &args, CF::from_pure(Box::new(f))) } /// Set a Rust function taking one mutable parameter into the module, returning a hash key. @@ -348,19 +342,17 @@ impl Module { /// let hash = module.set_fn_1_mut("calc", |x: &mut i64| { *x += 1; Ok(*x) }); /// assert!(module.get_fn(hash).is_some()); /// ``` - pub fn set_fn_1_mut, A: Variant + Clone, T: Into>( + pub fn set_fn_1_mut, A: Variant + Clone, T: Variant + Clone>( &mut self, - fn_name: K, + name: K, #[cfg(not(feature = "sync"))] func: impl Fn(&mut A) -> FuncReturn + 'static, #[cfg(feature = "sync")] func: impl Fn(&mut A) -> FuncReturn + Send + Sync + 'static, ) -> u64 { - let f = move |args: &mut FnCallArgs, pos| { - func(args[0].downcast_mut::().unwrap()) - .map(|v| v.into()) - .map_err(|err| EvalAltResult::set_position(err, pos)) + let f = move |args: &mut FnCallArgs| { + func(args[0].downcast_mut::().unwrap()).map(Dynamic::from) }; - let arg_types = vec![TypeId::of::()]; - self.set_fn(fn_name.into(), FnAccess::Public, arg_types, Box::new(f)) + let args = [TypeId::of::()]; + self.set_fn(name.into(), Public, &args, CF::from_method(Box::new(f))) } /// Set a Rust function taking two parameters into the module, returning a hash key. @@ -378,22 +370,20 @@ impl Module { /// }); /// assert!(module.get_fn(hash).is_some()); /// ``` - pub fn set_fn_2, A: Variant + Clone, B: Variant + Clone, T: Into>( + pub fn set_fn_2, A: Variant + Clone, B: Variant + Clone, T: Variant + Clone>( &mut self, - fn_name: K, + name: K, #[cfg(not(feature = "sync"))] func: impl Fn(A, B) -> FuncReturn + 'static, #[cfg(feature = "sync")] func: impl Fn(A, B) -> FuncReturn + Send + Sync + 'static, ) -> u64 { - let f = move |args: &mut FnCallArgs, pos| { + let f = move |args: &mut FnCallArgs| { let a = mem::take(args[0]).cast::(); let b = mem::take(args[1]).cast::(); - func(a, b) - .map(|v| v.into()) - .map_err(|err| EvalAltResult::set_position(err, pos)) + func(a, b).map(Dynamic::from) }; - let arg_types = vec![TypeId::of::(), TypeId::of::()]; - self.set_fn(fn_name.into(), FnAccess::Public, arg_types, Box::new(f)) + let args = [TypeId::of::(), TypeId::of::()]; + self.set_fn(name.into(), Public, &args, CF::from_pure(Box::new(f))) } /// Set a Rust function taking two parameters (the first one mutable) into the module, @@ -414,23 +404,21 @@ impl Module { K: Into, A: Variant + Clone, B: Variant + Clone, - T: Into, + T: Variant + Clone, >( &mut self, - fn_name: K, + name: K, #[cfg(not(feature = "sync"))] func: impl Fn(&mut A, B) -> FuncReturn + 'static, #[cfg(feature = "sync")] func: impl Fn(&mut A, B) -> FuncReturn + Send + Sync + 'static, ) -> u64 { - let f = move |args: &mut FnCallArgs, pos| { + let f = move |args: &mut FnCallArgs| { let b = mem::take(args[1]).cast::(); let a = args[0].downcast_mut::().unwrap(); - func(a, b) - .map(|v| v.into()) - .map_err(|err| EvalAltResult::set_position(err, pos)) + func(a, b).map(Dynamic::from) }; - let arg_types = vec![TypeId::of::(), TypeId::of::()]; - self.set_fn(fn_name.into(), FnAccess::Public, arg_types, Box::new(f)) + let args = [TypeId::of::(), TypeId::of::()]; + self.set_fn(name.into(), Public, &args, CF::from_method(Box::new(f))) } /// Set a Rust function taking three parameters into the module, returning a hash key. @@ -453,24 +441,22 @@ impl Module { A: Variant + Clone, B: Variant + Clone, C: Variant + Clone, - T: Into, + T: Variant + Clone, >( &mut self, - fn_name: K, + name: K, #[cfg(not(feature = "sync"))] func: impl Fn(A, B, C) -> FuncReturn + 'static, #[cfg(feature = "sync")] func: impl Fn(A, B, C) -> FuncReturn + Send + Sync + 'static, ) -> u64 { - let f = move |args: &mut FnCallArgs, pos| { + let f = move |args: &mut FnCallArgs| { let a = mem::take(args[0]).cast::(); let b = mem::take(args[1]).cast::(); let c = mem::take(args[2]).cast::(); - func(a, b, c) - .map(|v| v.into()) - .map_err(|err| EvalAltResult::set_position(err, pos)) + func(a, b, c).map(Dynamic::from) }; - let arg_types = vec![TypeId::of::(), TypeId::of::(), TypeId::of::()]; - self.set_fn(fn_name.into(), FnAccess::Public, arg_types, Box::new(f)) + let args = [TypeId::of::(), TypeId::of::(), TypeId::of::()]; + self.set_fn(name.into(), Public, &args, CF::from_pure(Box::new(f))) } /// Set a Rust function taking three parameters (the first one mutable) into the module, @@ -494,24 +480,22 @@ impl Module { A: Variant + Clone, B: Variant + Clone, C: Variant + Clone, - T: Into, + T: Variant + Clone, >( &mut self, - fn_name: K, + name: K, #[cfg(not(feature = "sync"))] func: impl Fn(&mut A, B, C) -> FuncReturn + 'static, #[cfg(feature = "sync")] func: impl Fn(&mut A, B, C) -> FuncReturn + Send + Sync + 'static, ) -> u64 { - let f = move |args: &mut FnCallArgs, pos| { + let f = move |args: &mut FnCallArgs| { let b = mem::take(args[1]).cast::(); let c = mem::take(args[2]).cast::(); let a = args[0].downcast_mut::().unwrap(); - func(a, b, c) - .map(|v| v.into()) - .map_err(|err| EvalAltResult::set_position(err, pos)) + func(a, b, c).map(Dynamic::from) }; - let arg_types = vec![TypeId::of::(), TypeId::of::(), TypeId::of::()]; - self.set_fn(fn_name.into(), FnAccess::Public, arg_types, Box::new(f)) + let args = [TypeId::of::(), TypeId::of::(), TypeId::of::()]; + self.set_fn(name.into(), Public, &args, CF::from_method(Box::new(f))) } /// Get a Rust function. @@ -528,8 +512,8 @@ impl Module { /// let hash = module.set_fn_1("calc", |x: i64| Ok(x + 1)); /// assert!(module.get_fn(hash).is_some()); /// ``` - pub fn get_fn(&self, hash: u64) -> Option<&Box> { - self.functions.get(&hash).map(|(_, _, _, v)| v.as_ref()) + pub fn get_fn(&self, hash_fn: u64) -> Option<&CF> { + self.functions.get(&hash_fn).map(|(_, _, _, v)| v) } /// Get a modules-qualified function. @@ -539,34 +523,14 @@ impl Module { pub(crate) fn get_qualified_fn( &mut self, name: &str, - hash: u64, - pos: Position, - ) -> Result<&Box, Box> { - self.all_functions - .get(&hash) - .map(|f| f.as_ref()) - .ok_or_else(|| Box::new(EvalAltResult::ErrorFunctionNotFound(name.to_string(), pos))) - } - - /// Get the script-defined functions. - /// - /// # Examples - /// - /// ``` - /// use rhai::Module; - /// - /// let mut module = Module::new(); - /// assert_eq!(module.get_fn_lib().len(), 0); - /// ``` - pub fn get_fn_lib(&self) -> &FunctionsLib { - &self.fn_lib - } - - /// Get a modules-qualified script-defined functions. - /// - /// The `u64` hash is calculated by the function `crate::calc_fn_hash`. - pub(crate) fn get_qualified_scripted_fn(&mut self, hash: u64) -> Option<&FnDef> { - self.all_fn_lib.get_function(hash) + hash_fn_native: u64, + ) -> Result<&CF, Box> { + self.all_functions.get(&hash_fn_native).ok_or_else(|| { + Box::new(EvalAltResult::ErrorFunctionNotFound( + name.to_string(), + Position::none(), + )) + }) } /// Create a new `Module` by evaluating an `AST`. @@ -585,6 +549,7 @@ impl Module { /// # Ok(()) /// # } /// ``` + #[cfg(not(feature = "no_module"))] pub fn eval_ast_as_new(mut scope: Scope, ast: &AST, engine: &Engine) -> FuncReturn { // Run the script engine.eval_ast_with_scope_raw(&mut scope, &ast)?; @@ -623,84 +588,175 @@ impl Module { pub(crate) fn index_all_sub_modules(&mut self) { // Collect a particular module. fn index_module<'a>( - module: &'a mut Module, + module: &'a Module, qualifiers: &mut Vec<&'a str>, variables: &mut Vec<(u64, Dynamic)>, - functions: &mut Vec<(u64, NativeFunction)>, - fn_lib: &mut Vec<(u64, ScriptedFunction)>, + functions: &mut Vec<(u64, CF)>, ) { - for (name, m) in module.modules.iter_mut() { + for (name, m) in &module.modules { // Index all the sub-modules first. qualifiers.push(name); - index_module(m, qualifiers, variables, functions, fn_lib); + index_module(m, qualifiers, variables, functions); qualifiers.pop(); } // Index all variables - for (var_name, value) in module.variables.iter() { + for (var_name, value) in &module.variables { // Qualifiers + variable name - let hash = calc_fn_hash(qualifiers.iter().map(|v| *v), var_name, empty()); - variables.push((hash, value.clone())); + let hash_var = calc_fn_hash(qualifiers.iter().map(|&v| v), var_name, 0, empty()); + variables.push((hash_var, value.clone())); } // Index all Rust functions - for (fn_name, access, params, func) in module.functions.values() { + for (name, access, params, func) in module.functions.values() { match access { // Private functions are not exported - FnAccess::Private => continue, - FnAccess::Public => (), + Private => continue, + Public => (), } // Rust functions are indexed in two steps: // 1) Calculate a hash in a similar manner to script-defined functions, - // i.e. qualifiers + function name + dummy parameter types (one for each parameter). - let hash_fn_def = calc_fn_hash( - qualifiers.iter().map(|v| *v), - fn_name, - repeat(EMPTY_TYPE_ID()).take(params.len()), - ); - // 2) Calculate a second hash with no qualifiers, empty function name, and - // the actual list of parameter `TypeId`'.s - let hash_fn_args = calc_fn_hash(empty(), "", params.iter().cloned()); + // i.e. qualifiers + function name + number of arguments. + let hash_fn_def = + calc_fn_hash(qualifiers.iter().map(|&v| v), name, params.len(), empty()); + // 2) Calculate a second hash with no qualifiers, empty function name, + // zero number of arguments, and the actual list of argument `TypeId`'.s + let hash_fn_args = calc_fn_hash(empty(), "", 0, params.iter().cloned()); // 3) The final hash is the XOR of the two hashes. - let hash = hash_fn_def ^ hash_fn_args; + let hash_fn_native = hash_fn_def ^ hash_fn_args; - functions.push((hash, func.clone())); + functions.push((hash_fn_native, func.clone())); } // Index all script-defined functions for fn_def in module.fn_lib.values() { match fn_def.access { // Private functions are not exported - FnAccess::Private => continue, - FnAccess::Public => (), + Private => continue, + Public => (), } - // Qualifiers + function name + placeholders (one for each parameter) - let hash = calc_fn_hash( - qualifiers.iter().map(|v| *v), + // Qualifiers + function name + number of arguments. + let hash_fn_def = calc_fn_hash( + qualifiers.iter().map(|&v| v), &fn_def.name, - repeat(EMPTY_TYPE_ID()).take(fn_def.params.len()), + fn_def.params.len(), + empty(), ); - fn_lib.push((hash, fn_def.clone())); + functions.push((hash_fn_def, CF::Script(fn_def.clone()).into())); } } let mut variables = Vec::new(); let mut functions = Vec::new(); - let mut fn_lib = Vec::new(); - index_module( - self, - &mut vec!["root"], - &mut variables, - &mut functions, - &mut fn_lib, - ); + index_module(self, &mut vec!["root"], &mut variables, &mut functions); self.all_variables = variables.into_iter().collect(); self.all_functions = functions.into_iter().collect(); - self.all_fn_lib = fn_lib.into(); + } + + /// Does a type iterator exist in the module? + pub fn contains_iter(&self, id: TypeId) -> bool { + self.type_iterators.contains_key(&id) + } + + /// Set a type iterator into the module. + pub fn set_iter(&mut self, typ: TypeId, func: IteratorFn) { + self.type_iterators.insert(typ, func); + } + + /// Get the specified type iterator. + pub fn get_iter(&self, id: TypeId) -> Option { + self.type_iterators.get(&id).cloned() } } +/// A chain of module names to qualify a variable or function call. +/// A `u64` hash key is kept for quick search purposes. +/// +/// A `StaticVec` is used because most module-level access contains only one level, +/// and it is wasteful to always allocate a `Vec` with one element. +#[derive(Clone, Eq, PartialEq, Default)] +pub struct ModuleRef(StaticVec<(String, Position)>, Option); + +impl fmt::Debug for ModuleRef { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Debug::fmt(&self.0, f)?; + + if let Some(index) = self.1 { + write!(f, " -> {}", index) + } else { + Ok(()) + } + } +} + +impl Deref for ModuleRef { + type Target = StaticVec<(String, Position)>; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl DerefMut for ModuleRef { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} + +impl fmt::Display for ModuleRef { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + for (m, _) in self.0.iter() { + write!(f, "{}{}", m, Token::DoubleColon.syntax())?; + } + Ok(()) + } +} + +impl From> for ModuleRef { + fn from(modules: StaticVec<(String, Position)>) -> Self { + Self(modules, None) + } +} + +impl ModuleRef { + pub(crate) fn index(&self) -> Option { + self.1 + } + pub(crate) fn set_index(&mut self, index: Option) { + self.1 = index + } +} + +/// Trait that encapsulates a module resolution service. +#[cfg(not(feature = "no_module"))] +#[cfg(not(feature = "sync"))] +pub trait ModuleResolver { + /// Resolve a module based on a path string. + fn resolve( + &self, + engine: &Engine, + scope: Scope, + path: &str, + pos: Position, + ) -> Result>; +} + +/// Trait that encapsulates a module resolution service. +#[cfg(not(feature = "no_module"))] +#[cfg(feature = "sync")] +pub trait ModuleResolver: Send + Sync { + /// Resolve a module based on a path string. + fn resolve( + &self, + engine: &Engine, + scope: Scope, + path: &str, + pos: Position, + ) -> Result>; +} + /// Re-export module resolvers. +#[cfg(not(feature = "no_module"))] pub mod resolvers { #[cfg(not(feature = "no_std"))] pub use super::file::FileModuleResolver; @@ -708,12 +764,13 @@ pub mod resolvers { } /// Script file-based module resolver. +#[cfg(not(feature = "no_module"))] #[cfg(not(feature = "no_std"))] mod file { use super::*; use crate::stdlib::path::PathBuf; - /// A module resolution service that loads module script files from the file system. + /// Module resolution service that loads module script files from the file system. /// /// The `new_with_path` and `new_with_path_and_extension` constructor functions /// allow specification of a base directory with module path used as a relative path offset @@ -733,7 +790,7 @@ mod file { /// let mut engine = Engine::new(); /// engine.set_module_resolver(Some(resolver)); /// ``` - #[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] + #[derive(Debug, Eq, PartialEq, PartialOrd, Ord, Clone, Hash)] pub struct FileModuleResolver { path: PathBuf, extension: String, @@ -838,77 +895,19 @@ mod file { // Compile it let ast = engine .compile_file(file_path) - .map_err(|err| EvalAltResult::set_position(err, pos))?; + .map_err(|err| err.new_position(pos))?; - Module::eval_ast_as_new(scope, &ast, engine) - .map_err(|err| EvalAltResult::set_position(err, pos)) + Module::eval_ast_as_new(scope, &ast, engine).map_err(|err| err.new_position(pos)) } } } -/// A chain of module names to qualify a variable or function call. -/// A `u64` hash key is kept for quick search purposes. -/// -/// A `StaticVec` is used because most module-level access contains only one level, -/// and it is wasteful to always allocate a `Vec` with one element. -#[derive(Clone, Hash, Default)] -pub struct ModuleRef(StaticVec<(String, Position)>, Option); - -impl fmt::Debug for ModuleRef { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - fmt::Debug::fmt(&self.0, f)?; - - if let Some(index) = self.1 { - write!(f, " -> {}", index) - } else { - Ok(()) - } - } -} - -impl Deref for ModuleRef { - type Target = StaticVec<(String, Position)>; - - fn deref(&self) -> &Self::Target { - &self.0 - } -} - -impl DerefMut for ModuleRef { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} - -impl fmt::Display for ModuleRef { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - for (m, _) in self.0.iter() { - write!(f, "{}{}", m, Token::DoubleColon.syntax())?; - } - Ok(()) - } -} - -impl From> for ModuleRef { - fn from(modules: StaticVec<(String, Position)>) -> Self { - Self(modules, None) - } -} - -impl ModuleRef { - pub(crate) fn index(&self) -> Option { - self.1 - } - pub(crate) fn set_index(&mut self, index: Option) { - self.1 = index - } -} - /// Static module resolver. +#[cfg(not(feature = "no_module"))] mod stat { use super::*; - /// A module resolution service that serves modules added into it. + /// Module resolution service that serves modules added into it. /// /// # Examples /// @@ -974,7 +973,7 @@ mod stat { self.0 .get(path) .cloned() - .ok_or_else(|| Box::new(EvalAltResult::ErrorModuleNotFound(path.to_string(), pos))) + .ok_or_else(|| Box::new(EvalAltResult::ErrorModuleNotFound(path.into(), pos))) } } } diff --git a/src/optimize.rs b/src/optimize.rs index ca18d1ce..1bba1196 100644 --- a/src/optimize.rs +++ b/src/optimize.rs @@ -1,18 +1,19 @@ use crate::any::Dynamic; use crate::calc_fn_hash; use crate::engine::{ - Engine, FnAny, FnCallArgs, FunctionsLib, KEYWORD_DEBUG, KEYWORD_EVAL, KEYWORD_PRINT, - KEYWORD_TYPE_OF, + Engine, FunctionsLib, KEYWORD_DEBUG, KEYWORD_EVAL, KEYWORD_PRINT, KEYWORD_TYPE_OF, }; -use crate::packages::{PackageStore, PackagesCollection}; +use crate::fn_native::FnCallArgs; +use crate::module::Module; +use crate::packages::PackagesCollection; use crate::parser::{map_dynamic_to_expr, Expr, FnDef, ReturnType, Stmt, AST}; use crate::result::EvalAltResult; use crate::scope::{Entry as ScopeEntry, EntryType as ScopeEntryType, Scope}; use crate::token::Position; +use crate::utils::StaticVec; use crate::stdlib::{ boxed::Box, - collections::HashMap, iter::empty, string::{String, ToString}, vec, @@ -95,7 +96,7 @@ impl<'a> State<'a> { } /// Add a new constant to the list. pub fn push_constant(&mut self, name: &str, value: Expr) { - self.constants.push((name.to_string(), value)) + self.constants.push((name.into(), value)) } /// Look up a constant from the list. pub fn find_constant(&self, name: &str) -> Option<&Expr> { @@ -112,19 +113,25 @@ impl<'a> State<'a> { /// Call a registered function fn call_fn( packages: &PackagesCollection, - base_package: &PackageStore, + global_module: &Module, fn_name: &str, args: &mut FnCallArgs, pos: Position, ) -> Result, Box> { // Search built-in's and external functions - let hash = calc_fn_hash(empty(), fn_name, args.iter().map(|a| a.type_id())); + let hash_fn = calc_fn_hash( + empty(), + fn_name, + args.len(), + args.iter().map(|a| a.type_id()), + ); - base_package - .get_function(hash) - .or_else(|| packages.get_function(hash)) - .map(|func| func(args, pos)) + global_module + .get_fn(hash_fn) + .or_else(|| packages.get_fn(hash_fn)) + .map(|func| func.get_native_fn()(args)) .transpose() + .map_err(|err| err.new_position(pos)) } /// Optimize a statement. @@ -139,7 +146,11 @@ fn optimize_stmt<'a>(stmt: Stmt, state: &mut State<'a>, preserve_result: bool) - if preserve_result { // -> { expr, Noop } - Stmt::Block(Box::new((vec![Stmt::Expr(Box::new(expr)), x.1], pos))) + let mut statements = StaticVec::new(); + statements.push(Stmt::Expr(Box::new(expr))); + statements.push(x.1); + + Stmt::Block(Box::new((statements, pos))) } else { // -> expr Stmt::Expr(Box::new(expr)) @@ -192,7 +203,8 @@ fn optimize_stmt<'a>(stmt: Stmt, state: &mut State<'a>, preserve_result: bool) - Stmt::Break(pos) => { // Only a single break statement - turn into running the guard expression once state.set_dirty(); - let mut statements = vec![Stmt::Expr(Box::new(optimize_expr(expr, state)))]; + let mut statements = StaticVec::new(); + statements.push(Stmt::Expr(Box::new(optimize_expr(expr, state)))); if preserve_result { statements.push(Stmt::Noop(pos)) } @@ -323,13 +335,13 @@ fn optimize_stmt<'a>(stmt: Stmt, state: &mut State<'a>, preserve_result: bool) - Stmt::Noop(pos) } // Only one let/import statement - leave it alone - [Stmt::Let(_)] | [Stmt::Import(_)] => Stmt::Block(Box::new((result, pos))), + [Stmt::Let(_)] | [Stmt::Import(_)] => Stmt::Block(Box::new((result.into(), pos))), // Only one statement - promote [_] => { state.set_dirty(); result.remove(0) } - _ => Stmt::Block(Box::new((result, pos))), + _ => Stmt::Block(Box::new((result.into(), pos))), } } // expr; @@ -392,11 +404,12 @@ fn optimize_expr<'a>(expr: Expr, state: &mut State<'a>) -> Expr { Expr::Dot(x) => match (x.0, x.1) { // map.string (Expr::Map(m), Expr::Property(p)) if m.0.iter().all(|(_, x)| x.is_pure()) => { + let ((prop, _, _), _) = p.as_ref(); // Map literal where everything is pure - promote the indexed item. // All other items can be thrown away. state.set_dirty(); let pos = m.1; - m.0.into_iter().find(|((name, _), _)| name == &p.0) + m.0.into_iter().find(|((name, _), _)| name == prop) .map(|(_, expr)| expr.set_position(pos)) .unwrap_or_else(|| Expr::Unit(pos)) } @@ -414,7 +427,7 @@ fn optimize_expr<'a>(expr: Expr, state: &mut State<'a>) -> Expr { // Array literal where everything is pure - promote the indexed item. // All other items can be thrown away. state.set_dirty(); - a.0.remove(i.0 as usize).set_position(a.1) + a.0.take(i.0 as usize).set_position(a.1) } // map[string] (Expr::Map(m), Expr::StringConstant(s)) if m.0.iter().all(|(_, x)| x.is_pure()) => { @@ -438,14 +451,12 @@ fn optimize_expr<'a>(expr: Expr, state: &mut State<'a>) -> Expr { // [ items .. ] #[cfg(not(feature = "no_index"))] Expr::Array(a) => Expr::Array(Box::new((a.0 - .into_iter() - .map(|expr| optimize_expr(expr, state)) - .collect(), a.1))), + .into_iter().map(|expr| optimize_expr(expr, state)) + .collect(), a.1))), // [ items .. ] #[cfg(not(feature = "no_object"))] Expr::Map(m) => Expr::Map(Box::new((m.0 - .into_iter() - .map(|((key, pos), expr)| ((key, pos), optimize_expr(expr, state))) + .into_iter().map(|((key, pos), expr)| ((key, pos), optimize_expr(expr, state))) .collect(), m.1))), // lhs in rhs Expr::In(x) => match (x.0, x.1) { @@ -544,8 +555,8 @@ fn optimize_expr<'a>(expr: Expr, state: &mut State<'a>) -> Expr { return Expr::FnCall(x); } - let mut arg_values: Vec<_> = args.iter().map(Expr::get_constant_value).collect(); - let mut call_args: Vec<_> = arg_values.iter_mut().collect(); + let mut arg_values: StaticVec<_> = args.iter().map(Expr::get_constant_value).collect(); + let mut call_args: StaticVec<_> = arg_values.iter_mut().collect(); // Save the typename of the first argument if it is `type_of()` // This is to avoid `call_args` being passed into the closure @@ -555,7 +566,7 @@ fn optimize_expr<'a>(expr: Expr, state: &mut State<'a>) -> Expr { "" }; - call_fn(&state.engine.packages, &state.engine.base_package, name, &mut call_args, *pos).ok() + call_fn(&state.engine.packages, &state.engine.global_module, name, call_args.as_mut(), *pos).ok() .and_then(|result| result.or_else(|| { if !arg_for_type_of.is_empty() { @@ -695,11 +706,14 @@ pub fn optimize_into_ast( const level: OptimizationLevel = OptimizationLevel::None; #[cfg(not(feature = "no_function"))] - let fn_lib: Vec<_> = functions + let fn_lib_values: StaticVec<_> = functions .iter() .map(|fn_def| (fn_def.name.as_str(), fn_def.params.len())) .collect(); + #[cfg(not(feature = "no_function"))] + let fn_lib = fn_lib_values.as_ref(); + #[cfg(feature = "no_function")] const fn_lib: &[(&str, usize)] = &[]; @@ -709,7 +723,7 @@ pub fn optimize_into_ast( let pos = fn_def.body.position(); // Optimize the function body - let mut body = optimize(vec![fn_def.body], engine, &Scope::new(), &fn_lib, level); + let mut body = optimize(vec![fn_def.body], engine, &Scope::new(), fn_lib, level); // {} -> Noop fn_def.body = match body.pop().unwrap_or_else(|| Stmt::Noop(pos)) { @@ -735,7 +749,7 @@ pub fn optimize_into_ast( match level { OptimizationLevel::None => statements, OptimizationLevel::Simple | OptimizationLevel::Full => { - optimize(statements, engine, &scope, &fn_lib, level) + optimize(statements, engine, &scope, fn_lib, level) } }, lib, diff --git a/src/packages/arithmetic.rs b/src/packages/arithmetic.rs index c788fbb2..e4a26844 100644 --- a/src/packages/arithmetic.rs +++ b/src/packages/arithmetic.rs @@ -1,7 +1,5 @@ -use super::{reg_binary, reg_unary}; - use crate::def_package; -use crate::fn_register::{map_dynamic as map, map_result as result}; +use crate::module::FuncReturn; use crate::parser::INT; use crate::result::EvalAltResult; use crate::token::Position; @@ -22,7 +20,7 @@ use crate::stdlib::{ }; // Checked add -fn add(x: T, y: T) -> Result> { +fn add(x: T, y: T) -> FuncReturn { x.checked_add(&y).ok_or_else(|| { Box::new(EvalAltResult::ErrorArithmetic( format!("Addition overflow: {} + {}", x, y), @@ -31,7 +29,7 @@ fn add(x: T, y: T) -> Result> { }) } // Checked subtract -fn sub(x: T, y: T) -> Result> { +fn sub(x: T, y: T) -> FuncReturn { x.checked_sub(&y).ok_or_else(|| { Box::new(EvalAltResult::ErrorArithmetic( format!("Subtraction underflow: {} - {}", x, y), @@ -40,7 +38,7 @@ fn sub(x: T, y: T) -> Result> { }) } // Checked multiply -fn mul(x: T, y: T) -> Result> { +fn mul(x: T, y: T) -> FuncReturn { x.checked_mul(&y).ok_or_else(|| { Box::new(EvalAltResult::ErrorArithmetic( format!("Multiplication overflow: {} * {}", x, y), @@ -49,7 +47,7 @@ fn mul(x: T, y: T) -> Result> { }) } // Checked divide -fn div(x: T, y: T) -> Result> +fn div(x: T, y: T) -> FuncReturn where T: Display + CheckedDiv + PartialEq + Zero, { @@ -69,7 +67,7 @@ where }) } // Checked negative - e.g. -(i32::MIN) will overflow i32::MAX -fn neg(x: T) -> Result> { +fn neg(x: T) -> FuncReturn { x.checked_neg().ok_or_else(|| { Box::new(EvalAltResult::ErrorArithmetic( format!("Negation overflow: -{}", x), @@ -78,7 +76,7 @@ fn neg(x: T) -> Result> { }) } // Checked absolute -fn abs(x: T) -> Result> { +fn abs(x: T) -> FuncReturn { // FIX - We don't use Signed::abs() here because, contrary to documentation, it panics // when the number is ::MIN instead of returning ::MIN itself. if x >= ::zero() { @@ -93,49 +91,49 @@ fn abs(x: T) -> Result(x: T, y: T) -> ::Output { - x + y +fn add_u(x: T, y: T) -> FuncReturn<::Output> { + Ok(x + y) } // Unchecked subtract - may panic on underflow -fn sub_u(x: T, y: T) -> ::Output { - x - y +fn sub_u(x: T, y: T) -> FuncReturn<::Output> { + Ok(x - y) } // Unchecked multiply - may panic on overflow -fn mul_u(x: T, y: T) -> ::Output { - x * y +fn mul_u(x: T, y: T) -> FuncReturn<::Output> { + Ok(x * y) } // Unchecked divide - may panic when dividing by zero -fn div_u(x: T, y: T) -> ::Output { - x / y +fn div_u(x: T, y: T) -> FuncReturn<::Output> { + Ok(x / y) } // Unchecked negative - may panic on overflow -fn neg_u(x: T) -> ::Output { - -x +fn neg_u(x: T) -> FuncReturn<::Output> { + Ok(-x) } // Unchecked absolute - may panic on overflow -fn abs_u(x: T) -> ::Output +fn abs_u(x: T) -> FuncReturn<::Output> where T: Neg + PartialOrd + Default + Into<::Output>, { // Numbers should default to zero if x < Default::default() { - -x + Ok(-x) } else { - x.into() + Ok(x.into()) } } // Bit operators -fn binary_and(x: T, y: T) -> ::Output { - x & y +fn binary_and(x: T, y: T) -> FuncReturn<::Output> { + Ok(x & y) } -fn binary_or(x: T, y: T) -> ::Output { - x | y +fn binary_or(x: T, y: T) -> FuncReturn<::Output> { + Ok(x | y) } -fn binary_xor(x: T, y: T) -> ::Output { - x ^ y +fn binary_xor(x: T, y: T) -> FuncReturn<::Output> { + Ok(x ^ y) } // Checked left-shift -fn shl(x: T, y: INT) -> Result> { +fn shl(x: T, y: INT) -> FuncReturn { // Cannot shift by a negative number of bits if y < 0 { return Err(Box::new(EvalAltResult::ErrorArithmetic( @@ -152,7 +150,7 @@ fn shl(x: T, y: INT) -> Result> { }) } // Checked right-shift -fn shr(x: T, y: INT) -> Result> { +fn shr(x: T, y: INT) -> FuncReturn { // Cannot shift by a negative number of bits if y < 0 { return Err(Box::new(EvalAltResult::ErrorArithmetic( @@ -169,15 +167,15 @@ fn shr(x: T, y: INT) -> Result> { }) } // Unchecked left-shift - may panic if shifting by a negative number of bits -fn shl_u>(x: T, y: T) -> >::Output { - x.shl(y) +fn shl_u>(x: T, y: T) -> FuncReturn<>::Output> { + Ok(x.shl(y)) } // Unchecked right-shift - may panic if shifting by a negative number of bits -fn shr_u>(x: T, y: T) -> >::Output { - x.shr(y) +fn shr_u>(x: T, y: T) -> FuncReturn<>::Output> { + Ok(x.shr(y)) } // Checked modulo -fn modulo(x: T, y: T) -> Result> { +fn modulo(x: T, y: T) -> FuncReturn { x.checked_rem(&y).ok_or_else(|| { Box::new(EvalAltResult::ErrorArithmetic( format!("Modulo division by zero or overflow: {} % {}", x, y), @@ -186,11 +184,11 @@ fn modulo(x: T, y: T) -> Result> }) } // Unchecked modulo - may panic if dividing by zero -fn modulo_u(x: T, y: T) -> ::Output { - x % y +fn modulo_u(x: T, y: T) -> FuncReturn<::Output> { + Ok(x % y) } // Checked power -fn pow_i_i(x: INT, y: INT) -> Result> { +fn pow_i_i(x: INT, y: INT) -> FuncReturn { #[cfg(not(feature = "only_i32"))] { if y > (u32::MAX as INT) { @@ -231,17 +229,17 @@ fn pow_i_i(x: INT, y: INT) -> Result> { } } // Unchecked integer power - may panic on overflow or if the power index is too high (> u32::MAX) -fn pow_i_i_u(x: INT, y: INT) -> INT { - x.pow(y as u32) +fn pow_i_i_u(x: INT, y: INT) -> FuncReturn { + Ok(x.pow(y as u32)) } // Floating-point power - always well-defined #[cfg(not(feature = "no_float"))] -fn pow_f_f(x: FLOAT, y: FLOAT) -> FLOAT { - x.powf(y) +fn pow_f_f(x: FLOAT, y: FLOAT) -> FuncReturn { + Ok(x.powf(y)) } // Checked power #[cfg(not(feature = "no_float"))] -fn pow_f_i(x: FLOAT, y: INT) -> Result> { +fn pow_f_i(x: FLOAT, y: INT) -> FuncReturn { // Raise to power that is larger than an i32 if y > (i32::MAX as INT) { return Err(Box::new(EvalAltResult::ErrorArithmetic( @@ -255,39 +253,37 @@ fn pow_f_i(x: FLOAT, y: INT) -> Result> { // Unchecked power - may be incorrect if the power index is too high (> i32::MAX) #[cfg(feature = "unchecked")] #[cfg(not(feature = "no_float"))] -fn pow_f_i_u(x: FLOAT, y: INT) -> FLOAT { - x.powi(y as i32) +fn pow_f_i_u(x: FLOAT, y: INT) -> FuncReturn { + Ok(x.powi(y as i32)) } -macro_rules! reg_unary_x { ($lib:expr, $op:expr, $func:ident, $($par:ty),*) => { - $(reg_unary($lib, $op, $func::<$par>, result);)* }; +macro_rules! reg_unary { + ($lib:expr, $op:expr, $func:ident, $($par:ty),*) => { + $( $lib.set_fn_1($op, $func::<$par>); )* + }; } -macro_rules! reg_unary { ($lib:expr, $op:expr, $func:ident, $($par:ty),*) => { - $(reg_unary($lib, $op, $func::<$par>, map);)* }; -} -macro_rules! reg_op_x { ($lib:expr, $op:expr, $func:ident, $($par:ty),*) => { - $(reg_binary($lib, $op, $func::<$par>, result);)* }; -} -macro_rules! reg_op { ($lib:expr, $op:expr, $func:ident, $($par:ty),*) => { - $(reg_binary($lib, $op, $func::<$par>, map);)* }; +macro_rules! reg_op { + ($lib:expr, $op:expr, $func:ident, $($par:ty),*) => { + $( $lib.set_fn_2($op, $func::<$par>); )* + }; } def_package!(crate:ArithmeticPackage:"Basic arithmetic", lib, { // Checked basic arithmetic #[cfg(not(feature = "unchecked"))] { - reg_op_x!(lib, "+", add, INT); - reg_op_x!(lib, "-", sub, INT); - reg_op_x!(lib, "*", mul, INT); - reg_op_x!(lib, "/", div, INT); + reg_op!(lib, "+", add, INT); + reg_op!(lib, "-", sub, INT); + reg_op!(lib, "*", mul, INT); + reg_op!(lib, "/", div, INT); #[cfg(not(feature = "only_i32"))] #[cfg(not(feature = "only_i64"))] { - reg_op_x!(lib, "+", add, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128); - reg_op_x!(lib, "-", sub, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128); - reg_op_x!(lib, "*", mul, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128); - reg_op_x!(lib, "/", div, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128); + reg_op!(lib, "+", add, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128); + reg_op!(lib, "-", sub, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128); + reg_op!(lib, "*", mul, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128); + reg_op!(lib, "/", div, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128); } } @@ -334,16 +330,16 @@ def_package!(crate:ArithmeticPackage:"Basic arithmetic", lib, { // Checked bit shifts #[cfg(not(feature = "unchecked"))] { - reg_op_x!(lib, "<<", shl, INT); - reg_op_x!(lib, ">>", shr, INT); - reg_op_x!(lib, "%", modulo, INT); + reg_op!(lib, "<<", shl, INT); + reg_op!(lib, ">>", shr, INT); + reg_op!(lib, "%", modulo, INT); #[cfg(not(feature = "only_i32"))] #[cfg(not(feature = "only_i64"))] { - reg_op_x!(lib, "<<", shl, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128); - reg_op_x!(lib, ">>", shr, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128); - reg_op_x!(lib, "%", modulo, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128); + reg_op!(lib, "<<", shl, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128); + reg_op!(lib, ">>", shr, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128); + reg_op!(lib, "%", modulo, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128); } } @@ -366,39 +362,39 @@ def_package!(crate:ArithmeticPackage:"Basic arithmetic", lib, { // Checked power #[cfg(not(feature = "unchecked"))] { - reg_binary(lib, "~", pow_i_i, result); + lib.set_fn_2("~", pow_i_i); #[cfg(not(feature = "no_float"))] - reg_binary(lib, "~", pow_f_i, result); + lib.set_fn_2("~", pow_f_i); } // Unchecked power #[cfg(feature = "unchecked")] { - reg_binary(lib, "~", pow_i_i_u, map); + lib.set_fn_2("~", pow_i_i_u); #[cfg(not(feature = "no_float"))] - reg_binary(lib, "~", pow_f_i_u, map); + lib.set_fn_2("~", pow_f_i_u); } // Floating-point modulo and power #[cfg(not(feature = "no_float"))] { reg_op!(lib, "%", modulo_u, f32, f64); - reg_binary(lib, "~", pow_f_f, map); + lib.set_fn_2("~", pow_f_f); } // Checked unary #[cfg(not(feature = "unchecked"))] { - reg_unary_x!(lib, "-", neg, INT); - reg_unary_x!(lib, "abs", abs, INT); + reg_unary!(lib, "-", neg, INT); + reg_unary!(lib, "abs", abs, INT); #[cfg(not(feature = "only_i32"))] #[cfg(not(feature = "only_i64"))] { - reg_unary_x!(lib, "-", neg, i8, i16, i32, i64, i128); - reg_unary_x!(lib, "abs", abs, i8, i16, i32, i64, i128); + reg_unary!(lib, "-", neg, i8, i16, i32, i64, i128); + reg_unary!(lib, "abs", abs, i8, i16, i32, i64, i128); } } diff --git a/src/packages/array_basic.rs b/src/packages/array_basic.rs index dfb80422..eb56bbf4 100644 --- a/src/packages/array_basic.rs +++ b/src/packages/array_basic.rs @@ -1,41 +1,46 @@ #![cfg(not(feature = "no_index"))] -use super::{reg_binary, reg_binary_mut, reg_trinary_mut, reg_unary_mut}; - use crate::any::{Dynamic, Variant}; use crate::def_package; use crate::engine::Array; -use crate::fn_register::{map_dynamic as map, map_identity as pass}; +use crate::module::FuncReturn; use crate::parser::INT; use crate::stdlib::{any::TypeId, boxed::Box, string::String}; // Register array utility functions -fn push(list: &mut Array, item: T) { +fn push(list: &mut Array, item: T) -> FuncReturn<()> { list.push(Dynamic::from(item)); + Ok(()) } -fn ins(list: &mut Array, position: INT, item: T) { +fn ins(list: &mut Array, position: INT, item: T) -> FuncReturn<()> { if position <= 0 { list.insert(0, Dynamic::from(item)); } else if (position as usize) >= list.len() - 1 { - push(list, item); + push(list, item)?; } else { list.insert(position as usize, Dynamic::from(item)); } + Ok(()) } -fn pad(list: &mut Array, len: INT, item: T) { +fn pad(list: &mut Array, len: INT, item: T) -> FuncReturn<()> { if len >= 0 { while list.len() < len as usize { - push(list, item.clone()); + push(list, item.clone())?; } } + Ok(()) } -macro_rules! reg_op { ($lib:expr, $op:expr, $func:ident, $($par:ty),*) => { - $(reg_binary_mut($lib, $op, $func::<$par>, map);)* }; +macro_rules! reg_op { + ($lib:expr, $op:expr, $func:ident, $($par:ty),*) => { + $( $lib.set_fn_2_mut($op, $func::<$par>); )* + }; } -macro_rules! reg_tri { ($lib:expr, $op:expr, $func:ident, $($par:ty),*) => { - $(reg_trinary_mut($lib, $op, $func::<$par>, map);)* }; +macro_rules! reg_tri { + ($lib:expr, $op:expr, $func:ident, $($par:ty),*) => { + $( $lib.set_fn_3_mut($op, $func::<$par>); )* + }; } #[cfg(not(feature = "no_index"))] @@ -44,15 +49,16 @@ def_package!(crate:BasicArrayPackage:"Basic array utilities.", lib, { reg_tri!(lib, "pad", pad, INT, bool, char, String, Array, ()); reg_tri!(lib, "insert", ins, INT, bool, char, String, Array, ()); - reg_binary_mut(lib, "append", |x: &mut Array, y: Array| x.extend(y), map); - reg_binary( - lib, + lib.set_fn_2_mut("append", |x: &mut Array, y: Array| { + x.extend(y); + Ok(()) + }); + lib.set_fn_2( "+", |mut x: Array, y: Array| { x.extend(y); - x + Ok(x) }, - map, ); #[cfg(not(feature = "only_i32"))] @@ -70,40 +76,36 @@ def_package!(crate:BasicArrayPackage:"Basic array utilities.", lib, { reg_tri!(lib, "insert", ins, f32, f64); } - reg_unary_mut( - lib, + lib.set_fn_1_mut( "pop", - |list: &mut Array| list.pop().unwrap_or_else(|| ().into()), - pass, + |list: &mut Array| Ok(list.pop().unwrap_or_else(|| ().into())), ); - reg_unary_mut( - lib, + lib.set_fn_1_mut( "shift", |list: &mut Array| { - if list.is_empty() { + Ok(if list.is_empty() { ().into() } else { list.remove(0) - } + }) }, - pass, ); - reg_binary_mut( - lib, + lib.set_fn_2_mut( "remove", |list: &mut Array, len: INT| { - if len < 0 || (len as usize) >= list.len() { + Ok(if len < 0 || (len as usize) >= list.len() { ().into() } else { list.remove(len as usize) - } + }) }, - pass, ); - reg_unary_mut(lib, "len", |list: &mut Array| list.len() as INT, map); - reg_unary_mut(lib, "clear", |list: &mut Array| list.clear(), map); - reg_binary_mut( - lib, + lib.set_fn_1_mut("len", |list: &mut Array| Ok(list.len() as INT)); + lib.set_fn_1_mut("clear", |list: &mut Array| { + list.clear(); + Ok(()) + }); + lib.set_fn_2_mut( "truncate", |list: &mut Array, len: INT| { if len >= 0 { @@ -111,16 +113,13 @@ def_package!(crate:BasicArrayPackage:"Basic array utilities.", lib, { } else { list.clear(); } + Ok(()) }, - map, ); // Register array iterator - lib.type_iterators.insert( + lib.set_iter( TypeId::of::(), - Box::new(|a: Dynamic| { - Box::new(a.cast::().into_iter()) - as Box> - }), + |arr| Box::new(arr.cast::().into_iter()) as Box>, ); }); diff --git a/src/packages/eval.rs b/src/packages/eval.rs new file mode 100644 index 00000000..a6756d96 --- /dev/null +++ b/src/packages/eval.rs @@ -0,0 +1,12 @@ +use crate::def_package; +use crate::module::FuncReturn; +use crate::stdlib::string::String; + +def_package!(crate:EvalPackage:"Disable 'eval'.", lib, { + lib.set_fn_1_mut( + "eval", + |_: &mut String| -> FuncReturn<()> { + Err("eval is evil!".into()) + }, + ); +}); diff --git a/src/packages/iter_basic.rs b/src/packages/iter_basic.rs index 031ac095..ebf55992 100644 --- a/src/packages/iter_basic.rs +++ b/src/packages/iter_basic.rs @@ -1,8 +1,6 @@ -use super::{reg_binary, reg_trinary, PackageStore}; - use crate::any::{Dynamic, Variant}; use crate::def_package; -use crate::fn_register::map_dynamic as map; +use crate::module::{FuncReturn, Module}; use crate::parser::INT; use crate::stdlib::{ @@ -12,17 +10,18 @@ use crate::stdlib::{ }; // Register range function -fn reg_range(lib: &mut PackageStore) +fn reg_range(lib: &mut Module) where Range: Iterator, { - lib.type_iterators.insert( - TypeId::of::>(), - Box::new(|source: Dynamic| { - Box::new(source.cast::>().map(|x| x.into_dynamic())) - as Box> - }), - ); + lib.set_iter(TypeId::of::>(), |source| { + Box::new(source.cast::>().map(|x| x.into_dynamic())) + as Box> + }); +} + +fn get_range(from: T, to: T) -> FuncReturn> { + Ok(from..to) } // Register range function with step @@ -50,37 +49,38 @@ where } } -fn reg_step(lib: &mut PackageStore) +fn reg_step(lib: &mut Module) where for<'a> &'a T: Add<&'a T, Output = T>, T: Variant + Clone + PartialOrd, StepRange: Iterator, { - lib.type_iterators.insert( - TypeId::of::>(), - Box::new(|source: Dynamic| { - Box::new(source.cast::>().map(|x| x.into_dynamic())) - as Box> - }), - ); + lib.set_iter(TypeId::of::>(), |source| { + Box::new(source.cast::>().map(|x| x.into_dynamic())) + as Box> + }); +} + +fn get_step_range(from: T, to: T, step: T) -> FuncReturn> +where + for<'a> &'a T: Add<&'a T, Output = T>, + T: Variant + Clone + PartialOrd, +{ + Ok(StepRange::(from, to, step)) } def_package!(crate:BasicIteratorPackage:"Basic range iterators.", lib, { - fn get_range(from: T, to: T) -> Range { - from..to - } - reg_range::(lib); - reg_binary(lib, "range", get_range::, map); + lib.set_fn_2("range", get_range::); #[cfg(not(feature = "only_i32"))] #[cfg(not(feature = "only_i64"))] { macro_rules! reg_range { - ($self:expr, $x:expr, $( $y:ty ),*) => ( + ($lib:expr, $x:expr, $( $y:ty ),*) => ( $( - reg_range::<$y>($self); - reg_binary($self, $x, get_range::<$y>, map); + reg_range::<$y>($lib); + $lib.set_fn_2($x, get_range::<$y>); )* ) } @@ -89,16 +89,16 @@ def_package!(crate:BasicIteratorPackage:"Basic range iterators.", lib, { } reg_step::(lib); - reg_trinary(lib, "range", StepRange::, map); + lib.set_fn_3("range", get_step_range::); #[cfg(not(feature = "only_i32"))] #[cfg(not(feature = "only_i64"))] { macro_rules! reg_step { - ($self:expr, $x:expr, $( $y:ty ),*) => ( + ($lib:expr, $x:expr, $( $y:ty ),*) => ( $( - reg_step::<$y>($self); - reg_trinary($self, $x, StepRange::<$y>, map); + reg_step::<$y>($lib); + $lib.set_fn_3($x, get_step_range::<$y>); )* ) } diff --git a/src/packages/logic.rs b/src/packages/logic.rs index f993044a..ef771688 100644 --- a/src/packages/logic.rs +++ b/src/packages/logic.rs @@ -1,44 +1,44 @@ -use super::{reg_binary, reg_binary_mut, reg_unary}; - use crate::def_package; -use crate::fn_register::map_dynamic as map; +use crate::module::FuncReturn; use crate::parser::INT; use crate::stdlib::string::String; // Comparison operators -pub fn lt(x: T, y: T) -> bool { - x < y +pub fn lt(x: T, y: T) -> FuncReturn { + Ok(x < y) } -pub fn lte(x: T, y: T) -> bool { - x <= y +pub fn lte(x: T, y: T) -> FuncReturn { + Ok(x <= y) } -pub fn gt(x: T, y: T) -> bool { - x > y +pub fn gt(x: T, y: T) -> FuncReturn { + Ok(x > y) } -pub fn gte(x: T, y: T) -> bool { - x >= y +pub fn gte(x: T, y: T) -> FuncReturn { + Ok(x >= y) } -pub fn eq(x: T, y: T) -> bool { - x == y +pub fn eq(x: T, y: T) -> FuncReturn { + Ok(x == y) } -pub fn ne(x: T, y: T) -> bool { - x != y +pub fn ne(x: T, y: T) -> FuncReturn { + Ok(x != y) } // Logic operators -fn and(x: bool, y: bool) -> bool { - x && y +fn and(x: bool, y: bool) -> FuncReturn { + Ok(x && y) } -fn or(x: bool, y: bool) -> bool { - x || y +fn or(x: bool, y: bool) -> FuncReturn { + Ok(x || y) } -fn not(x: bool) -> bool { - !x +fn not(x: bool) -> FuncReturn { + Ok(!x) } -macro_rules! reg_op { ($lib:expr, $op:expr, $func:ident, $($par:ty),*) => { - $(reg_binary($lib, $op, $func::<$par>, map);)* }; +macro_rules! reg_op { + ($lib:expr, $op:expr, $func:ident, $($par:ty),*) => { + $( $lib.set_fn_2($op, $func::<$par>); )* + }; } def_package!(crate:LogicPackage:"Logical operators.", lib, { @@ -50,14 +50,12 @@ def_package!(crate:LogicPackage:"Logical operators.", lib, { reg_op!(lib, "!=", ne, INT, char, bool, ()); // Special versions for strings - at least avoid copying the first string - // use super::utils::reg_test; - // reg_test(lib, "<", |x: &mut String, y: String| *x < y, |v| v, map); - reg_binary_mut(lib, "<", |x: &mut String, y: String| *x < y, map); - reg_binary_mut(lib, "<=", |x: &mut String, y: String| *x <= y, map); - reg_binary_mut(lib, ">", |x: &mut String, y: String| *x > y, map); - reg_binary_mut(lib, ">=", |x: &mut String, y: String| *x >= y, map); - reg_binary_mut(lib, "==", |x: &mut String, y: String| *x == y, map); - reg_binary_mut(lib, "!=", |x: &mut String, y: String| *x != y, map); + lib.set_fn_2_mut("<", |x: &mut String, y: String| Ok(*x < y)); + lib.set_fn_2_mut("<=", |x: &mut String, y: String| Ok(*x <= y)); + lib.set_fn_2_mut(">", |x: &mut String, y: String| Ok(*x > y)); + lib.set_fn_2_mut(">=", |x: &mut String, y: String| Ok(*x >= y)); + lib.set_fn_2_mut("==", |x: &mut String, y: String| Ok(*x == y)); + lib.set_fn_2_mut("!=", |x: &mut String, y: String| Ok(*x != y)); #[cfg(not(feature = "only_i32"))] #[cfg(not(feature = "only_i64"))] @@ -85,7 +83,7 @@ def_package!(crate:LogicPackage:"Logical operators.", lib, { //reg_op!(lib, "||", or, bool); //reg_op!(lib, "&&", and, bool); - reg_binary(lib, "|", or, map); - reg_binary(lib, "&", and, map); - reg_unary(lib, "!", not, map); + lib.set_fn_2("|", or); + lib.set_fn_2("&", and); + lib.set_fn_1("!", not); }); diff --git a/src/packages/map_basic.rs b/src/packages/map_basic.rs index 451897bf..c9f4e894 100644 --- a/src/packages/map_basic.rs +++ b/src/packages/map_basic.rs @@ -1,11 +1,9 @@ #![cfg(not(feature = "no_object"))] -use super::{reg_binary, reg_binary_mut, reg_unary_mut}; - use crate::any::Dynamic; use crate::def_package; use crate::engine::Map; -use crate::fn_register::map_dynamic as map; +use crate::module::FuncReturn; use crate::parser::INT; use crate::stdlib::{ @@ -13,55 +11,51 @@ use crate::stdlib::{ vec::Vec, }; -fn map_get_keys(map: &mut Map) -> Vec { - map.iter().map(|(k, _)| k.to_string().into()).collect() +fn map_get_keys(map: &mut Map) -> FuncReturn> { + Ok(map.iter().map(|(k, _)| k.to_string().into()).collect()) } -fn map_get_values(map: &mut Map) -> Vec { - map.iter().map(|(_, v)| v.clone()).collect() +fn map_get_values(map: &mut Map) -> FuncReturn> { + Ok(map.iter().map(|(_, v)| v.clone()).collect()) } #[cfg(not(feature = "no_object"))] def_package!(crate:BasicMapPackage:"Basic object map utilities.", lib, { - reg_binary_mut( - lib, + lib.set_fn_2_mut( "has", - |map: &mut Map, prop: String| map.contains_key(&prop), - map, + |map: &mut Map, prop: String| Ok(map.contains_key(&prop)), ); - reg_unary_mut(lib, "len", |map: &mut Map| map.len() as INT, map); - reg_unary_mut(lib, "clear", |map: &mut Map| map.clear(), map); - reg_binary_mut( - lib, + lib.set_fn_1_mut("len", |map: &mut Map| Ok(map.len() as INT)); + lib.set_fn_1_mut("clear", |map: &mut Map| { + map.clear(); + Ok(()) + }); + lib.set_fn_2_mut( "remove", - |x: &mut Map, name: String| x.remove(&name).unwrap_or_else(|| ().into()), - map, + |x: &mut Map, name: String| Ok(x.remove(&name).unwrap_or_else(|| ().into())), ); - reg_binary_mut( - lib, + lib.set_fn_2_mut( "mixin", |map1: &mut Map, map2: Map| { map2.into_iter().for_each(|(key, value)| { map1.insert(key, value); }); + Ok(()) }, - map, ); - reg_binary( - lib, + lib.set_fn_2( "+", |mut map1: Map, map2: Map| { map2.into_iter().for_each(|(key, value)| { map1.insert(key, value); }); - map1 + Ok(map1) }, - map, ); // Register map access functions #[cfg(not(feature = "no_index"))] - reg_unary_mut(lib, "keys", map_get_keys, map); + lib.set_fn_1_mut("keys", map_get_keys); #[cfg(not(feature = "no_index"))] - reg_unary_mut(lib, "values", map_get_values, map); + lib.set_fn_1_mut("values", map_get_values); }); diff --git a/src/packages/math_basic.rs b/src/packages/math_basic.rs index a39f477c..9c7313ed 100644 --- a/src/packages/math_basic.rs +++ b/src/packages/math_basic.rs @@ -1,7 +1,4 @@ -use super::{reg_binary, reg_unary}; - use crate::def_package; -use crate::fn_register::{map_dynamic as map, map_result as result}; use crate::parser::INT; use crate::result::EvalAltResult; use crate::token::Position; @@ -20,78 +17,77 @@ def_package!(crate:BasicMathPackage:"Basic mathematic functions.", lib, { #[cfg(not(feature = "no_float"))] { // Advanced math functions - reg_unary(lib, "sin", |x: FLOAT| x.to_radians().sin(), map); - reg_unary(lib, "cos", |x: FLOAT| x.to_radians().cos(), map); - reg_unary(lib, "tan", |x: FLOAT| x.to_radians().tan(), map); - reg_unary(lib, "sinh", |x: FLOAT| x.to_radians().sinh(), map); - reg_unary(lib, "cosh", |x: FLOAT| x.to_radians().cosh(), map); - reg_unary(lib, "tanh", |x: FLOAT| x.to_radians().tanh(), map); - reg_unary(lib, "asin", |x: FLOAT| x.asin().to_degrees(), map); - reg_unary(lib, "acos", |x: FLOAT| x.acos().to_degrees(), map); - reg_unary(lib, "atan", |x: FLOAT| x.atan().to_degrees(), map); - reg_unary(lib, "asinh", |x: FLOAT| x.asinh().to_degrees(), map); - reg_unary(lib, "acosh", |x: FLOAT| x.acosh().to_degrees(), map); - reg_unary(lib, "atanh", |x: FLOAT| x.atanh().to_degrees(), map); - reg_unary(lib, "sqrt", |x: FLOAT| x.sqrt(), map); - reg_unary(lib, "exp", |x: FLOAT| x.exp(), map); - reg_unary(lib, "ln", |x: FLOAT| x.ln(), map); - reg_binary(lib, "log", |x: FLOAT, base: FLOAT| x.log(base), map); - reg_unary(lib, "log10", |x: FLOAT| x.log10(), map); - reg_unary(lib, "floor", |x: FLOAT| x.floor(), map); - reg_unary(lib, "ceiling", |x: FLOAT| x.ceil(), map); - reg_unary(lib, "round", |x: FLOAT| x.ceil(), map); - reg_unary(lib, "int", |x: FLOAT| x.trunc(), map); - reg_unary(lib, "fraction", |x: FLOAT| x.fract(), map); - reg_unary(lib, "is_nan", |x: FLOAT| x.is_nan(), map); - reg_unary(lib, "is_finite", |x: FLOAT| x.is_finite(), map); - reg_unary(lib, "is_infinite", |x: FLOAT| x.is_infinite(), map); + lib.set_fn_1("sin", |x: FLOAT| Ok(x.to_radians().sin())); + lib.set_fn_1("cos", |x: FLOAT| Ok(x.to_radians().cos())); + lib.set_fn_1("tan", |x: FLOAT| Ok(x.to_radians().tan())); + lib.set_fn_1("sinh", |x: FLOAT| Ok(x.to_radians().sinh())); + lib.set_fn_1("cosh", |x: FLOAT| Ok(x.to_radians().cosh())); + lib.set_fn_1("tanh", |x: FLOAT| Ok(x.to_radians().tanh())); + lib.set_fn_1("asin", |x: FLOAT| Ok(x.asin().to_degrees())); + lib.set_fn_1("acos", |x: FLOAT| Ok(x.acos().to_degrees())); + lib.set_fn_1("atan", |x: FLOAT| Ok(x.atan().to_degrees())); + lib.set_fn_1("asinh", |x: FLOAT| Ok(x.asinh().to_degrees())); + lib.set_fn_1("acosh", |x: FLOAT| Ok(x.acosh().to_degrees())); + lib.set_fn_1("atanh", |x: FLOAT| Ok(x.atanh().to_degrees())); + lib.set_fn_1("sqrt", |x: FLOAT| Ok(x.sqrt())); + lib.set_fn_1("exp", |x: FLOAT| Ok(x.exp())); + lib.set_fn_1("ln", |x: FLOAT| Ok(x.ln())); + lib.set_fn_2("log", |x: FLOAT, base: FLOAT| Ok(x.log(base))); + lib.set_fn_1("log10", |x: FLOAT| Ok(x.log10())); + lib.set_fn_1("floor", |x: FLOAT| Ok(x.floor())); + lib.set_fn_1("ceiling", |x: FLOAT| Ok(x.ceil())); + lib.set_fn_1("round", |x: FLOAT| Ok(x.ceil())); + lib.set_fn_1("int", |x: FLOAT| Ok(x.trunc())); + lib.set_fn_1("fraction", |x: FLOAT| Ok(x.fract())); + lib.set_fn_1("is_nan", |x: FLOAT| Ok(x.is_nan())); + lib.set_fn_1("is_finite", |x: FLOAT| Ok(x.is_finite())); + lib.set_fn_1("is_infinite", |x: FLOAT| Ok(x.is_infinite())); // Register conversion functions - reg_unary(lib, "to_float", |x: INT| x as FLOAT, map); - reg_unary(lib, "to_float", |x: f32| x as FLOAT, map); + lib.set_fn_1("to_float", |x: INT| Ok(x as FLOAT)); + lib.set_fn_1("to_float", |x: f32| Ok(x as FLOAT)); #[cfg(not(feature = "only_i32"))] #[cfg(not(feature = "only_i64"))] { - reg_unary(lib, "to_float", |x: i8| x as FLOAT, map); - reg_unary(lib, "to_float", |x: u8| x as FLOAT, map); - reg_unary(lib, "to_float", |x: i16| x as FLOAT, map); - reg_unary(lib, "to_float", |x: u16| x as FLOAT, map); - reg_unary(lib, "to_float", |x: i32| x as FLOAT, map); - reg_unary(lib, "to_float", |x: u32| x as FLOAT, map); - reg_unary(lib, "to_float", |x: i64| x as FLOAT, map); - reg_unary(lib, "to_float", |x: u64| x as FLOAT, map); - reg_unary(lib, "to_float", |x: i128| x as FLOAT, map); - reg_unary(lib, "to_float", |x: u128| x as FLOAT, map); + lib.set_fn_1("to_float", |x: i8| Ok(x as FLOAT)); + lib.set_fn_1("to_float", |x: u8| Ok(x as FLOAT)); + lib.set_fn_1("to_float", |x: i16| Ok(x as FLOAT)); + lib.set_fn_1("to_float", |x: u16| Ok(x as FLOAT)); + lib.set_fn_1("to_float", |x: i32| Ok(x as FLOAT)); + lib.set_fn_1("to_float", |x: u32| Ok(x as FLOAT)); + lib.set_fn_1("to_float", |x: i64| Ok(x as FLOAT)); + lib.set_fn_1("to_float", |x: u64| Ok(x as FLOAT)); + lib.set_fn_1("to_float", |x: i128| Ok(x as FLOAT)); + lib.set_fn_1("to_float", |x: u128| Ok(x as FLOAT)); } } - reg_unary(lib, "to_int", |ch: char| ch as INT, map); + lib.set_fn_1("to_int", |ch: char| Ok(ch as INT)); #[cfg(not(feature = "only_i32"))] #[cfg(not(feature = "only_i64"))] { - reg_unary(lib, "to_int", |x: i8| x as INT, map); - reg_unary(lib, "to_int", |x: u8| x as INT, map); - reg_unary(lib, "to_int", |x: i16| x as INT, map); - reg_unary(lib, "to_int", |x: u16| x as INT, map); + lib.set_fn_1("to_int", |x: i8| Ok(x as INT)); + lib.set_fn_1("to_int", |x: u8| Ok(x as INT)); + lib.set_fn_1("to_int", |x: i16| Ok(x as INT)); + lib.set_fn_1("to_int", |x: u16| Ok(x as INT)); } #[cfg(not(feature = "only_i32"))] { - reg_unary(lib, "to_int", |x: i32| x as INT, map); - reg_unary(lib, "to_int", |x: u64| x as INT, map); + lib.set_fn_1("to_int", |x: i32| Ok(x as INT)); + lib.set_fn_1("to_int", |x: u64| Ok(x as INT)); #[cfg(feature = "only_i64")] - reg_unary(lib, "to_int", |x: u32| x as INT, map); + lib.set_fn_1("to_int", |x: u32| Ok(x as INT)); } #[cfg(not(feature = "no_float"))] { #[cfg(not(feature = "unchecked"))] { - reg_unary( - lib, + lib.set_fn_1( "to_int", |x: f32| { if x > (MAX_INT as f32) { @@ -103,10 +99,8 @@ def_package!(crate:BasicMathPackage:"Basic mathematic functions.", lib, { Ok(x.trunc() as INT) }, - result, ); - reg_unary( - lib, + lib.set_fn_1( "to_int", |x: FLOAT| { if x > (MAX_INT as FLOAT) { @@ -118,14 +112,13 @@ def_package!(crate:BasicMathPackage:"Basic mathematic functions.", lib, { Ok(x.trunc() as INT) }, - result, ); } #[cfg(feature = "unchecked")] { - reg_unary(lib, "to_int", |x: f32| x as INT, map); - reg_unary(lib, "to_int", |x: f64| x as INT, map); + lib.set_fn_1("to_int", |x: f32| Ok(x as INT)); + lib.set_fn_1("to_int", |x: f64| Ok(x as INT)); } } }); diff --git a/src/packages/mod.rs b/src/packages/mod.rs index 0d935e40..54b6ecea 100644 --- a/src/packages/mod.rs +++ b/src/packages/mod.rs @@ -1,11 +1,14 @@ -//! This module contains all built-in _packages_ available to Rhai, plus facilities to define custom packages. +//! Module containing all built-in _packages_ available to Rhai, plus facilities to define custom packages. -use crate::engine::{FnAny, IteratorFn}; +use crate::fn_native::{CallableFunction, IteratorFn}; +use crate::module::Module; +use crate::utils::StaticVec; use crate::stdlib::{any::TypeId, boxed::Box, collections::HashMap, rc::Rc, sync::Arc, vec::Vec}; mod arithmetic; mod array_basic; +mod eval; mod iter_basic; mod logic; mod map_basic; @@ -15,11 +18,11 @@ mod pkg_std; mod string_basic; mod string_more; mod time_basic; -mod utils; pub use arithmetic::ArithmeticPackage; #[cfg(not(feature = "no_index"))] pub use array_basic::BasicArrayPackage; +pub use eval::EvalPackage; pub use iter_basic::BasicIteratorPackage; pub use logic::LogicPackage; #[cfg(not(feature = "no_object"))] @@ -32,74 +35,29 @@ pub use string_more::MoreStringPackage; #[cfg(not(feature = "no_std"))] pub use time_basic::BasicTimePackage; -pub use utils::*; - -const NUM_NATIVE_FUNCTIONS: usize = 512; - /// Trait that all packages must implement. pub trait Package { /// Register all the functions in a package into a store. - fn init(lib: &mut PackageStore); + fn init(lib: &mut Module); /// Retrieve the generic package library from this package. fn get(&self) -> PackageLibrary; } -/// Type to store all functions in the package. -pub struct PackageStore { - /// All functions, keyed by a hash created from the function name and parameter types. - pub functions: HashMap>, - - /// All iterator functions, keyed by the type producing the iterator. - pub type_iterators: HashMap>, -} - -impl PackageStore { - /// Create a new `PackageStore`. - pub fn new() -> Self { - Default::default() - } - /// Does the specified function hash key exist in the `PackageStore`? - pub fn contains_function(&self, hash: u64) -> bool { - self.functions.contains_key(&hash) - } - /// Get specified function via its hash key. - pub fn get_function(&self, hash: u64) -> Option<&Box> { - self.functions.get(&hash) - } - /// Does the specified TypeId iterator exist in the `PackageStore`? - pub fn contains_iterator(&self, id: TypeId) -> bool { - self.type_iterators.contains_key(&id) - } - /// Get the specified TypeId iterator. - pub fn get_iterator(&self, id: TypeId) -> Option<&Box> { - self.type_iterators.get(&id) - } -} - -impl Default for PackageStore { - fn default() -> Self { - Self { - functions: HashMap::with_capacity(NUM_NATIVE_FUNCTIONS), - type_iterators: HashMap::with_capacity(4), - } - } -} - -/// Type which `Rc`-wraps a `PackageStore` to facilitate sharing library instances. +/// Type which `Rc`-wraps a `Module` to facilitate sharing library instances. #[cfg(not(feature = "sync"))] -pub type PackageLibrary = Rc; +pub type PackageLibrary = Rc; -/// Type which `Arc`-wraps a `PackageStore` to facilitate sharing library instances. +/// Type which `Arc`-wraps a `Module` to facilitate sharing library instances. #[cfg(feature = "sync")] -pub type PackageLibrary = Arc; +pub type PackageLibrary = Arc; /// Type containing a collection of `PackageLibrary` instances. /// All function and type iterator keys in the loaded packages are indexed for fast access. #[derive(Clone, Default)] pub(crate) struct PackagesCollection { /// Collection of `PackageLibrary` instances. - packages: Vec, + packages: StaticVec, } impl PackagesCollection { @@ -109,27 +67,75 @@ impl PackagesCollection { self.packages.insert(0, package); } /// Does the specified function hash key exist in the `PackagesCollection`? - pub fn contains_function(&self, hash: u64) -> bool { - self.packages.iter().any(|p| p.contains_function(hash)) + pub fn contains_fn(&self, hash: u64) -> bool { + self.packages.iter().any(|p| p.contains_fn(hash)) } /// Get specified function via its hash key. - pub fn get_function(&self, hash: u64) -> Option<&Box> { + pub fn get_fn(&self, hash: u64) -> Option<&CallableFunction> { self.packages .iter() - .map(|p| p.get_function(hash)) + .map(|p| p.get_fn(hash)) .find(|f| f.is_some()) .flatten() } /// Does the specified TypeId iterator exist in the `PackagesCollection`? - pub fn contains_iterator(&self, id: TypeId) -> bool { - self.packages.iter().any(|p| p.contains_iterator(id)) + pub fn contains_iter(&self, id: TypeId) -> bool { + self.packages.iter().any(|p| p.contains_iter(id)) } /// Get the specified TypeId iterator. - pub fn get_iterator(&self, id: TypeId) -> Option<&Box> { + pub fn get_iter(&self, id: TypeId) -> Option { self.packages .iter() - .map(|p| p.get_iterator(id)) + .map(|p| p.get_iter(id)) .find(|f| f.is_some()) .flatten() } } + +/// Macro that makes it easy to define a _package_ (which is basically a shared module) +/// and register functions into it. +/// +/// Functions can be added to the package using the standard module methods such as +/// `set_fn_2`, `set_fn_3_mut`, `set_fn_0` etc. +/// +/// # Examples +/// +/// ``` +/// use rhai::{Dynamic, EvalAltResult}; +/// use rhai::def_package; +/// +/// fn add(x: i64, y: i64) -> Result> { Ok(x + y) } +/// +/// def_package!(rhai:MyPackage:"My super-duper package", lib, +/// { +/// // Load a binary function with all value parameters. +/// lib.set_fn_2("my_add", add); +/// }); +/// ``` +/// +/// The above defines a package named 'MyPackage' with a single function named 'my_add'. +#[macro_export] +macro_rules! def_package { + ($root:ident : $package:ident : $comment:expr , $lib:ident , $block:stmt) => { + #[doc=$comment] + pub struct $package($root::packages::PackageLibrary); + + impl $root::packages::Package for $package { + fn get(&self) -> $root::packages::PackageLibrary { + self.0.clone() + } + + fn init($lib: &mut $root::Module) { + $block + } + } + + impl $package { + pub fn new() -> Self { + let mut module = $root::Module::new_with_capacity(512); + ::init(&mut module); + Self(module.into()) + } + } + }; +} diff --git a/src/packages/string_basic.rs b/src/packages/string_basic.rs index e58890d1..3b1689cf 100644 --- a/src/packages/string_basic.rs +++ b/src/packages/string_basic.rs @@ -1,8 +1,6 @@ -use super::{reg_binary, reg_binary_mut, reg_none, reg_unary, reg_unary_mut}; - use crate::def_package; use crate::engine::{FUNC_TO_STRING, KEYWORD_DEBUG, KEYWORD_PRINT}; -use crate::fn_register::map_dynamic as map; +use crate::module::FuncReturn; use crate::parser::INT; #[cfg(not(feature = "no_index"))] @@ -18,31 +16,33 @@ use crate::stdlib::{ }; // Register print and debug -fn to_debug(x: &mut T) -> String { - format!("{:?}", x) +fn to_debug(x: &mut T) -> FuncReturn { + Ok(format!("{:?}", x)) } -fn to_string(x: &mut T) -> String { - format!("{}", x) +fn to_string(x: &mut T) -> FuncReturn { + Ok(format!("{}", x)) } #[cfg(not(feature = "no_object"))] -fn format_map(x: &mut Map) -> String { - format!("#{:?}", x) +fn format_map(x: &mut Map) -> FuncReturn { + Ok(format!("#{:?}", x)) } -macro_rules! reg_op { ($lib:expr, $op:expr, $func:ident, $($par:ty),*) => { - $(reg_unary_mut($lib, $op, $func::<$par>, map);)* }; +macro_rules! reg_op { + ($lib:expr, $op:expr, $func:ident, $($par:ty),*) => { + $( $lib.set_fn_1_mut($op, $func::<$par>); )* + }; } def_package!(crate:BasicStringPackage:"Basic string utilities, including printing.", lib, { reg_op!(lib, KEYWORD_PRINT, to_string, INT, bool, char); reg_op!(lib, FUNC_TO_STRING, to_string, INT, bool, char); - reg_none(lib, KEYWORD_PRINT, || "".to_string(), map); - reg_unary(lib, KEYWORD_PRINT, |_: ()| "".to_string(), map); - reg_unary(lib, FUNC_TO_STRING, |_: ()| "".to_string(), map); + lib.set_fn_0(KEYWORD_PRINT, || Ok("".to_string())); + lib.set_fn_1(KEYWORD_PRINT, |_: ()| Ok("".to_string())); + lib.set_fn_1(FUNC_TO_STRING, |_: ()| Ok("".to_string())); - reg_unary_mut(lib, KEYWORD_PRINT, |s: &mut String| s.clone(), map); - reg_unary_mut(lib, FUNC_TO_STRING, |s: &mut String| s.clone(), map); + lib.set_fn_1_mut(KEYWORD_PRINT, |s: &mut String| Ok(s.clone())); + lib.set_fn_1_mut(FUNC_TO_STRING, |s: &mut String| Ok(s.clone())); reg_op!(lib, KEYWORD_DEBUG, to_debug, INT, bool, (), char, String); @@ -73,34 +73,34 @@ def_package!(crate:BasicStringPackage:"Basic string utilities, including printin #[cfg(not(feature = "no_object"))] { - reg_unary_mut(lib, KEYWORD_PRINT, format_map, map); - reg_unary_mut(lib, FUNC_TO_STRING, format_map, map); - reg_unary_mut(lib, KEYWORD_DEBUG, format_map, map); + lib.set_fn_1_mut(KEYWORD_PRINT, format_map); + lib.set_fn_1_mut(FUNC_TO_STRING, format_map); + lib.set_fn_1_mut(KEYWORD_DEBUG, format_map); } - reg_binary( - lib, + lib.set_fn_2( "+", |mut s: String, ch: char| { s.push(ch); - s + Ok(s) }, - map, ); - reg_binary( - lib, + lib.set_fn_2( "+", |mut s: String, s2: String| { s.push_str(&s2); - s + Ok(s) }, - map, ); - reg_binary_mut(lib, "append", |s: &mut String, ch: char| s.push(ch), map); - reg_binary_mut( - lib, + lib.set_fn_2_mut("append", |s: &mut String, ch: char| { + s.push(ch); + Ok(()) + }); + lib.set_fn_2_mut( "append", - |s: &mut String, s2: String| s.push_str(&s2), - map, + |s: &mut String, s2: String| { + s.push_str(&s2); + Ok(()) + } ); }); diff --git a/src/packages/string_more.rs b/src/packages/string_more.rs index 2badac23..2c90bea5 100644 --- a/src/packages/string_more.rs +++ b/src/packages/string_more.rs @@ -1,8 +1,7 @@ -use super::{reg_binary, reg_binary_mut, reg_trinary_mut, reg_unary_mut}; - use crate::def_package; -use crate::fn_register::map_dynamic as map; +use crate::module::FuncReturn; use crate::parser::INT; +use crate::utils::StaticVec; #[cfg(not(feature = "no_index"))] use crate::engine::Array; @@ -14,24 +13,24 @@ use crate::stdlib::{ vec::Vec, }; -fn prepend(x: T, y: String) -> String { - format!("{}{}", x, y) +fn prepend(x: T, y: String) -> FuncReturn { + Ok(format!("{}{}", x, y)) } -fn append(x: String, y: T) -> String { - format!("{}{}", x, y) +fn append(x: String, y: T) -> FuncReturn { + Ok(format!("{}{}", x, y)) } -fn sub_string(s: &mut String, start: INT, len: INT) -> String { +fn sub_string(s: &mut String, start: INT, len: INT) -> FuncReturn { let offset = if s.is_empty() || len <= 0 { - return "".to_string(); + return Ok("".to_string()); } else if start < 0 { 0 } else if (start as usize) >= s.chars().count() { - return "".to_string(); + return Ok("".to_string()); } else { start as usize }; - let chars: Vec<_> = s.chars().collect(); + let chars: StaticVec<_> = s.chars().collect(); let len = if offset + (len as usize) > chars.len() { chars.len() - offset @@ -39,22 +38,22 @@ fn sub_string(s: &mut String, start: INT, len: INT) -> String { len as usize }; - chars[offset..][..len].into_iter().collect() + Ok(chars.iter().skip(offset).take(len).cloned().collect()) } -fn crop_string(s: &mut String, start: INT, len: INT) { +fn crop_string(s: &mut String, start: INT, len: INT) -> FuncReturn<()> { let offset = if s.is_empty() || len <= 0 { s.clear(); - return; + return Ok(()); } else if start < 0 { 0 } else if (start as usize) >= s.chars().count() { s.clear(); - return; + return Ok(()); } else { start as usize }; - let chars: Vec<_> = s.chars().collect(); + let chars: StaticVec<_> = s.chars().collect(); let len = if offset + (len as usize) > chars.len() { chars.len() - offset @@ -64,21 +63,27 @@ fn crop_string(s: &mut String, start: INT, len: INT) { s.clear(); - chars[offset..][..len] - .into_iter() + chars + .iter() + .skip(offset) + .take(len) .for_each(|&ch| s.push(ch)); + + Ok(()) } -macro_rules! reg_op { ($lib:expr, $op:expr, $func:ident, $($par:ty),*) => { - $(reg_binary($lib, $op, $func::<$par>, map);)* }; +macro_rules! reg_op { + ($lib:expr, $op:expr, $func:ident, $($par:ty),*) => { + $( $lib.set_fn_2($op, $func::<$par>); )* + }; } def_package!(crate:MoreStringPackage:"Additional string utilities, including string building.", lib, { reg_op!(lib, "+", append, INT, bool, char); - reg_binary_mut(lib, "+", |x: &mut String, _: ()| x.clone(), map); + lib.set_fn_2_mut( "+", |x: &mut String, _: ()| Ok(x.clone())); reg_op!(lib, "+", prepend, INT, bool, char); - reg_binary(lib, "+", |_: (), y: String| y, map); + lib.set_fn_2("+", |_: (), y: String| Ok(y)); #[cfg(not(feature = "only_i32"))] #[cfg(not(feature = "only_i64"))] @@ -95,139 +100,153 @@ def_package!(crate:MoreStringPackage:"Additional string utilities, including str #[cfg(not(feature = "no_index"))] { - reg_binary(lib, "+", |x: String, y: Array| format!("{}{:?}", x, y), map); - reg_binary(lib, "+", |x: Array, y: String| format!("{:?}{}", x, y), map); + lib.set_fn_2("+", |x: String, y: Array| Ok(format!("{}{:?}", x, y))); + lib.set_fn_2("+", |x: Array, y: String| Ok(format!("{:?}{}", x, y))); } - reg_unary_mut(lib, "len", |s: &mut String| s.chars().count() as INT, map); - reg_binary_mut( - lib, + lib.set_fn_1_mut("len", |s: &mut String| Ok(s.chars().count() as INT)); + lib.set_fn_2_mut( "contains", - |s: &mut String, ch: char| s.contains(ch), - map, + |s: &mut String, ch: char| Ok(s.contains(ch)), ); - reg_binary_mut( - lib, + lib.set_fn_2_mut( "contains", - |s: &mut String, find: String| s.contains(&find), - map, + |s: &mut String, find: String| Ok(s.contains(&find)), ); - reg_trinary_mut( - lib, + lib.set_fn_3_mut( "index_of", |s: &mut String, ch: char, start: INT| { let start = if start < 0 { 0 } else if (start as usize) >= s.chars().count() { - return -1 as INT; + return Ok(-1 as INT); } else { s.chars().take(start as usize).collect::().len() }; - s[start..] + Ok(s[start..] .find(ch) .map(|index| s[0..start + index].chars().count() as INT) - .unwrap_or(-1 as INT) + .unwrap_or(-1 as INT)) }, - map, ); - reg_binary_mut( - lib, + lib.set_fn_2_mut( "index_of", |s: &mut String, ch: char| { - s.find(ch) + Ok(s.find(ch) .map(|index| s[0..index].chars().count() as INT) - .unwrap_or(-1 as INT) + .unwrap_or(-1 as INT)) }, - map, ); - reg_trinary_mut( - lib, + lib.set_fn_3_mut( "index_of", |s: &mut String, find: String, start: INT| { let start = if start < 0 { 0 } else if (start as usize) >= s.chars().count() { - return -1 as INT; + return Ok(-1 as INT); } else { s.chars().take(start as usize).collect::().len() }; - s[start..] + Ok(s[start..] .find(&find) .map(|index| s[0..start + index].chars().count() as INT) - .unwrap_or(-1 as INT) + .unwrap_or(-1 as INT)) }, - map, ); - reg_binary_mut( - lib, + lib.set_fn_2_mut( "index_of", |s: &mut String, find: String| { - s.find(&find) + Ok(s.find(&find) .map(|index| s[0..index].chars().count() as INT) - .unwrap_or(-1 as INT) + .unwrap_or(-1 as INT)) }, - map, ); - reg_unary_mut(lib, "clear", |s: &mut String| s.clear(), map); - reg_binary_mut(lib, "append", |s: &mut String, ch: char| s.push(ch), map); - reg_binary_mut( - lib, + lib.set_fn_1_mut("clear", |s: &mut String| { + s.clear(); + Ok(()) + }); + lib.set_fn_2_mut( "append", |s: &mut String, ch: char| { + s.push(ch); + Ok(()) + }); + lib.set_fn_2_mut( "append", - |s: &mut String, add: String| s.push_str(&add), - map, + |s: &mut String, add: String| { + s.push_str(&add); + Ok(()) + } ); - reg_trinary_mut(lib, "sub_string", sub_string, map); - reg_binary_mut( - lib, + lib.set_fn_3_mut( "sub_string", sub_string); + lib.set_fn_2_mut( "sub_string", |s: &mut String, start: INT| sub_string(s, start, s.len() as INT), - map, ); - reg_trinary_mut(lib, "crop", crop_string, map); - reg_binary_mut( - lib, + lib.set_fn_3_mut( "crop", crop_string); + lib.set_fn_2_mut( "crop", |s: &mut String, start: INT| crop_string(s, start, s.len() as INT), - map, ); - reg_binary_mut( - lib, + lib.set_fn_2_mut( "truncate", |s: &mut String, len: INT| { if len >= 0 { - let chars: Vec<_> = s.chars().take(len as usize).collect(); + let chars: StaticVec<_> = s.chars().take(len as usize).collect(); s.clear(); - chars.into_iter().for_each(|ch| s.push(ch)); + chars.iter().for_each(|&ch| s.push(ch)); } else { s.clear(); } + Ok(()) }, - map, ); - reg_trinary_mut( - lib, + lib.set_fn_3_mut( "pad", |s: &mut String, len: INT, ch: char| { for _ in 0..s.chars().count() - len as usize { s.push(ch); } + Ok(()) }, - map, ); - reg_trinary_mut( - lib, + lib.set_fn_3_mut( "replace", |s: &mut String, find: String, sub: String| { let new_str = s.replace(&find, &sub); s.clear(); s.push_str(&new_str); + Ok(()) }, - map, ); - reg_unary_mut( - lib, + lib.set_fn_3_mut( + "replace", + |s: &mut String, find: String, sub: char| { + let new_str = s.replace(&find, &sub.to_string()); + s.clear(); + s.push_str(&new_str); + Ok(()) + }, + ); + lib.set_fn_3_mut( + "replace", + |s: &mut String, find: char, sub: String| { + let new_str = s.replace(&find.to_string(), &sub); + s.clear(); + s.push_str(&new_str); + Ok(()) + }, + ); + lib.set_fn_3_mut( + "replace", + |s: &mut String, find: char, sub: char| { + let new_str = s.replace(&find.to_string(), &sub.to_string()); + s.clear(); + s.push_str(&new_str); + Ok(()) + }, + ); + lib.set_fn_1_mut( "trim", |s: &mut String| { let trimmed = s.trim(); @@ -235,7 +254,7 @@ def_package!(crate:MoreStringPackage:"Additional string utilities, including str if trimmed.len() < s.len() { *s = trimmed.to_string(); } + Ok(()) }, - map, ); }); diff --git a/src/packages/time_basic.rs b/src/packages/time_basic.rs index 173c3e22..7d80344c 100644 --- a/src/packages/time_basic.rs +++ b/src/packages/time_basic.rs @@ -1,9 +1,8 @@ use super::logic::{eq, gt, gte, lt, lte, ne}; use super::math_basic::MAX_INT; -use super::{reg_binary, reg_none, reg_unary}; use crate::def_package; -use crate::fn_register::{map_dynamic as map, map_result as result}; +use crate::module::FuncReturn; use crate::parser::INT; use crate::result::EvalAltResult; use crate::token::Position; @@ -14,10 +13,9 @@ use crate::stdlib::time::Instant; #[cfg(not(feature = "no_std"))] def_package!(crate:BasicTimePackage:"Basic timing utilities.", lib, { // Register date/time functions - reg_none(lib, "timestamp", || Instant::now(), map); + lib.set_fn_0("timestamp", || Ok(Instant::now())); - reg_binary( - lib, + lib.set_fn_2( "-", |ts1: Instant, ts2: Instant| { if ts2 > ts1 { @@ -63,18 +61,16 @@ def_package!(crate:BasicTimePackage:"Basic timing utilities.", lib, { } } }, - result, ); - reg_binary(lib, "<", lt::, map); - reg_binary(lib, "<=", lte::, map); - reg_binary(lib, ">", gt::, map); - reg_binary(lib, ">=", gte::, map); - reg_binary(lib, "==", eq::, map); - reg_binary(lib, "!=", ne::, map); + lib.set_fn_2("<", lt::); + lib.set_fn_2("<=", lte::); + lib.set_fn_2(">", gt::); + lib.set_fn_2(">=", gte::); + lib.set_fn_2("==", eq::); + lib.set_fn_2("!=", ne::); - reg_unary( - lib, + lib.set_fn_1( "elapsed", |timestamp: Instant| { #[cfg(not(feature = "no_float"))] @@ -96,6 +92,5 @@ def_package!(crate:BasicTimePackage:"Basic timing utilities.", lib, { return Ok(seconds as INT); } }, - result, ); }); diff --git a/src/packages/utils.rs b/src/packages/utils.rs deleted file mode 100644 index fbb8c31d..00000000 --- a/src/packages/utils.rs +++ /dev/null @@ -1,451 +0,0 @@ -use super::PackageStore; - -use crate::any::{Dynamic, Variant}; -use crate::calc_fn_hash; -use crate::engine::FnCallArgs; -use crate::result::EvalAltResult; -use crate::token::Position; - -use crate::stdlib::{ - any::TypeId, - boxed::Box, - iter::empty, - mem, - string::{String, ToString}, -}; - -/// This macro makes it easy to define a _package_ and register functions into it. -/// -/// Functions can be added to the package using a number of helper functions under the `packages` module, -/// such as `reg_unary`, `reg_binary_mut`, `reg_trinary_mut` etc. -/// -/// # Examples -/// -/// ``` -/// use rhai::Dynamic; -/// use rhai::def_package; -/// use rhai::packages::reg_binary; -/// -/// fn add(x: i64, y: i64) -> i64 { x + y } -/// -/// def_package!(rhai:MyPackage:"My super-duper package", lib, -/// { -/// reg_binary(lib, "my_add", add, |v, _| Ok(v.into())); -/// // ^^^^^^^^^^^^^^^^^^^ -/// // map into Result> -/// }); -/// ``` -/// -/// The above defines a package named 'MyPackage' with a single function named 'my_add'. -#[macro_export] -macro_rules! def_package { - ($root:ident : $package:ident : $comment:expr , $lib:ident , $block:stmt) => { - #[doc=$comment] - pub struct $package($root::packages::PackageLibrary); - - impl $root::packages::Package for $package { - fn get(&self) -> $root::packages::PackageLibrary { - self.0.clone() - } - - fn init($lib: &mut $root::packages::PackageStore) { - $block - } - } - - impl $package { - pub fn new() -> Self { - let mut pkg = $root::packages::PackageStore::new(); - ::init(&mut pkg); - Self(pkg.into()) - } - } - }; -} - -/// Check whether the correct number of arguments is passed to the function. -fn check_num_args( - name: &str, - num_args: usize, - args: &mut FnCallArgs, - pos: Position, -) -> Result<(), Box> { - if args.len() != num_args { - Err(Box::new(EvalAltResult::ErrorFunctionArgsMismatch( - name.to_string(), - num_args, - args.len(), - pos, - ))) - } else { - Ok(()) - } -} - -/// Add a function with no parameters to the package. -/// -/// `map_result` is a function that maps the return type of the function to `Result`. -/// -/// # Examples -/// -/// ``` -/// use rhai::Dynamic; -/// use rhai::def_package; -/// use rhai::packages::reg_none; -/// -/// fn get_answer() -> i64 { 42 } -/// -/// def_package!(rhai:MyPackage:"My super-duper package", lib, -/// { -/// reg_none(lib, "my_answer", get_answer, |v, _| Ok(v.into())); -/// // ^^^^^^^^^^^^^^^^^^^ -/// // map into Result> -/// }); -/// ``` -/// -/// The above defines a package named 'MyPackage' with a single function named 'my_add_1'. -pub fn reg_none( - lib: &mut PackageStore, - fn_name: &'static str, - - #[cfg(not(feature = "sync"))] func: impl Fn() -> R + 'static, - #[cfg(feature = "sync")] func: impl Fn() -> R + Send + Sync + 'static, - - #[cfg(not(feature = "sync"))] map_result: impl Fn(R, Position) -> Result> - + 'static, - #[cfg(feature = "sync")] map_result: impl Fn(R, Position) -> Result> - + Send - + Sync - + 'static, -) { - let hash = calc_fn_hash(empty(), fn_name, ([] as [TypeId; 0]).iter().cloned()); - - let f = Box::new(move |args: &mut FnCallArgs, pos: Position| { - check_num_args(fn_name, 0, args, pos)?; - - let r = func(); - map_result(r, pos) - }); - - lib.functions.insert(hash, f); -} - -/// Add a function with one parameter to the package. -/// -/// `map_result` is a function that maps the return type of the function to `Result`. -/// -/// # Examples -/// -/// ``` -/// use rhai::Dynamic; -/// use rhai::def_package; -/// use rhai::packages::reg_unary; -/// -/// fn add_1(x: i64) -> i64 { x + 1 } -/// -/// def_package!(rhai:MyPackage:"My super-duper package", lib, -/// { -/// reg_unary(lib, "my_add_1", add_1, |v, _| Ok(v.into())); -/// // ^^^^^^^^^^^^^^^^^^^ -/// // map into Result> -/// }); -/// ``` -/// -/// The above defines a package named 'MyPackage' with a single function named 'my_add_1'. -pub fn reg_unary( - lib: &mut PackageStore, - fn_name: &'static str, - - #[cfg(not(feature = "sync"))] func: impl Fn(T) -> R + 'static, - #[cfg(feature = "sync")] func: impl Fn(T) -> R + Send + Sync + 'static, - - #[cfg(not(feature = "sync"))] map_result: impl Fn(R, Position) -> Result> - + 'static, - #[cfg(feature = "sync")] map_result: impl Fn(R, Position) -> Result> - + Send - + Sync - + 'static, -) { - //println!("register {}({})", fn_name, crate::std::any::type_name::()); - - let hash = calc_fn_hash(empty(), fn_name, [TypeId::of::()].iter().cloned()); - - let f = Box::new(move |args: &mut FnCallArgs, pos: Position| { - check_num_args(fn_name, 1, args, pos)?; - - let mut drain = args.iter_mut(); - let x = mem::take(*drain.next().unwrap()).cast::(); - - let r = func(x); - map_result(r, pos) - }); - - lib.functions.insert(hash, f); -} - -/// Add a function with one mutable reference parameter to the package. -/// -/// `map_result` is a function that maps the return type of the function to `Result`. -/// -/// # Examples -/// -/// ``` -/// use rhai::{Dynamic, EvalAltResult}; -/// use rhai::def_package; -/// use rhai::packages::reg_unary_mut; -/// -/// fn inc(x: &mut i64) -> Result> { -/// if *x == 0 { -/// return Err("boo! zero cannot be incremented!".into()) -/// } -/// *x += 1; -/// Ok(().into()) -/// } -/// -/// def_package!(rhai:MyPackage:"My super-duper package", lib, -/// { -/// reg_unary_mut(lib, "try_inc", inc, |r, _| r); -/// // ^^^^^^^^ -/// // map into Result> -/// }); -/// ``` -/// -/// The above defines a package named 'MyPackage' with a single fallible function named 'try_inc' -/// which takes a first argument of `&mut`, return a `Result>`. -pub fn reg_unary_mut( - lib: &mut PackageStore, - fn_name: &'static str, - - #[cfg(not(feature = "sync"))] func: impl Fn(&mut T) -> R + 'static, - #[cfg(feature = "sync")] func: impl Fn(&mut T) -> R + Send + Sync + 'static, - - #[cfg(not(feature = "sync"))] map_result: impl Fn(R, Position) -> Result> - + 'static, - #[cfg(feature = "sync")] map_result: impl Fn(R, Position) -> Result> - + Send - + Sync - + 'static, -) { - //println!("register {}(&mut {})", fn_name, crate::std::any::type_name::()); - - let hash = calc_fn_hash(empty(), fn_name, [TypeId::of::()].iter().cloned()); - - let f = Box::new(move |args: &mut FnCallArgs, pos: Position| { - check_num_args(fn_name, 1, args, pos)?; - - let mut drain = args.iter_mut(); - let x: &mut T = drain.next().unwrap().downcast_mut().unwrap(); - - let r = func(x); - map_result(r, pos) - }); - - lib.functions.insert(hash, f); -} - -/// Add a function with two parameters to the package. -/// -/// `map_result` is a function that maps the return type of the function to `Result`. -/// -/// # Examples -/// -/// ``` -/// use rhai::Dynamic; -/// use rhai::def_package; -/// use rhai::packages::reg_binary; -/// -/// fn add(x: i64, y: i64) -> i64 { x + y } -/// -/// def_package!(rhai:MyPackage:"My super-duper package", lib, -/// { -/// reg_binary(lib, "my_add", add, |v, _| Ok(v.into())); -/// // ^^^^^^^^^^^^^^^^^^^ -/// // map into Result> -/// }); -/// ``` -/// -/// The above defines a package named 'MyPackage' with a single function named 'my_add'. -pub fn reg_binary( - lib: &mut PackageStore, - fn_name: &'static str, - - #[cfg(not(feature = "sync"))] func: impl Fn(A, B) -> R + 'static, - #[cfg(feature = "sync")] func: impl Fn(A, B) -> R + Send + Sync + 'static, - - #[cfg(not(feature = "sync"))] map_result: impl Fn(R, Position) -> Result> - + 'static, - #[cfg(feature = "sync")] map_result: impl Fn(R, Position) -> Result> - + Send - + Sync - + 'static, -) { - //println!("register {}({}, {})", fn_name, crate::std::any::type_name::(), crate::std::any::type_name::()); - - let hash = calc_fn_hash( - empty(), - fn_name, - [TypeId::of::(), TypeId::of::()].iter().cloned(), - ); - - let f = Box::new(move |args: &mut FnCallArgs, pos: Position| { - check_num_args(fn_name, 2, args, pos)?; - - let mut drain = args.iter_mut(); - let x = mem::take(*drain.next().unwrap()).cast::(); - let y = mem::take(*drain.next().unwrap()).cast::(); - - let r = func(x, y); - map_result(r, pos) - }); - - lib.functions.insert(hash, f); -} - -/// Add a function with two parameters (the first one being a mutable reference) to the package. -/// -/// `map_result` is a function that maps the return type of the function to `Result`. -/// -/// # Examples -/// -/// ``` -/// use rhai::{Dynamic, EvalAltResult}; -/// use rhai::def_package; -/// use rhai::packages::reg_binary_mut; -/// -/// fn add(x: &mut i64, y: i64) -> Result> { -/// if y == 0 { -/// return Err("boo! cannot add zero!".into()) -/// } -/// *x += y; -/// Ok(().into()) -/// } -/// -/// def_package!(rhai:MyPackage:"My super-duper package", lib, -/// { -/// reg_binary_mut(lib, "try_add", add, |r, _| r); -/// // ^^^^^^^^ -/// // map into Result> -/// }); -/// ``` -/// -/// The above defines a package named 'MyPackage' with a single fallible function named 'try_add' -/// which takes a first argument of `&mut`, return a `Result>`. -pub fn reg_binary_mut( - lib: &mut PackageStore, - fn_name: &'static str, - - #[cfg(not(feature = "sync"))] func: impl Fn(&mut A, B) -> R + 'static, - #[cfg(feature = "sync")] func: impl Fn(&mut A, B) -> R + Send + Sync + 'static, - - #[cfg(not(feature = "sync"))] map_result: impl Fn(R, Position) -> Result> - + 'static, - #[cfg(feature = "sync")] map_result: impl Fn(R, Position) -> Result> - + Send - + Sync - + 'static, -) { - //println!("register {}(&mut {}, {})", fn_name, crate::std::any::type_name::(), crate::std::any::type_name::()); - - let hash = calc_fn_hash( - empty(), - fn_name, - [TypeId::of::(), TypeId::of::()].iter().cloned(), - ); - - let f = Box::new(move |args: &mut FnCallArgs, pos: Position| { - check_num_args(fn_name, 2, args, pos)?; - - let mut drain = args.iter_mut(); - let x: &mut A = drain.next().unwrap().downcast_mut().unwrap(); - let y = mem::take(*drain.next().unwrap()).cast::(); - - let r = func(x, y); - map_result(r, pos) - }); - - lib.functions.insert(hash, f); -} - -/// Add a function with three parameters to the package. -/// -/// `map_result` is a function that maps the return type of the function to `Result`. -pub fn reg_trinary( - lib: &mut PackageStore, - fn_name: &'static str, - - #[cfg(not(feature = "sync"))] func: impl Fn(A, B, C) -> R + 'static, - #[cfg(feature = "sync")] func: impl Fn(A, B, C) -> R + Send + Sync + 'static, - - #[cfg(not(feature = "sync"))] map_result: impl Fn(R, Position) -> Result> - + 'static, - #[cfg(feature = "sync")] map_result: impl Fn(R, Position) -> Result> - + Send - + Sync - + 'static, -) { - //println!("register {}({}, {}, {})", fn_name, crate::std::any::type_name::(), crate::std::any::type_name::(), crate::std::any::type_name::()); - - let hash = calc_fn_hash( - empty(), - fn_name, - [TypeId::of::(), TypeId::of::(), TypeId::of::()] - .iter() - .cloned(), - ); - - let f = Box::new(move |args: &mut FnCallArgs, pos: Position| { - check_num_args(fn_name, 3, args, pos)?; - - let mut drain = args.iter_mut(); - let x = mem::take(*drain.next().unwrap()).cast::(); - let y = mem::take(*drain.next().unwrap()).cast::(); - let z = mem::take(*drain.next().unwrap()).cast::(); - - let r = func(x, y, z); - map_result(r, pos) - }); - - lib.functions.insert(hash, f); -} - -/// Add a function with three parameters (the first one is a mutable reference) to the package. -/// -/// `map_result` is a function that maps the return type of the function to `Result`. -pub fn reg_trinary_mut( - lib: &mut PackageStore, - fn_name: &'static str, - - #[cfg(not(feature = "sync"))] func: impl Fn(&mut A, B, C) -> R + 'static, - #[cfg(feature = "sync")] func: impl Fn(&mut A, B, C) -> R + Send + Sync + 'static, - - #[cfg(not(feature = "sync"))] map_result: impl Fn(R, Position) -> Result> - + 'static, - #[cfg(feature = "sync")] map_result: impl Fn(R, Position) -> Result> - + Send - + Sync - + 'static, -) { - //println!("register {}(&mut {}, {}, {})", fn_name, crate::std::any::type_name::(), crate::std::any::type_name::(), crate::std::any::type_name::()); - - let hash = calc_fn_hash( - empty(), - fn_name, - [TypeId::of::(), TypeId::of::(), TypeId::of::()] - .iter() - .cloned(), - ); - - let f = Box::new(move |args: &mut FnCallArgs, pos: Position| { - check_num_args(fn_name, 3, args, pos)?; - - let mut drain = args.iter_mut(); - let x: &mut A = drain.next().unwrap().downcast_mut().unwrap(); - let y = mem::take(*drain.next().unwrap()).cast::(); - let z = mem::take(*drain.next().unwrap()).cast::(); - - let r = func(x, y, z); - map_result(r, pos) - }); - - lib.functions.insert(hash, f); -} diff --git a/src/parser.rs b/src/parser.rs index aebcf037..e03f3686 100644 --- a/src/parser.rs +++ b/src/parser.rs @@ -2,18 +2,18 @@ use crate::any::{Dynamic, Union}; use crate::calc_fn_hash; -use crate::engine::{Engine, FunctionsLib}; +use crate::engine::{make_getter, make_setter, Engine, FunctionsLib}; use crate::error::{LexError, ParseError, ParseErrorType}; use crate::optimize::{optimize_into_ast, OptimizationLevel}; use crate::scope::{EntryType as ScopeEntryType, Scope}; use crate::token::{Position, Token, TokenIterator}; -use crate::utils::EMPTY_TYPE_ID; +use crate::utils::StaticVec; #[cfg(not(feature = "no_module"))] use crate::module::ModuleRef; #[cfg(feature = "no_module")] -#[derive(Debug, Clone, Copy)] +#[derive(Debug, Eq, PartialEq, Clone, Hash, Copy, Default)] pub struct ModuleRef; use crate::stdlib::{ @@ -22,12 +22,10 @@ use crate::stdlib::{ char, collections::HashMap, format, - iter::{empty, repeat, Peekable}, + iter::{empty, Peekable}, num::NonZeroUsize, ops::{Add, Deref, DerefMut}, - rc::Rc, string::{String, ToString}, - sync::Arc, vec, vec::Vec, }; @@ -59,21 +57,14 @@ type PERR = ParseErrorType; pub struct AST( /// Global statements. Vec, - /// Script-defined functions, wrapped in an `Arc` for shared access. - #[cfg(feature = "sync")] - Arc, - /// Script-defined functions, wrapped in an `Rc` for shared access. - #[cfg(not(feature = "sync"))] - Rc, + /// Script-defined functions. + FunctionsLib, ); impl AST { /// Create a new `AST`. pub fn new(statements: Vec, fn_lib: FunctionsLib) -> Self { - #[cfg(feature = "sync")] - return Self(statements, Arc::new(fn_lib)); - #[cfg(not(feature = "sync"))] - return Self(statements, Rc::new(fn_lib)); + Self(statements, fn_lib) } /// Get the statements. @@ -88,7 +79,7 @@ impl AST { /// Get the script-defined functions. pub(crate) fn fn_lib(&self) -> &FunctionsLib { - self.1.as_ref() + &self.1 } /// Merge two `AST` into one. Both `AST`'s are untouched and a new, merged, version @@ -147,20 +138,13 @@ impl AST { (true, true) => vec![], }; - Self::new(ast, functions.merge(other.1.as_ref())) + Self::new(ast, functions.merge(&other.1)) } /// Clear all function definitions in the `AST`. #[cfg(not(feature = "no_function"))] pub fn clear_functions(&mut self) { - #[cfg(feature = "sync")] - { - self.1 = Arc::new(Default::default()); - } - #[cfg(not(feature = "sync"))] - { - self.1 = Rc::new(Default::default()); - } + self.1 = Default::default(); } /// Clear all statements in the `AST`, leaving only function definitions. @@ -179,7 +163,7 @@ impl Add for &AST { } /// A type representing the access mode of a scripted function. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)] pub enum FnAccess { /// Private function. Private, @@ -195,7 +179,7 @@ pub struct FnDef { /// Function access mode. pub access: FnAccess, /// Names of function parameters. - pub params: Vec, + pub params: StaticVec, /// Function body. pub body: Stmt, /// Position of the function definition. @@ -203,7 +187,7 @@ pub struct FnDef { } /// `return`/`throw` statement. -#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)] +#[derive(Debug, Eq, PartialEq, Hash, Clone, Copy)] pub enum ReturnType { /// `return` statement. Return, @@ -211,21 +195,27 @@ pub enum ReturnType { Exception, } -/// A type that encapsulates a local stack with variable names to simulate an actual runtime scope. #[derive(Debug, Clone, Default)] -struct Stack(Vec<(String, ScopeEntryType)>); +struct ParseState { + /// Encapsulates a local stack with variable names to simulate an actual runtime scope. + stack: Vec<(String, ScopeEntryType)>, + max_expr_depth: usize, +} -impl Stack { - /// Create a new `Stack`. - pub fn new() -> Self { - Default::default() +impl ParseState { + /// Create a new `ParseState`. + pub fn new(max_expr_depth: usize) -> Self { + Self { + max_expr_depth, + ..Default::default() + } } - /// Find a variable by name in the `Stack`, searching in reverse. + /// Find a variable by name in the `ParseState`, searching in reverse. /// The return value is the offset to be deducted from `Stack::len`, - /// i.e. the top element of the `Stack` is offset 1. - /// Return zero when the variable name is not found in the `Stack`. + /// i.e. the top element of the `ParseState` is offset 1. + /// Return zero when the variable name is not found in the `ParseState`. pub fn find(&self, name: &str) -> Option { - self.0 + self.stack .iter() .rev() .enumerate() @@ -235,12 +225,12 @@ impl Stack { }) .and_then(|(i, _)| NonZeroUsize::new(i + 1)) } - /// Find a module by name in the `Stack`, searching in reverse. + /// Find a module by name in the `ParseState`, searching in reverse. /// The return value is the offset to be deducted from `Stack::len`, - /// i.e. the top element of the `Stack` is offset 1. - /// Return zero when the variable name is not found in the `Stack`. + /// i.e. the top element of the `ParseState` is offset 1. + /// Return zero when the variable name is not found in the `ParseState`. pub fn find_module(&self, name: &str) -> Option { - self.0 + self.stack .iter() .rev() .enumerate() @@ -252,17 +242,17 @@ impl Stack { } } -impl Deref for Stack { +impl Deref for ParseState { type Target = Vec<(String, ScopeEntryType)>; fn deref(&self) -> &Self::Target { - &self.0 + &self.stack } } -impl DerefMut for Stack { +impl DerefMut for ParseState { fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 + &mut self.stack } } @@ -287,7 +277,7 @@ pub enum Stmt { /// const id = expr Const(Box<((String, Position), Expr)>), /// { stmt; ... } - Block(Box<(Vec, Position)>), + Block(Box<(StaticVec, Position)>), /// { stmt } Expr(Box), /// continue @@ -299,7 +289,13 @@ pub enum Stmt { /// import expr as module Import(Box<(Expr, (String, Position))>), /// expr id as name, ... - Export(Box)>>), + Export(Box)>>), +} + +impl Default for Stmt { + fn default() -> Self { + Self::Noop(Default::default()) + } } impl Stmt { @@ -317,7 +313,7 @@ impl Stmt { Stmt::Loop(x) => x.position(), Stmt::For(x) => x.2.position(), Stmt::Import(x) => (x.1).1, - Stmt::Export(x) => (x.get(0).unwrap().0).1, + Stmt::Export(x) => (x.get(0).0).1, } } @@ -388,7 +384,7 @@ pub enum Expr { /// Variable access - ((variable name, position), optional modules, hash, optional index) Variable(Box<((String, Position), MRef, u64, Option)>), /// Property access. - Property(Box<(String, Position)>), + Property(Box<((String, String, String), Position)>), /// { stmt } Stmt(Box<(Stmt, Position)>), /// func(expr, ... ) - ((function name, position), optional modules, hash, arguments, optional default value) @@ -399,7 +395,7 @@ pub enum Expr { (Cow<'static, str>, Position), MRef, u64, - Vec, + StaticVec, Option, )>, ), @@ -410,9 +406,9 @@ pub enum Expr { /// expr[expr] Index(Box<(Expr, Expr, Position)>), /// [ expr, ... ] - Array(Box<(Vec, Position)>), + Array(Box<(StaticVec, Position)>), /// #{ name:expr, ... } - Map(Box<(Vec<((String, Position), Expr)>, Position)>), + Map(Box<(StaticVec<((String, Position), Expr)>, Position)>), /// lhs in rhs In(Box<(Expr, Expr, Position)>), /// lhs && rhs @@ -427,6 +423,12 @@ pub enum Expr { Unit(Position), } +impl Default for Expr { + fn default() -> Self { + Self::Unit(Default::default()) + } +} + impl Expr { /// Get the `Dynamic` value of a constant expression. /// @@ -509,7 +511,7 @@ impl Expr { } } - /// Get the `Position` of the expression. + /// Override the `Position` of the expression. pub(crate) fn set_position(mut self, new_pos: Position) -> Self { match &mut self { #[cfg(not(feature = "no_float"))] @@ -634,7 +636,9 @@ impl Expr { match self { Self::Variable(x) if x.1.is_none() => { let (name, pos) = x.0; - Self::Property(Box::new((name.clone(), pos))) + let getter = make_getter(&name); + let setter = make_setter(&name); + Self::Property(Box::new(((name.clone(), getter, setter), pos))) } _ => self, } @@ -670,15 +674,20 @@ fn match_token(input: &mut Peekable, token: Token) -> Result( input: &mut Peekable>, - stack: &mut Stack, + state: &mut ParseState, pos: Position, + level: usize, allow_stmt_expr: bool, ) -> Result> { + if level > state.max_expr_depth { + return Err(PERR::ExprTooDeep.into_err(pos)); + } + if match_token(input, Token::RightParen)? { return Ok(Expr::Unit(pos)); } - let expr = parse_expr(input, stack, allow_stmt_expr)?; + let expr = parse_expr(input, state, level + 1, allow_stmt_expr)?; match input.next().unwrap() { // ( xxx ) @@ -697,18 +706,25 @@ fn parse_paren_expr<'a>( /// Parse a function call. fn parse_call_expr<'a>( input: &mut Peekable>, - stack: &mut Stack, + state: &mut ParseState, id: String, #[cfg(not(feature = "no_module"))] mut modules: Option>, #[cfg(feature = "no_module")] modules: Option, begin: Position, + level: usize, allow_stmt_expr: bool, ) -> Result> { - let mut args = Vec::new(); + let (token, pos) = input.peek().unwrap(); - match input.peek().unwrap() { + if level > state.max_expr_depth { + return Err(PERR::ExprTooDeep.into_err(*pos)); + } + + let mut args = StaticVec::new(); + + match token { // id - (Token::EOF, pos) => { + Token::EOF => { return Err(PERR::MissingToken( Token::RightParen.into(), format!("to close the arguments list of this function call '{}'", id), @@ -716,25 +732,26 @@ fn parse_call_expr<'a>( .into_err(*pos)) } // id - (Token::LexError(err), pos) => return Err(PERR::BadInput(err.to_string()).into_err(*pos)), + Token::LexError(err) => return Err(PERR::BadInput(err.to_string()).into_err(*pos)), // id() - (Token::RightParen, _) => { + Token::RightParen => { eat_token(input, Token::RightParen); #[cfg(not(feature = "no_module"))] let hash_fn_def = { if let Some(modules) = modules.as_mut() { - modules.set_index(stack.find_module(&modules.get_ref(0).0)); + modules.set_index(state.find_module(&modules.get(0).0)); // Rust functions are indexed in two steps: // 1) Calculate a hash in a similar manner to script-defined functions, - // i.e. qualifiers + function name + no parameters. - // 2) Calculate a second hash with no qualifiers, empty function name, and - // the actual list of parameter `TypeId`'.s + // i.e. qualifiers + function name + number of arguments. + // 2) Calculate a second hash with no qualifiers, empty function name, + // zero number of arguments, and the actual list of argument `TypeId`'s. // 3) The final hash is the XOR of the two hashes. - calc_fn_hash(modules.iter().map(|(m, _)| m.as_str()), &id, empty()) + let qualifiers = modules.iter().map(|(m, _)| m.as_str()); + calc_fn_hash(qualifiers, &id, 0, empty()) } else { - calc_fn_hash(empty(), &id, empty()) + calc_fn_hash(empty(), &id, 0, empty()) } }; // Qualifiers (none) + function name + no parameters. @@ -754,7 +771,7 @@ fn parse_call_expr<'a>( } loop { - args.push(parse_expr(input, stack, allow_stmt_expr)?); + args.push(parse_expr(input, state, level + 1, allow_stmt_expr)?); match input.peek().unwrap() { // id(...args) @@ -764,27 +781,23 @@ fn parse_call_expr<'a>( #[cfg(not(feature = "no_module"))] let hash_fn_def = { if let Some(modules) = modules.as_mut() { - modules.set_index(stack.find_module(&modules.get_ref(0).0)); + modules.set_index(state.find_module(&modules.get(0).0)); // Rust functions are indexed in two steps: // 1) Calculate a hash in a similar manner to script-defined functions, - // i.e. qualifiers + function name + dummy parameter types (one for each parameter). - // 2) Calculate a second hash with no qualifiers, empty function name, and - // the actual list of parameter `TypeId`'.s + // i.e. qualifiers + function name + number of arguments. + // 2) Calculate a second hash with no qualifiers, empty function name, + // zero number of arguments, and the actual list of argument `TypeId`'s. // 3) The final hash is the XOR of the two hashes. - calc_fn_hash( - modules.iter().map(|(m, _)| m.as_str()), - &id, - repeat(EMPTY_TYPE_ID()).take(args.len()), - ) + let qualifiers = modules.iter().map(|(m, _)| m.as_str()); + calc_fn_hash(qualifiers, &id, args.len(), empty()) } else { - calc_fn_hash(empty(), &id, repeat(EMPTY_TYPE_ID()).take(args.len())) + calc_fn_hash(empty(), &id, args.len(), empty()) } }; // Qualifiers (none) + function name + dummy parameter types (one for each parameter). #[cfg(feature = "no_module")] - let hash_fn_def = - calc_fn_hash(empty(), &id, repeat(EMPTY_TYPE_ID()).take(args.len())); + let hash_fn_def = calc_fn_hash(empty(), &id, args_iter); return Ok(Expr::FnCall(Box::new(( (id.into(), begin), @@ -826,12 +839,17 @@ fn parse_call_expr<'a>( /// Indexing binds to the right, so this call parses all possible levels of indexing following in the input. fn parse_index_chain<'a>( input: &mut Peekable>, - stack: &mut Stack, + state: &mut ParseState, lhs: Expr, pos: Position, + level: usize, allow_stmt_expr: bool, ) -> Result> { - let idx_expr = parse_expr(input, stack, allow_stmt_expr)?; + if level > state.max_expr_depth { + return Err(PERR::ExprTooDeep.into_err(pos)); + } + + let idx_expr = parse_expr(input, state, level + 1, allow_stmt_expr)?; // Check type of indexing - must be integer or string match &idx_expr { @@ -982,12 +1000,18 @@ fn parse_index_chain<'a>( match input.peek().unwrap() { // If another indexing level, right-bind it (Token::LeftBracket, _) => { - let follow_pos = eat_token(input, Token::LeftBracket); + let idx_pos = eat_token(input, Token::LeftBracket); // Recursively parse the indexing chain, right-binding each - let follow = - parse_index_chain(input, stack, idx_expr, follow_pos, allow_stmt_expr)?; + let idx = parse_index_chain( + input, + state, + idx_expr, + idx_pos, + level + 1, + allow_stmt_expr, + )?; // Indexing binds to right - Ok(Expr::Index(Box::new((lhs, follow, pos)))) + Ok(Expr::Index(Box::new((lhs, idx, pos)))) } // Otherwise terminate the indexing chain _ => Ok(Expr::Index(Box::new((lhs, idx_expr, pos)))), @@ -1005,15 +1029,20 @@ fn parse_index_chain<'a>( /// Parse an array literal. fn parse_array_literal<'a>( input: &mut Peekable>, - stack: &mut Stack, + state: &mut ParseState, pos: Position, + level: usize, allow_stmt_expr: bool, ) -> Result> { - let mut arr = Vec::new(); + if level > state.max_expr_depth { + return Err(PERR::ExprTooDeep.into_err(pos)); + } + + let mut arr = StaticVec::new(); if !match_token(input, Token::RightBracket)? { while !input.peek().unwrap().0.is_eof() { - arr.push(parse_expr(input, stack, allow_stmt_expr)?); + arr.push(parse_expr(input, state, level + 1, allow_stmt_expr)?); match input.peek().unwrap() { (Token::Comma, _) => eat_token(input, Token::Comma), @@ -1048,11 +1077,16 @@ fn parse_array_literal<'a>( /// Parse a map literal. fn parse_map_literal<'a>( input: &mut Peekable>, - stack: &mut Stack, + state: &mut ParseState, pos: Position, + level: usize, allow_stmt_expr: bool, ) -> Result> { - let mut map = Vec::new(); + if level > state.max_expr_depth { + return Err(PERR::ExprTooDeep.into_err(pos)); + } + + let mut map = StaticVec::new(); if !match_token(input, Token::RightBrace)? { while !input.peek().unwrap().0.is_eof() { @@ -1096,7 +1130,7 @@ fn parse_map_literal<'a>( } }; - let expr = parse_expr(input, stack, allow_stmt_expr)?; + let expr = parse_expr(input, state, level + 1, allow_stmt_expr)?; map.push(((name, pos), expr)); @@ -1145,17 +1179,24 @@ fn parse_map_literal<'a>( /// Parse a primary expression. fn parse_primary<'a>( input: &mut Peekable>, - stack: &mut Stack, + state: &mut ParseState, + level: usize, allow_stmt_expr: bool, ) -> Result> { - let (token, pos) = match input.peek().unwrap() { + let (token, pos) = input.peek().unwrap(); + let pos = *pos; + + if level > state.max_expr_depth { + return Err(PERR::ExprTooDeep.into_err(pos)); + } + + let (token, _) = match token { // { - block statement as expression - (Token::LeftBrace, pos) if allow_stmt_expr => { - let pos = *pos; - return parse_block(input, stack, false, allow_stmt_expr) + Token::LeftBrace if allow_stmt_expr => { + return parse_block(input, state, false, level + 1, allow_stmt_expr) .map(|block| Expr::Stmt(Box::new((block, pos)))); } - (Token::EOF, pos) => return Err(PERR::UnexpectedEOF.into_err(*pos)), + Token::EOF => return Err(PERR::UnexpectedEOF.into_err(pos)), _ => input.next().unwrap(), }; @@ -1166,14 +1207,14 @@ fn parse_primary<'a>( Token::CharConstant(c) => Expr::CharConstant(Box::new((c, pos))), Token::StringConst(s) => Expr::StringConstant(Box::new((s, pos))), Token::Identifier(s) => { - let index = stack.find(&s); + let index = state.find(&s); Expr::Variable(Box::new(((s, pos), None, 0, index))) } - Token::LeftParen => parse_paren_expr(input, stack, pos, allow_stmt_expr)?, + Token::LeftParen => parse_paren_expr(input, state, pos, level + 1, allow_stmt_expr)?, #[cfg(not(feature = "no_index"))] - Token::LeftBracket => parse_array_literal(input, stack, pos, allow_stmt_expr)?, + Token::LeftBracket => parse_array_literal(input, state, pos, level + 1, allow_stmt_expr)?, #[cfg(not(feature = "no_object"))] - Token::MapStart => parse_map_literal(input, stack, pos, allow_stmt_expr)?, + Token::MapStart => parse_map_literal(input, state, pos, level + 1, allow_stmt_expr)?, Token::True => Expr::True(pos), Token::False => Expr::False(pos), Token::LexError(err) => return Err(PERR::BadInput(err.to_string()).into_err(pos)), @@ -1196,12 +1237,9 @@ fn parse_primary<'a>( // Function call (Expr::Variable(x), Token::LeftParen) => { let ((name, pos), modules, _, _) = *x; - parse_call_expr(input, stack, name, modules, pos, allow_stmt_expr)? - } - (Expr::Property(x), Token::LeftParen) => { - let (name, pos) = *x; - parse_call_expr(input, stack, name, None, pos, allow_stmt_expr)? + parse_call_expr(input, state, name, modules, pos, level + 1, allow_stmt_expr)? } + (Expr::Property(_), _) => unreachable!(), // module access #[cfg(not(feature = "no_module"))] (Expr::Variable(x), Token::DoubleColon) => match input.next().unwrap() { @@ -1222,7 +1260,7 @@ fn parse_primary<'a>( // Indexing #[cfg(not(feature = "no_index"))] (expr, Token::LeftBracket) => { - parse_index_chain(input, stack, expr, token_pos, allow_stmt_expr)? + parse_index_chain(input, state, expr, token_pos, level + 1, allow_stmt_expr)? } // Unknown postfix operator (expr, token) => panic!("unknown postfix operator {:?} for {:?}", token, expr), @@ -1237,8 +1275,8 @@ fn parse_primary<'a>( let modules = modules.as_mut().unwrap(); // Qualifiers + variable name - *hash = calc_fn_hash(modules.iter().map(|(v, _)| v.as_str()), name, empty()); - modules.set_index(stack.find_module(&modules.get_ref(0).0)); + *hash = calc_fn_hash(modules.iter().map(|(v, _)| v.as_str()), name, 0, empty()); + modules.set_index(state.find_module(&modules.get(0).0)); } _ => (), } @@ -1249,23 +1287,28 @@ fn parse_primary<'a>( /// Parse a potential unary operator. fn parse_unary<'a>( input: &mut Peekable>, - stack: &mut Stack, + state: &mut ParseState, + level: usize, allow_stmt_expr: bool, ) -> Result> { - match input.peek().unwrap() { + let (token, pos) = input.peek().unwrap(); + let pos = *pos; + + if level > state.max_expr_depth { + return Err(PERR::ExprTooDeep.into_err(pos)); + } + + match token { // If statement is allowed to act as expressions - (Token::If, pos) => { - let pos = *pos; - Ok(Expr::Stmt(Box::new(( - parse_if(input, stack, false, allow_stmt_expr)?, - pos, - )))) - } + Token::If => Ok(Expr::Stmt(Box::new(( + parse_if(input, state, false, level + 1, allow_stmt_expr)?, + pos, + )))), // -expr - (Token::UnaryMinus, _) => { + Token::UnaryMinus => { let pos = eat_token(input, Token::UnaryMinus); - match parse_unary(input, stack, allow_stmt_expr)? { + match parse_unary(input, state, level + 1, allow_stmt_expr)? { // Negative integer Expr::IntegerConstant(x) => { let (num, pos) = *x; @@ -1295,50 +1338,53 @@ fn parse_unary<'a>( Expr::FloatConstant(x) => Ok(Expr::FloatConstant(Box::new((-x.0, x.1)))), // Call negative function - e => { + expr => { let op = "-"; - let hash = calc_fn_hash(empty(), op, repeat(EMPTY_TYPE_ID()).take(2)); + let hash = calc_fn_hash(empty(), op, 2, empty()); + let mut args = StaticVec::new(); + args.push(expr); Ok(Expr::FnCall(Box::new(( (op.into(), pos), None, hash, - vec![e], + args, None, )))) } } } // +expr - (Token::UnaryPlus, _) => { + Token::UnaryPlus => { eat_token(input, Token::UnaryPlus); - parse_unary(input, stack, allow_stmt_expr) + parse_unary(input, state, level + 1, allow_stmt_expr) } // !expr - (Token::Bang, _) => { + Token::Bang => { let pos = eat_token(input, Token::Bang); - let expr = vec![parse_primary(input, stack, allow_stmt_expr)?]; + let mut args = StaticVec::new(); + args.push(parse_primary(input, state, level + 1, allow_stmt_expr)?); let op = "!"; - let hash = calc_fn_hash(empty(), op, repeat(EMPTY_TYPE_ID()).take(2)); + let hash = calc_fn_hash(empty(), op, 2, empty()); Ok(Expr::FnCall(Box::new(( (op.into(), pos), None, hash, - expr, + args, Some(false.into()), // NOT operator, when operating on invalid operand, defaults to false )))) } // - (Token::EOF, pos) => Err(PERR::UnexpectedEOF.into_err(*pos)), + Token::EOF => Err(PERR::UnexpectedEOF.into_err(pos)), // All other tokens - _ => parse_primary(input, stack, allow_stmt_expr), + _ => parse_primary(input, state, level + 1, allow_stmt_expr), } } fn make_assignment_stmt<'a>( - stack: &mut Stack, + state: &mut ParseState, lhs: Expr, rhs: Expr, pos: Position, @@ -1347,7 +1393,7 @@ fn make_assignment_stmt<'a>( Expr::Variable(x) if x.3.is_none() => Ok(Expr::Assignment(Box::new((lhs, rhs, pos)))), Expr::Variable(x) => { let ((name, name_pos), _, _, index) = x.as_ref(); - match stack[(stack.len() - index.unwrap().get())].1 { + match state.stack[(state.len() - index.unwrap().get())].1 { ScopeEntryType::Normal => Ok(Expr::Assignment(Box::new((lhs, rhs, pos)))), // Constant values cannot be assigned to ScopeEntryType::Constant => { @@ -1360,7 +1406,7 @@ fn make_assignment_stmt<'a>( Expr::Variable(x) if x.3.is_none() => Ok(Expr::Assignment(Box::new((lhs, rhs, pos)))), Expr::Variable(x) => { let ((name, name_pos), _, _, index) = x.as_ref(); - match stack[(stack.len() - index.unwrap().get())].1 { + match state.stack[(state.len() - index.unwrap().get())].1 { ScopeEntryType::Normal => Ok(Expr::Assignment(Box::new((lhs, rhs, pos)))), // Constant values cannot be assigned to ScopeEntryType::Constant => { @@ -1381,40 +1427,53 @@ fn make_assignment_stmt<'a>( /// Parse an operator-assignment expression. fn parse_op_assignment_stmt<'a>( input: &mut Peekable>, - stack: &mut Stack, + state: &mut ParseState, lhs: Expr, + level: usize, allow_stmt_expr: bool, ) -> Result> { - let (op, pos) = match *input.peek().unwrap() { - (Token::Equals, _) => { + let (token, pos) = input.peek().unwrap(); + let pos = *pos; + + if level > state.max_expr_depth { + return Err(PERR::ExprTooDeep.into_err(pos)); + } + + let op = match token { + Token::Equals => { let pos = eat_token(input, Token::Equals); - let rhs = parse_expr(input, stack, allow_stmt_expr)?; - return make_assignment_stmt(stack, lhs, rhs, pos); + let rhs = parse_expr(input, state, level + 1, allow_stmt_expr)?; + return make_assignment_stmt(state, lhs, rhs, pos); } - (Token::PlusAssign, pos) => ("+", pos), - (Token::MinusAssign, pos) => ("-", pos), - (Token::MultiplyAssign, pos) => ("*", pos), - (Token::DivideAssign, pos) => ("/", pos), - (Token::LeftShiftAssign, pos) => ("<<", pos), - (Token::RightShiftAssign, pos) => (">>", pos), - (Token::ModuloAssign, pos) => ("%", pos), - (Token::PowerOfAssign, pos) => ("~", pos), - (Token::AndAssign, pos) => ("&", pos), - (Token::OrAssign, pos) => ("|", pos), - (Token::XOrAssign, pos) => ("^", pos), - (_, _) => return Ok(lhs), + Token::PlusAssign => Token::Plus.syntax(), + Token::MinusAssign => Token::Minus.syntax(), + Token::MultiplyAssign => Token::Multiply.syntax(), + Token::DivideAssign => Token::Divide.syntax(), + Token::LeftShiftAssign => Token::LeftShift.syntax(), + Token::RightShiftAssign => Token::RightShift.syntax(), + Token::ModuloAssign => Token::Modulo.syntax(), + Token::PowerOfAssign => Token::PowerOf.syntax(), + Token::AndAssign => Token::Ampersand.syntax(), + Token::OrAssign => Token::Pipe.syntax(), + Token::XOrAssign => Token::XOr.syntax(), + + _ => return Ok(lhs), }; input.next(); let lhs_copy = lhs.clone(); - let rhs = parse_expr(input, stack, allow_stmt_expr)?; + let rhs = parse_expr(input, state, level + 1, allow_stmt_expr)?; // lhs op= rhs -> lhs = op(lhs, rhs) - let args = vec![lhs_copy, rhs]; - let hash = calc_fn_hash(empty(), op, repeat(EMPTY_TYPE_ID()).take(args.len())); - let rhs_expr = Expr::FnCall(Box::new(((op.into(), pos), None, hash, args, None))); - make_assignment_stmt(stack, lhs, rhs_expr, pos) + let mut args = StaticVec::new(); + args.push(lhs_copy); + args.push(rhs); + + let hash = calc_fn_hash(empty(), &op, args.len(), empty()); + let rhs_expr = Expr::FnCall(Box::new(((op, pos), None, hash, args, None))); + + make_assignment_stmt(state, lhs, rhs_expr, pos) } /// Make a dot expression. @@ -1432,8 +1491,13 @@ fn make_dot_expr( } // lhs.id (lhs, Expr::Variable(x)) if x.1.is_none() => { + let (name, pos) = x.0; let lhs = if is_index { lhs.into_property() } else { lhs }; - let rhs = Expr::Property(Box::new(x.0)); + + let getter = make_getter(&name); + let setter = make_setter(&name); + let rhs = Expr::Property(Box::new(((name, getter, setter), pos))); + Expr::Dot(Box::new((lhs, rhs, op_pos))) } (lhs, Expr::Property(x)) => { @@ -1446,7 +1510,7 @@ fn make_dot_expr( #[cfg(feature = "no_module")] unreachable!(); #[cfg(not(feature = "no_module"))] - return Err(PERR::PropertyExpected.into_err(x.1.unwrap().get_ref(0).1)); + return Err(PERR::PropertyExpected.into_err(x.1.unwrap().get(0).1)); } // lhs.dot_lhs.dot_rhs (lhs, Expr::Dot(x)) => { @@ -1648,50 +1712,59 @@ fn make_in_expr(lhs: Expr, rhs: Expr, op_pos: Position) -> Result( input: &mut Peekable>, - stack: &mut Stack, + state: &mut ParseState, parent_precedence: u8, lhs: Expr, + mut level: usize, allow_stmt_expr: bool, ) -> Result> { - let mut current_lhs = lhs; + if level > state.max_expr_depth { + return Err(PERR::ExprTooDeep.into_err(lhs.position())); + } + + let mut root = lhs; loop { - let (current_precedence, bind_right) = input.peek().map_or_else( - || (0, false), - |(current_op, _)| (current_op.precedence(), current_op.is_bind_right()), - ); + let (current_op, _) = input.peek().unwrap(); + let precedence = current_op.precedence(); + let bind_right = current_op.is_bind_right(); // Bind left to the parent lhs expression if precedence is higher // If same precedence, then check if the operator binds right - if current_precedence < parent_precedence - || (current_precedence == parent_precedence && !bind_right) - { - return Ok(current_lhs); + if precedence < parent_precedence || (precedence == parent_precedence && !bind_right) { + return Ok(root); } let (op_token, pos) = input.next().unwrap(); - let rhs = parse_unary(input, stack, allow_stmt_expr)?; + let rhs = parse_unary(input, state, level, allow_stmt_expr)?; let next_precedence = input.peek().unwrap().0.precedence(); // Bind to right if the next operator has higher precedence // If same precedence, then check if the operator binds right - let rhs = if (current_precedence == next_precedence && bind_right) - || current_precedence < next_precedence - { - parse_binary_op(input, stack, current_precedence, rhs, allow_stmt_expr)? + let rhs = if (precedence == next_precedence && bind_right) || precedence < next_precedence { + parse_binary_op(input, state, precedence, rhs, level, allow_stmt_expr)? } else { // Otherwise bind to left (even if next operator has the same precedence) rhs }; + level += 1; + + if level > state.max_expr_depth { + return Err(PERR::ExprTooDeep.into_err(pos)); + } + let cmp_def = Some(false.into()); let op = op_token.syntax(); - let hash = calc_fn_hash(empty(), &op, repeat(EMPTY_TYPE_ID()).take(2)); - let mut args = vec![current_lhs, rhs]; + let hash = calc_fn_hash(empty(), &op, 2, empty()); - current_lhs = match op_token { + let mut args = StaticVec::new(); + args.push(root); + args.push(rhs); + + root = match op_token { Token::Plus => Expr::FnCall(Box::new(((op, pos), None, hash, args, None))), Token::Minus => Expr::FnCall(Box::new(((op, pos), None, hash, args, None))), Token::Multiply => Expr::FnCall(Box::new(((op, pos), None, hash, args, None))), @@ -1715,13 +1788,13 @@ fn parse_binary_op<'a>( } Token::Or => { - let rhs = args.pop().unwrap(); - let current_lhs = args.pop().unwrap(); + let rhs = args.pop(); + let current_lhs = args.pop(); Expr::Or(Box::new((current_lhs, rhs, pos))) } Token::And => { - let rhs = args.pop().unwrap(); - let current_lhs = args.pop().unwrap(); + let rhs = args.pop(); + let current_lhs = args.pop(); Expr::And(Box::new((current_lhs, rhs, pos))) } Token::Ampersand => Expr::FnCall(Box::new(((op, pos), None, hash, args, None))), @@ -1729,15 +1802,26 @@ fn parse_binary_op<'a>( Token::XOr => Expr::FnCall(Box::new(((op, pos), None, hash, args, None))), Token::In => { - let rhs = args.pop().unwrap(); - let current_lhs = args.pop().unwrap(); + let rhs = args.pop(); + let current_lhs = args.pop(); make_in_expr(current_lhs, rhs, pos)? } #[cfg(not(feature = "no_object"))] Token::Period => { - let rhs = args.pop().unwrap(); - let current_lhs = args.pop().unwrap(); + let mut rhs = args.pop(); + let current_lhs = args.pop(); + + match &mut rhs { + // current_lhs.rhs(...) - method call + Expr::FnCall(x) => { + let ((id, _), _, hash, args, _) = x.as_mut(); + // Recalculate function call hash because there is an additional argument + *hash = calc_fn_hash(empty(), id, args.len() + 1, empty()); + } + _ => (), + } + make_dot_expr(current_lhs, rhs, pos, false)? } @@ -1749,11 +1833,18 @@ fn parse_binary_op<'a>( /// Parse an expression. fn parse_expr<'a>( input: &mut Peekable>, - stack: &mut Stack, + state: &mut ParseState, + level: usize, allow_stmt_expr: bool, ) -> Result> { - let lhs = parse_unary(input, stack, allow_stmt_expr)?; - parse_binary_op(input, stack, 1, lhs, allow_stmt_expr) + let (_, pos) = input.peek().unwrap(); + + if level > state.max_expr_depth { + return Err(PERR::ExprTooDeep.into_err(*pos)); + } + + let lhs = parse_unary(input, state, level + 1, allow_stmt_expr)?; + parse_binary_op(input, state, 1, lhs, level + 1, allow_stmt_expr) } /// Make sure that the expression is not a statement expression (i.e. wrapped in `{}`). @@ -1803,27 +1894,32 @@ fn ensure_not_assignment<'a>( /// Parse an if statement. fn parse_if<'a>( input: &mut Peekable>, - stack: &mut Stack, + state: &mut ParseState, breakable: bool, + level: usize, allow_stmt_expr: bool, ) -> Result> { // if ... - eat_token(input, Token::If); + let pos = eat_token(input, Token::If); + + if level > state.max_expr_depth { + return Err(PERR::ExprTooDeep.into_err(pos)); + } // if guard { if_body } ensure_not_statement_expr(input, "a boolean")?; - let guard = parse_expr(input, stack, allow_stmt_expr)?; + let guard = parse_expr(input, state, level + 1, allow_stmt_expr)?; ensure_not_assignment(input)?; - let if_body = parse_block(input, stack, breakable, allow_stmt_expr)?; + let if_body = parse_block(input, state, breakable, level + 1, allow_stmt_expr)?; // if guard { if_body } else ... let else_body = if match_token(input, Token::Else).unwrap_or(false) { Some(if let (Token::If, _) = input.peek().unwrap() { // if guard { if_body } else if ... - parse_if(input, stack, breakable, allow_stmt_expr)? + parse_if(input, state, breakable, level + 1, allow_stmt_expr)? } else { // if guard { if_body } else { else-body } - parse_block(input, stack, breakable, allow_stmt_expr)? + parse_block(input, state, breakable, level + 1, allow_stmt_expr)? }) } else { None @@ -1835,17 +1931,22 @@ fn parse_if<'a>( /// Parse a while loop. fn parse_while<'a>( input: &mut Peekable>, - stack: &mut Stack, + state: &mut ParseState, + level: usize, allow_stmt_expr: bool, ) -> Result> { // while ... - eat_token(input, Token::While); + let pos = eat_token(input, Token::While); + + if level > state.max_expr_depth { + return Err(PERR::ExprTooDeep.into_err(pos)); + } // while guard { body } ensure_not_statement_expr(input, "a boolean")?; - let guard = parse_expr(input, stack, allow_stmt_expr)?; + let guard = parse_expr(input, state, level + 1, allow_stmt_expr)?; ensure_not_assignment(input)?; - let body = parse_block(input, stack, true, allow_stmt_expr)?; + let body = parse_block(input, state, true, level + 1, allow_stmt_expr)?; Ok(Stmt::While(Box::new((guard, body)))) } @@ -1853,14 +1954,19 @@ fn parse_while<'a>( /// Parse a loop statement. fn parse_loop<'a>( input: &mut Peekable>, - stack: &mut Stack, + state: &mut ParseState, + level: usize, allow_stmt_expr: bool, ) -> Result> { // loop ... - eat_token(input, Token::Loop); + let pos = eat_token(input, Token::Loop); + + if level > state.max_expr_depth { + return Err(PERR::ExprTooDeep.into_err(pos)); + } // loop { body } - let body = parse_block(input, stack, true, allow_stmt_expr)?; + let body = parse_block(input, state, true, level + 1, allow_stmt_expr)?; Ok(Stmt::Loop(Box::new(body))) } @@ -1868,11 +1974,16 @@ fn parse_loop<'a>( /// Parse a for loop. fn parse_for<'a>( input: &mut Peekable>, - stack: &mut Stack, + state: &mut ParseState, + level: usize, allow_stmt_expr: bool, ) -> Result> { // for ... - eat_token(input, Token::For); + let pos = eat_token(input, Token::For); + + if level > state.max_expr_depth { + return Err(PERR::ExprTooDeep.into_err(pos)); + } // for name ... let name = match input.next().unwrap() { @@ -1900,14 +2011,14 @@ fn parse_for<'a>( // for name in expr { body } ensure_not_statement_expr(input, "a boolean")?; - let expr = parse_expr(input, stack, allow_stmt_expr)?; + let expr = parse_expr(input, state, level + 1, allow_stmt_expr)?; - let prev_len = stack.len(); - stack.push((name.clone(), ScopeEntryType::Normal)); + let prev_len = state.len(); + state.push((name.clone(), ScopeEntryType::Normal)); - let body = parse_block(input, stack, true, allow_stmt_expr)?; + let body = parse_block(input, state, true, level + 1, allow_stmt_expr)?; - stack.truncate(prev_len); + state.truncate(prev_len); Ok(Stmt::For(Box::new((name, expr, body)))) } @@ -1915,12 +2026,17 @@ fn parse_for<'a>( /// Parse a variable definition statement. fn parse_let<'a>( input: &mut Peekable>, - stack: &mut Stack, + state: &mut ParseState, var_type: ScopeEntryType, + level: usize, allow_stmt_expr: bool, ) -> Result> { // let/const... (specified in `var_type`) - input.next(); + let (_, pos) = input.next().unwrap(); + + if level > state.max_expr_depth { + return Err(PERR::ExprTooDeep.into_err(pos)); + } // let name ... let (name, pos) = match input.next().unwrap() { @@ -1932,17 +2048,17 @@ fn parse_let<'a>( // let name = ... if match_token(input, Token::Equals)? { // let name = expr - let init_value = parse_expr(input, stack, allow_stmt_expr)?; + let init_value = parse_expr(input, state, level + 1, allow_stmt_expr)?; match var_type { // let name = expr ScopeEntryType::Normal => { - stack.push((name.clone(), ScopeEntryType::Normal)); + state.push((name.clone(), ScopeEntryType::Normal)); Ok(Stmt::Let(Box::new(((name, pos), Some(init_value))))) } // const name = { expr:constant } ScopeEntryType::Constant if init_value.is_constant() => { - stack.push((name.clone(), ScopeEntryType::Constant)); + state.push((name.clone(), ScopeEntryType::Constant)); Ok(Stmt::Const(Box::new(((name, pos), init_value)))) } // const name = expr - error @@ -1956,11 +2072,11 @@ fn parse_let<'a>( // let name match var_type { ScopeEntryType::Normal => { - stack.push((name.clone(), ScopeEntryType::Normal)); + state.push((name.clone(), ScopeEntryType::Normal)); Ok(Stmt::Let(Box::new(((name, pos), None)))) } ScopeEntryType::Constant => { - stack.push((name.clone(), ScopeEntryType::Constant)); + state.push((name.clone(), ScopeEntryType::Constant)); Ok(Stmt::Const(Box::new(((name, pos), Expr::Unit(pos))))) } // Variable cannot be a module @@ -1972,14 +2088,19 @@ fn parse_let<'a>( /// Parse an import statement. fn parse_import<'a>( input: &mut Peekable>, - stack: &mut Stack, + state: &mut ParseState, + level: usize, allow_stmt_expr: bool, ) -> Result> { // import ... let pos = eat_token(input, Token::Import); + if level > state.max_expr_depth { + return Err(PERR::ExprTooDeep.into_err(pos)); + } + // import expr ... - let expr = parse_expr(input, stack, allow_stmt_expr)?; + let expr = parse_expr(input, state, level + 1, allow_stmt_expr)?; // import expr as ... match input.next().unwrap() { @@ -1999,15 +2120,23 @@ fn parse_import<'a>( (_, pos) => return Err(PERR::VariableExpected.into_err(pos)), }; - stack.push((name.clone(), ScopeEntryType::Module)); + state.push((name.clone(), ScopeEntryType::Module)); Ok(Stmt::Import(Box::new((expr, (name, pos))))) } /// Parse an export statement. -fn parse_export<'a>(input: &mut Peekable>) -> Result> { - eat_token(input, Token::Export); +fn parse_export<'a>( + input: &mut Peekable>, + state: &mut ParseState, + level: usize, +) -> Result> { + let pos = eat_token(input, Token::Export); - let mut exports = Vec::new(); + if level > state.max_expr_depth { + return Err(PERR::ExprTooDeep.into_err(pos)); + } + + let mut exports = StaticVec::new(); loop { let (id, id_pos) = match input.next().unwrap() { @@ -2063,8 +2192,9 @@ fn parse_export<'a>(input: &mut Peekable>) -> Result( input: &mut Peekable>, - stack: &mut Stack, + state: &mut ParseState, breakable: bool, + level: usize, allow_stmt_expr: bool, ) -> Result> { // Must start with { @@ -2080,12 +2210,16 @@ fn parse_block<'a>( } }; - let mut statements = Vec::new(); - let prev_len = stack.len(); + if level > state.max_expr_depth { + return Err(PERR::ExprTooDeep.into_err(pos)); + } + + let mut statements = StaticVec::new(); + let prev_len = state.len(); while !match_token(input, Token::RightBrace)? { // Parse statements inside the block - let stmt = parse_stmt(input, stack, breakable, false, allow_stmt_expr)?; + let stmt = parse_stmt(input, state, breakable, false, level + 1, allow_stmt_expr)?; // See if it needs a terminating semicolon let need_semicolon = !stmt.is_self_terminated(); @@ -2122,7 +2256,7 @@ fn parse_block<'a>( } } - stack.truncate(prev_len); + state.truncate(prev_len); Ok(Stmt::Block(Box::new((statements, pos)))) } @@ -2130,41 +2264,55 @@ fn parse_block<'a>( /// Parse an expression as a statement. fn parse_expr_stmt<'a>( input: &mut Peekable>, - stack: &mut Stack, + state: &mut ParseState, + level: usize, allow_stmt_expr: bool, ) -> Result> { - let expr = parse_expr(input, stack, allow_stmt_expr)?; - let expr = parse_op_assignment_stmt(input, stack, expr, allow_stmt_expr)?; + let (_, pos) = input.peek().unwrap(); + + if level > state.max_expr_depth { + return Err(PERR::ExprTooDeep.into_err(*pos)); + } + + let expr = parse_expr(input, state, level + 1, allow_stmt_expr)?; + let expr = parse_op_assignment_stmt(input, state, expr, level + 1, allow_stmt_expr)?; Ok(Stmt::Expr(Box::new(expr))) } /// Parse a single statement. fn parse_stmt<'a>( input: &mut Peekable>, - stack: &mut Stack, + state: &mut ParseState, breakable: bool, is_global: bool, + level: usize, allow_stmt_expr: bool, ) -> Result> { + use ScopeEntryType::{Constant, Normal}; + let (token, pos) = match input.peek().unwrap() { (Token::EOF, pos) => return Ok(Stmt::Noop(*pos)), x => x, }; + if level > state.max_expr_depth { + return Err(PERR::ExprTooDeep.into_err(*pos)); + } + match token { // Semicolon - empty statement Token::SemiColon => Ok(Stmt::Noop(*pos)), - Token::LeftBrace => parse_block(input, stack, breakable, allow_stmt_expr), + Token::LeftBrace => parse_block(input, state, breakable, level + 1, allow_stmt_expr), // fn ... Token::Fn if !is_global => Err(PERR::WrongFnDefinition.into_err(*pos)), Token::Fn => unreachable!(), - Token::If => parse_if(input, stack, breakable, allow_stmt_expr), - Token::While => parse_while(input, stack, allow_stmt_expr), - Token::Loop => parse_loop(input, stack, allow_stmt_expr), - Token::For => parse_for(input, stack, allow_stmt_expr), + Token::If => parse_if(input, state, breakable, level + 1, allow_stmt_expr), + Token::While => parse_while(input, state, level + 1, allow_stmt_expr), + Token::Loop => parse_loop(input, state, level + 1, allow_stmt_expr), + Token::For => parse_for(input, state, level + 1, allow_stmt_expr), Token::Continue if breakable => { let pos = eat_token(input, Token::Continue); @@ -2194,7 +2342,7 @@ fn parse_stmt<'a>( } // `return` or `throw` with expression (_, _) => { - let expr = parse_expr(input, stack, allow_stmt_expr)?; + let expr = parse_expr(input, state, level + 1, allow_stmt_expr)?; let pos = expr.position(); Ok(Stmt::ReturnWithVal(Box::new(( @@ -2205,31 +2353,36 @@ fn parse_stmt<'a>( } } - Token::Let => parse_let(input, stack, ScopeEntryType::Normal, allow_stmt_expr), - Token::Const => parse_let(input, stack, ScopeEntryType::Constant, allow_stmt_expr), + Token::Let => parse_let(input, state, Normal, level + 1, allow_stmt_expr), + Token::Const => parse_let(input, state, Constant, level + 1, allow_stmt_expr), #[cfg(not(feature = "no_module"))] - Token::Import => parse_import(input, stack, allow_stmt_expr), + Token::Import => parse_import(input, state, level + 1, allow_stmt_expr), #[cfg(not(feature = "no_module"))] Token::Export if !is_global => Err(PERR::WrongExport.into_err(*pos)), #[cfg(not(feature = "no_module"))] - Token::Export => parse_export(input), + Token::Export => parse_export(input, state, level + 1), - _ => parse_expr_stmt(input, stack, allow_stmt_expr), + _ => parse_expr_stmt(input, state, level + 1, allow_stmt_expr), } } /// Parse a function definition. fn parse_fn<'a>( input: &mut Peekable>, - stack: &mut Stack, + state: &mut ParseState, access: FnAccess, + level: usize, allow_stmt_expr: bool, ) -> Result> { let pos = eat_token(input, Token::Fn); + if level > state.max_expr_depth { + return Err(PERR::ExprTooDeep.into_err(pos)); + } + let name = match input.next().unwrap() { (Token::Identifier(s), _) => s, (_, pos) => return Err(PERR::FnMissingName.into_err(pos)), @@ -2249,7 +2402,7 @@ fn parse_fn<'a>( loop { match input.next().unwrap() { (Token::Identifier(s), pos) => { - stack.push((s.clone(), ScopeEntryType::Normal)); + state.push((s.clone(), ScopeEntryType::Normal)); params.push((s, pos)) } (Token::LexError(err), pos) => { @@ -2293,7 +2446,7 @@ fn parse_fn<'a>( // Parse function body let body = match input.peek().unwrap() { - (Token::LeftBrace, _) => parse_block(input, stack, false, allow_stmt_expr)?, + (Token::LeftBrace, _) => parse_block(input, state, false, level + 1, allow_stmt_expr)?, (_, pos) => return Err(PERR::FnMissingBody(name).into_err(*pos)), }; @@ -2313,9 +2466,10 @@ pub fn parse_global_expr<'a>( engine: &Engine, scope: &Scope, optimization_level: OptimizationLevel, + max_expr_depth: usize, ) -> Result> { - let mut stack = Stack::new(); - let expr = parse_expr(input, &mut stack, false)?; + let mut state = ParseState::new(max_expr_depth); + let expr = parse_expr(input, &mut state, 0, false)?; match input.peek().unwrap() { (Token::EOF, _) => (), @@ -2340,10 +2494,11 @@ pub fn parse_global_expr<'a>( /// Parse the global level statements. fn parse_global_level<'a>( input: &mut Peekable>, + max_expr_depth: (usize, usize), ) -> Result<(Vec, HashMap), Box> { let mut statements = Vec::::new(); let mut functions = HashMap::::new(); - let mut stack = Stack::new(); + let mut state = ParseState::new(max_expr_depth.0); while !input.peek().unwrap().0.is_eof() { // Collect all the function definitions @@ -2359,15 +2514,11 @@ fn parse_global_level<'a>( match input.peek().unwrap() { (Token::Fn, _) => { - let mut stack = Stack::new(); - let func = parse_fn(input, &mut stack, access, true)?; + let mut state = ParseState::new(max_expr_depth.1); + let func = parse_fn(input, &mut state, access, 0, true)?; - // Qualifiers (none) + function name + argument `TypeId`'s - let hash = calc_fn_hash( - empty(), - &func.name, - repeat(EMPTY_TYPE_ID()).take(func.params.len()), - ); + // Qualifiers (none) + function name + number of arguments. + let hash = calc_fn_hash(empty(), &func.name, func.params.len(), empty()); functions.insert(hash, func); continue; @@ -2383,7 +2534,7 @@ fn parse_global_level<'a>( } } // Actual statement - let stmt = parse_stmt(input, &mut stack, false, true, true)?; + let stmt = parse_stmt(input, &mut state, false, true, 0, true)?; let need_semicolon = !stmt.is_self_terminated(); @@ -2425,8 +2576,9 @@ pub fn parse<'a>( engine: &Engine, scope: &Scope, optimization_level: OptimizationLevel, + max_expr_depth: (usize, usize), ) -> Result> { - let (statements, functions) = parse_global_level(input)?; + let (statements, functions) = parse_global_level(input, max_expr_depth)?; let fn_lib = functions.into_iter().map(|(_, v)| v).collect(); Ok( diff --git a/src/result.rs b/src/result.rs index 5e38f8d9..af55535a 100644 --- a/src/result.rs +++ b/src/result.rs @@ -33,10 +33,9 @@ pub enum EvalAltResult { /// Call to an unknown function. Wrapped value is the name of the function. ErrorFunctionNotFound(String, Position), - /// Function call has incorrect number of arguments. - /// Wrapped values are the name of the function, the number of parameters required - /// and the actual number of arguments passed. - ErrorFunctionArgsMismatch(String, usize, usize, Position), + /// An error has occurred inside a called function. + /// Wrapped values re the name of the function and the interior error. + ErrorInFunctionCall(String, Box, Position), /// Non-boolean operand encountered for boolean operator. Wrapped value is the operator. ErrorBooleanArgMismatch(String, Position), /// Non-character value encountered where a character is required. @@ -76,8 +75,14 @@ pub enum EvalAltResult { ErrorDotExpr(String, Position), /// Arithmetic error encountered. Wrapped value is the error message. ErrorArithmetic(String, Position), + /// Number of operations over maximum limit. + ErrorTooManyOperations(Position), + /// Modules over maximum limit. + ErrorTooManyModules(Position), /// Call stack over maximum limit. ErrorStackOverflow(Position), + /// The script is prematurely terminated. + ErrorTerminated(Position), /// Run-time error encountered. Wrapped value is the error message. ErrorRuntime(String, Position), @@ -97,10 +102,8 @@ impl EvalAltResult { Self::ErrorReadingScriptFile(_, _, _) => "Cannot read from script file", Self::ErrorParsing(p) => p.desc(), + Self::ErrorInFunctionCall(_, _, _) => "Error in called function", Self::ErrorFunctionNotFound(_, _) => "Function not found", - Self::ErrorFunctionArgsMismatch(_, _, _, _) => { - "Function call with wrong number of arguments" - } Self::ErrorBooleanArgMismatch(_, _) => "Boolean operator expects boolean operands", Self::ErrorCharMismatch(_) => "Character expected", Self::ErrorNumericIndexExpr(_) => { @@ -133,7 +136,10 @@ impl EvalAltResult { Self::ErrorInExpr(_) => "Malformed 'in' expression", Self::ErrorDotExpr(_, _) => "Malformed dot expression", Self::ErrorArithmetic(_, _) => "Arithmetic error", + Self::ErrorTooManyOperations(_) => "Too many operations", + Self::ErrorTooManyModules(_) => "Too many modules imported", Self::ErrorStackOverflow(_) => "Stack overflow", + Self::ErrorTerminated(_) => "Script terminated.", Self::ErrorRuntime(_, _) => "Runtime error", Self::ErrorLoopBreak(true, _) => "Break statement not inside a loop", Self::ErrorLoopBreak(false, _) => "Continue statement not inside a loop", @@ -160,6 +166,10 @@ impl fmt::Display for EvalAltResult { Self::ErrorParsing(p) => write!(f, "Syntax error: {}", p), + Self::ErrorInFunctionCall(s, err, pos) => { + write!(f, "Error in call to function '{}' ({}): {}", s, pos, err) + } + Self::ErrorFunctionNotFound(s, pos) | Self::ErrorVariableNotFound(s, pos) | Self::ErrorModuleNotFound(s, pos) => write!(f, "{}: '{}' ({})", desc, s, pos), @@ -175,7 +185,10 @@ impl fmt::Display for EvalAltResult { | Self::ErrorAssignmentToUnknownLHS(pos) | Self::ErrorInExpr(pos) | Self::ErrorDotExpr(_, pos) - | Self::ErrorStackOverflow(pos) => write!(f, "{} ({})", desc, pos), + | Self::ErrorTooManyOperations(pos) + | Self::ErrorTooManyModules(pos) + | Self::ErrorStackOverflow(pos) + | Self::ErrorTerminated(pos) => write!(f, "{} ({})", desc, pos), Self::ErrorRuntime(s, pos) => { write!(f, "{} ({})", if s.is_empty() { desc } else { s }, pos) @@ -188,21 +201,6 @@ impl fmt::Display for EvalAltResult { Self::ErrorLoopBreak(_, pos) => write!(f, "{} ({})", desc, pos), Self::Return(_, pos) => write!(f, "{} ({})", desc, pos), - Self::ErrorFunctionArgsMismatch(fn_name, 0, n, pos) => write!( - f, - "Function '{}' expects no argument but {} found ({})", - fn_name, n, pos - ), - Self::ErrorFunctionArgsMismatch(fn_name, 1, n, pos) => write!( - f, - "Function '{}' expects one argument but {} found ({})", - fn_name, n, pos - ), - Self::ErrorFunctionArgsMismatch(fn_name, need, n, pos) => write!( - f, - "Function '{}' expects {} argument(s) but {} found ({})", - fn_name, need, n, pos - ), Self::ErrorBooleanArgMismatch(op, pos) => { write!(f, "{} operator expects boolean operands ({})", op, pos) } @@ -262,6 +260,7 @@ impl> From for Box { } impl EvalAltResult { + /// Get the `Position` of this error. pub fn position(&self) -> Position { match self { #[cfg(not(feature = "no_std"))] @@ -270,7 +269,7 @@ impl EvalAltResult { Self::ErrorParsing(err) => err.position(), Self::ErrorFunctionNotFound(_, pos) - | Self::ErrorFunctionArgsMismatch(_, _, _, pos) + | Self::ErrorInFunctionCall(_, _, pos) | Self::ErrorBooleanArgMismatch(_, pos) | Self::ErrorCharMismatch(pos) | Self::ErrorArrayBounds(_, _, pos) @@ -289,24 +288,26 @@ impl EvalAltResult { | Self::ErrorInExpr(pos) | Self::ErrorDotExpr(_, pos) | Self::ErrorArithmetic(_, pos) + | Self::ErrorTooManyOperations(pos) + | Self::ErrorTooManyModules(pos) | Self::ErrorStackOverflow(pos) + | Self::ErrorTerminated(pos) | Self::ErrorRuntime(_, pos) | Self::ErrorLoopBreak(_, pos) | Self::Return(_, pos) => *pos, } } - /// Consume the current `EvalAltResult` and return a new one - /// with the specified `Position`. - pub(crate) fn set_position(mut err: Box, new_position: Position) -> Box { - match err.as_mut() { + /// Override the `Position` of this error. + pub fn set_position(&mut self, new_position: Position) { + match self { #[cfg(not(feature = "no_std"))] Self::ErrorReadingScriptFile(_, pos, _) => *pos = new_position, Self::ErrorParsing(err) => err.1 = new_position, Self::ErrorFunctionNotFound(_, pos) - | Self::ErrorFunctionArgsMismatch(_, _, _, pos) + | Self::ErrorInFunctionCall(_, _, pos) | Self::ErrorBooleanArgMismatch(_, pos) | Self::ErrorCharMismatch(pos) | Self::ErrorArrayBounds(_, _, pos) @@ -325,12 +326,20 @@ impl EvalAltResult { | Self::ErrorInExpr(pos) | Self::ErrorDotExpr(_, pos) | Self::ErrorArithmetic(_, pos) + | Self::ErrorTooManyOperations(pos) + | Self::ErrorTooManyModules(pos) | Self::ErrorStackOverflow(pos) + | Self::ErrorTerminated(pos) | Self::ErrorRuntime(_, pos) | Self::ErrorLoopBreak(_, pos) | Self::Return(_, pos) => *pos = new_position, } + } - err + /// Consume the current `EvalAltResult` and return a new one + /// with the specified `Position`. + pub(crate) fn new_position(mut self: Box, new_position: Position) -> Box { + self.set_position(new_position); + self } } diff --git a/src/scope.rs b/src/scope.rs index 9f47b446..1b9c8b1d 100644 --- a/src/scope.rs +++ b/src/scope.rs @@ -22,7 +22,7 @@ pub enum EntryType { } /// An entry in the Scope. -#[derive(Debug)] +#[derive(Debug, Clone)] pub struct Entry<'a> { /// Name of the entry. pub name: Cow<'a, str>, @@ -36,7 +36,7 @@ pub struct Entry<'a> { pub expr: Option>, } -/// A type containing information about the current scope. +/// Type containing information about the current scope. /// Useful for keeping state between `Engine` evaluation runs. /// /// # Example @@ -64,7 +64,7 @@ pub struct Entry<'a> { /// allowing for automatic _shadowing_. /// /// Currently, `Scope` is neither `Send` nor `Sync`. Turn on the `sync` feature to make it `Send + Sync`. -#[derive(Debug, Default)] +#[derive(Debug, Clone, Default)] pub struct Scope<'a>(Vec>); impl<'a> Scope<'a> { diff --git a/src/token.rs b/src/token.rs index 25d26ff7..97df2d54 100644 --- a/src/token.rs +++ b/src/token.rs @@ -2,6 +2,7 @@ use crate::error::LexError; use crate::parser::INT; +use crate::utils::StaticVec; #[cfg(not(feature = "no_float"))] use crate::parser::FLOAT; @@ -425,7 +426,7 @@ pub struct TokenIterator<'a> { /// Current position. pos: Position, /// The input character streams. - streams: Vec>>, + streams: StaticVec>>, } impl<'a> TokenIterator<'a> { diff --git a/src/unsafe.rs b/src/unsafe.rs new file mode 100644 index 00000000..46d91198 --- /dev/null +++ b/src/unsafe.rs @@ -0,0 +1,63 @@ +//! A module containing all unsafe code. + +use crate::any::Variant; +use crate::engine::State; + +use crate::stdlib::{ + any::{Any, TypeId}, + borrow::Cow, + boxed::Box, + mem, ptr, + string::ToString, +}; + +/// Cast a type into another type. +pub fn unsafe_try_cast(a: A) -> Option { + if TypeId::of::() == 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 + // running or value otherwise being used again. + unsafe { + let ret: B = ptr::read(&a as *const _ as *const B); + mem::forget(a); + Some(ret) + } + } else { + None + } +} + +/// Cast a Boxed type into another type. +pub fn unsafe_cast_box(item: Box) -> Result, Box> { + // Only allow casting to the exact same type + if TypeId::of::() == TypeId::of::() { + // SAFETY: just checked whether we are pointing to the correct type + unsafe { + let raw: *mut dyn Any = Box::into_raw(item as Box); + Ok(Box::from_raw(raw as *mut T)) + } + } else { + // Return the consumed item for chaining. + Err(item) + } +} + +/// A dangerous function that blindly casts a `&str` from one lifetime to a `Cow` of +/// another lifetime. This is mainly used to let us push a block-local variable into the +/// current `Scope` without cloning the variable name. Doing this is safe because all local +/// variables in the `Scope` are cleared out before existing the block. +/// +/// Force-casting a local variable's lifetime to the current `Scope`'s larger lifetime saves +/// on allocations and string cloning, thus avoids us having to maintain a chain of `Scope`'s. +pub fn unsafe_cast_var_name_to_lifetime<'s>(name: &str, state: &State) -> Cow<'s, str> { + // If not at global level, we can force-cast + if state.scope_level > 0 { + // WARNING - force-cast the variable name into the scope's lifetime to avoid cloning it + // this is safe because all local variables are cleared at the end of the block + unsafe { mem::transmute::<_, &'s str>(name) }.into() + } else { + // The variable is introduced at global (top) level and may persist after the script run. + // Therefore, clone the variable name. + name.to_string().into() + } +} diff --git a/src/utils.rs b/src/utils.rs index 7abe88ab..126f6809 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -1,6 +1,8 @@ //! Module containing various utility types and functions. -// -// TODO - remove unsafe code +//! +//! # Safety +//! +//! The `StaticVec` type has some `unsafe` blocks to handle conversions between `MaybeUninit` and regular types. use crate::stdlib::{ any::TypeId, @@ -8,6 +10,8 @@ use crate::stdlib::{ hash::{Hash, Hasher}, iter::FromIterator, mem, + mem::MaybeUninit, + ops::{Drop, Index, IndexMut}, vec::Vec, }; @@ -17,10 +21,6 @@ use crate::stdlib::collections::hash_map::DefaultHasher; #[cfg(feature = "no_std")] use ahash::AHasher; -pub fn EMPTY_TYPE_ID() -> TypeId { - TypeId::of::<()>() -} - /// Calculate a `u64` hash key from a module-qualified function name and parameter types. /// /// Module names are passed in via `&str` references from an iterator. @@ -32,6 +32,7 @@ pub fn EMPTY_TYPE_ID() -> TypeId { pub fn calc_fn_spec<'a>( modules: impl Iterator, fn_name: &str, + num: usize, params: impl Iterator, ) -> u64 { #[cfg(feature = "no_std")] @@ -42,38 +43,117 @@ pub fn calc_fn_spec<'a>( // We always skip the first module modules.skip(1).for_each(|m| m.hash(&mut s)); s.write(fn_name.as_bytes()); + s.write_usize(num); params.for_each(|t| t.hash(&mut s)); s.finish() } -/// A type to hold a number of values in static storage for speed, and any spill-overs in a `Vec`. +/// A type to hold a number of values in static storage for no-allocation, quick access. +/// If too many items are stored, it converts into using a `Vec`. /// /// This is essentially a knock-off of the [`staticvec`](https://crates.io/crates/staticvec) crate. /// This simplified implementation here is to avoid pulling in another crate. /// +/// # Implementation +/// +/// A `StaticVec` holds data in _either one_ of two storages: 1) a fixed-size array of `MAX_STATIC_VEC` +/// items, and 2) a dynamic `Vec`. At any time, either one of them (or both) must be empty, depending on the +/// total number of items. +/// +/// There is a `len` field containing the total number of items held by the `StaticVec`. +/// +/// The fixed-size array (`list`) is not initialized (i.e. initialized with `MaybeUninit::uninit()`). +/// +/// When `len <= MAX_STATIC_VEC`, all elements are stored in the fixed-size array. +/// Array slots `>= len` are `MaybeUninit::uninit()` while slots `< len` are considered actual data. +/// In this scenario, the `Vec` (`more`) is empty. +/// +/// As soon as we try to push a new item into the `StaticVec` that makes the total number exceed +/// `MAX_STATIC_VEC`, all the items in the fixed-sized array are taken out, replaced with +/// `MaybeUninit::uninit()` (via `mem::replace`) and pushed into the `Vec`. +/// Then the new item is added to the `Vec`. +/// +/// Therefore, if `len > MAX_STATIC_VEC`, then the fixed-size array (`list`) is considered +/// empty and uninitialized while all data resides in the `Vec` (`more`). +/// +/// When popping an item off of the `StaticVec`, the reverse is true. When `len = MAX_STATIC_VEC + 1`, +/// after popping the item, all the items residing in the `Vec` are moved back to the fixed-size array (`list`). +/// The `Vec` will then be empty. +/// +/// Therefore, if `len <= MAX_STATIC_VEC`, data is in the fixed-size array (`list`). +/// Otherwise, data is in the `Vec` (`more`). +/// /// # Safety /// -/// This type uses some unsafe code (mainly to zero out unused array slots) for efficiency. -#[derive(Clone, Hash)] +/// This type uses some unsafe code (mainly for uninitialized/unused array slots) for efficiency. +// +// TODO - remove unsafe code pub struct StaticVec { /// Total number of values held. len: usize, - /// Static storage. 4 slots should be enough for most cases - i.e. four levels of indirection. - list: [T; 4], + /// Fixed-size storage for fast, no-allocation access. + list: [MaybeUninit; MAX_STATIC_VEC], /// Dynamic storage. For spill-overs. more: Vec, } +/// Maximum slots of fixed-size storage for a `StaticVec`. +/// 4 slots should be enough for most cases. +const MAX_STATIC_VEC: usize = 4; + +impl Drop for StaticVec { + fn drop(&mut self) { + self.clear(); + } +} + impl Default for StaticVec { fn default() -> Self { Self { len: 0, - list: unsafe { mem::MaybeUninit::zeroed().assume_init() }, + list: unsafe { mem::MaybeUninit::uninit().assume_init() }, more: Vec::new(), } } } +impl PartialEq for StaticVec { + fn eq(&self, other: &Self) -> bool { + if self.len != other.len || self.more != other.more { + return false; + } + + if self.len > MAX_STATIC_VEC { + return true; + } + + unsafe { + mem::transmute::<_, &[T; MAX_STATIC_VEC]>(&self.list) + == mem::transmute::<_, &[T; MAX_STATIC_VEC]>(&other.list) + } + } +} + +impl Clone for StaticVec { + fn clone(&self) -> Self { + let mut value: Self = Default::default(); + value.len = self.len; + + if self.is_fixed_storage() { + for x in 0..self.len { + let item: &T = unsafe { mem::transmute(self.list.get(x).unwrap()) }; + value.list[x] = MaybeUninit::new(item.clone()); + } + } else { + value.more = self.more.clone(); + } + + value + } +} + +impl Eq for StaticVec {} + impl FromIterator for StaticVec { fn from_iter>(iter: X) -> Self { let mut vec = StaticVec::new(); @@ -91,20 +171,116 @@ impl StaticVec { pub fn new() -> Self { Default::default() } + /// Empty the `StaticVec`. + pub fn clear(&mut self) { + if self.is_fixed_storage() { + for x in 0..self.len { + self.extract_from_list(x); + } + } else { + self.more.clear(); + } + self.len = 0; + } + /// Extract a `MaybeUninit` into a concrete initialized type. + fn extract(value: MaybeUninit) -> T { + unsafe { value.assume_init() } + } + /// Extract an item from the fixed-size array, replacing it with `MaybeUninit::uninit()`. + /// + /// # Panics + /// + /// Panics if fixed-size storage is not used, or if the `index` is out of bounds. + fn extract_from_list(&mut self, index: usize) -> T { + if !self.is_fixed_storage() { + panic!("not fixed storage in StaticVec"); + } + if index >= self.len { + panic!("index OOB in StaticVec"); + } + Self::extract(mem::replace( + self.list.get_mut(index).unwrap(), + MaybeUninit::uninit(), + )) + } + /// Set an item into the fixed-size array. + /// If `drop` is `true`, the original value is extracted then automatically dropped. + /// + /// # Panics + /// + /// Panics if fixed-size storage is not used, or if the `index` is out of bounds. + fn set_into_list(&mut self, index: usize, value: T, drop: bool) { + if !self.is_fixed_storage() { + panic!("not fixed storage in StaticVec"); + } + // Allow setting at most one slot to the right + if index > self.len { + panic!("index OOB in StaticVec"); + } + let temp = mem::replace(self.list.get_mut(index).unwrap(), MaybeUninit::new(value)); + if drop { + // Extract the original value - which will drop it automatically + Self::extract(temp); + } + } + /// Move item in the fixed-size array into the `Vec`. + /// + /// # Panics + /// + /// Panics if fixed-size storage is not used, or if the fixed-size storage is not full. + fn move_fixed_into_vec(&mut self, num: usize) { + if !self.is_fixed_storage() { + panic!("not fixed storage in StaticVec"); + } + if self.len != num { + panic!("fixed storage is not full in StaticVec"); + } + self.more.extend( + self.list + .iter_mut() + .take(num) + .map(|v| mem::replace(v, MaybeUninit::uninit())) + .map(Self::extract), + ); + } + /// Is data stored in fixed-size storage? + fn is_fixed_storage(&self) -> bool { + self.len <= MAX_STATIC_VEC + } /// Push a new value to the end of this `StaticVec`. pub fn push>(&mut self, value: X) { - if self.len == self.list.len() { - // Move the fixed list to the Vec - for x in 0..self.list.len() { - let def_val: T = unsafe { mem::MaybeUninit::zeroed().assume_init() }; - self.more - .push(mem::replace(self.list.get_mut(x).unwrap(), def_val)); - } - self.more.push(value.into()); - } else if self.len > self.list.len() { + if self.len == MAX_STATIC_VEC { + self.move_fixed_into_vec(MAX_STATIC_VEC); self.more.push(value.into()); + } else if self.is_fixed_storage() { + self.set_into_list(self.len, value.into(), false); } else { - self.list[self.len] = value.into(); + self.more.push(value.into()); + } + self.len += 1; + } + /// Insert a new value to this `StaticVec` at a particular position. + /// + /// # Panics + /// + /// Panics if `index` is out of bounds. + pub fn insert>(&mut self, index: usize, value: X) { + if index > self.len { + panic!("index OOB in StaticVec"); + } + + if self.len == MAX_STATIC_VEC { + self.move_fixed_into_vec(MAX_STATIC_VEC); + self.more.insert(index, value.into()); + } else if self.is_fixed_storage() { + // Move all items one slot to the right + for x in (index..self.len).rev() { + let orig_value = self.extract_from_list(x); + self.set_into_list(x + 1, orig_value, false); + } + self.set_into_list(index, value.into(), false); + } else { + self.more.insert(index, value.into()); } self.len += 1; } @@ -114,22 +290,62 @@ impl StaticVec { /// /// Panics if the `StaticVec` is empty. pub fn pop(&mut self) -> T { - let result = if self.len <= 0 { - panic!("nothing to pop!") - } else if self.len <= self.list.len() { - let def_val: T = unsafe { mem::MaybeUninit::zeroed().assume_init() }; - mem::replace(self.list.get_mut(self.len - 1).unwrap(), def_val) + if self.is_empty() { + panic!("nothing to pop!"); + } + + let result = if self.is_fixed_storage() { + self.extract_from_list(self.len - 1) } else { - let r = self.more.pop().unwrap(); + let value = self.more.pop().unwrap(); // Move back to the fixed list - if self.more.len() == self.list.len() { - for x in 0..self.list.len() { - self.list[self.list.len() - 1 - x] = self.more.pop().unwrap(); + if self.more.len() == MAX_STATIC_VEC { + for index in (0..MAX_STATIC_VEC).rev() { + let item = self.more.pop().unwrap(); + self.set_into_list(index, item, false); } } - r + value + }; + + self.len -= 1; + + result + } + /// Remove a value from this `StaticVec` at a particular position. + /// + /// # Panics + /// + /// Panics if `index` is out of bounds. + pub fn remove(&mut self, index: usize) -> T { + if index >= self.len { + panic!("index OOB in StaticVec"); + } + + let result = if self.is_fixed_storage() { + let value = self.extract_from_list(index); + + // Move all items one slot to the left + for x in index..self.len - 1 { + let orig_value = self.extract_from_list(x + 1); + self.set_into_list(x, orig_value, false); + } + + value + } else { + let value = self.more.remove(index); + + // Move back to the fixed list + if self.more.len() == MAX_STATIC_VEC { + for index in (0..MAX_STATIC_VEC).rev() { + let item = self.more.pop().unwrap(); + self.set_into_list(index, item, false); + } + } + + value }; self.len -= 1; @@ -140,18 +356,24 @@ impl StaticVec { pub fn len(&self) -> usize { self.len } + /// Is this `StaticVec` empty? + pub fn is_empty(&self) -> bool { + self.len == 0 + } /// Get a reference to the item at a particular index. /// /// # Panics /// - /// Panics if the index is out of bounds. - pub fn get_ref(&self, index: usize) -> &T { + /// Panics if `index` is out of bounds. + pub fn get(&self, index: usize) -> &T { if index >= self.len { panic!("index OOB in StaticVec"); } - if self.len < self.list.len() { - self.list.get(index).unwrap() + let list: &[T; MAX_STATIC_VEC] = unsafe { mem::transmute(&self.list) }; + + if self.is_fixed_storage() { + list.get(index).unwrap() } else { self.more.get(index).unwrap() } @@ -160,52 +382,106 @@ impl StaticVec { /// /// # Panics /// - /// Panics if the index is out of bounds. + /// Panics if `index` is out of bounds. pub fn get_mut(&mut self, index: usize) -> &mut T { if index >= self.len { panic!("index OOB in StaticVec"); } - if self.len < self.list.len() { - self.list.get_mut(index).unwrap() + let list: &mut [T; MAX_STATIC_VEC] = unsafe { mem::transmute(&mut self.list) }; + + if self.is_fixed_storage() { + list.get_mut(index).unwrap() } else { self.more.get_mut(index).unwrap() } } /// Get an iterator to entries in the `StaticVec`. pub fn iter(&self) -> impl Iterator { - if self.len > self.list.len() { - self.more.iter() + let list: &[T; MAX_STATIC_VEC] = unsafe { mem::transmute(&self.list) }; + + if self.is_fixed_storage() { + list[..self.len].iter() } else { - self.list[..self.len].iter() + self.more.iter() } } /// Get a mutable iterator to entries in the `StaticVec`. pub fn iter_mut(&mut self) -> impl Iterator { - if self.len > self.list.len() { - self.more.iter_mut() + let list: &mut [T; MAX_STATIC_VEC] = unsafe { mem::transmute(&mut self.list) }; + + if self.is_fixed_storage() { + list[..self.len].iter_mut() } else { - self.list[..self.len].iter_mut() + self.more.iter_mut() } } } -impl StaticVec { - /// Get the item at a particular index. +impl StaticVec { + /// Get a mutable iterator to entries in the `StaticVec`. + pub fn into_iter(mut self) -> Box> { + if self.is_fixed_storage() { + let mut it = FixedStorageIterator { + data: unsafe { mem::MaybeUninit::uninit().assume_init() }, + index: 0, + limit: self.len, + }; + + for x in 0..self.len { + it.data[x] = mem::replace(self.list.get_mut(x).unwrap(), MaybeUninit::uninit()); + } + self.len = 0; + + Box::new(it) + } else { + Box::new(Vec::from(self).into_iter()) + } + } +} + +/// An iterator that takes control of the fixed-size storage of a `StaticVec` and returns its values. +struct FixedStorageIterator { + data: [MaybeUninit; MAX_STATIC_VEC], + index: usize, + limit: usize, +} + +impl Iterator for FixedStorageIterator { + type Item = T; + + fn next(&mut self) -> Option { + if self.index >= self.limit { + None + } else { + self.index += 1; + + let value = mem::replace( + self.data.get_mut(self.index - 1).unwrap(), + MaybeUninit::uninit(), + ); + + unsafe { Some(value.assume_init()) } + } + } +} + +impl StaticVec { + /// Get the item at a particular index, replacing it with the default. /// /// # Panics /// - /// Panics if the index is out of bounds. - pub fn get(&self, index: usize) -> T { + /// Panics if `index` is out of bounds. + pub fn take(&mut self, index: usize) -> T { if index >= self.len { panic!("index OOB in StaticVec"); } - if self.len < self.list.len() { - *self.list.get(index).unwrap() + mem::take(if self.is_fixed_storage() { + unsafe { mem::transmute(self.list.get_mut(index).unwrap()) } } else { - *self.more.get(index).unwrap() - } + self.more.get_mut(index).unwrap() + }) } } @@ -219,20 +495,68 @@ impl fmt::Debug for StaticVec { impl AsRef<[T]> for StaticVec { fn as_ref(&self) -> &[T] { - if self.len > self.list.len() { - &self.more[..] + let list: &[T; MAX_STATIC_VEC] = unsafe { mem::transmute(&self.list) }; + + if self.is_fixed_storage() { + &list[..self.len] } else { - &self.list[..self.len] + &self.more[..] } } } impl AsMut<[T]> for StaticVec { fn as_mut(&mut self) -> &mut [T] { - if self.len > self.list.len() { - &mut self.more[..] + let list: &mut [T; MAX_STATIC_VEC] = unsafe { mem::transmute(&mut self.list) }; + + if self.is_fixed_storage() { + &mut list[..self.len] } else { - &mut self.list[..self.len] + &mut self.more[..] } } } + +impl Index for StaticVec { + type Output = T; + + fn index(&self, index: usize) -> &Self::Output { + self.get(index) + } +} + +impl IndexMut for StaticVec { + fn index_mut(&mut self, index: usize) -> &mut Self::Output { + self.get_mut(index) + } +} + +impl From> for Vec { + fn from(mut value: StaticVec) -> Self { + if value.len <= MAX_STATIC_VEC { + value.move_fixed_into_vec(value.len); + } + value.len = 0; + + let mut arr = Self::new(); + arr.append(&mut value.more); + arr + } +} + +impl From> for StaticVec { + fn from(mut value: Vec) -> Self { + let mut arr: Self = Default::default(); + arr.len = value.len(); + + if arr.len <= MAX_STATIC_VEC { + for x in (0..arr.len).rev() { + arr.set_into_list(x, value.pop().unwrap(), false); + } + } else { + arr.more = value; + } + + arr + } +} diff --git a/tests/call_fn.rs b/tests/call_fn.rs index f3d2a689..e3c61765 100644 --- a/tests/call_fn.rs +++ b/tests/call_fn.rs @@ -41,13 +41,13 @@ fn test_call_fn() -> Result<(), Box> { ", )?; - let r: i64 = engine.call_fn(&mut scope, &ast, "hello", (42 as INT, 123 as INT))?; + let r: INT = engine.call_fn(&mut scope, &ast, "hello", (42 as INT, 123 as INT))?; assert_eq!(r, 165); - let r: i64 = engine.call_fn(&mut scope, &ast, "hello", (123 as INT,))?; + let r: INT = engine.call_fn(&mut scope, &ast, "hello", (123 as INT,))?; assert_eq!(r, 5166); - let r: i64 = engine.call_fn(&mut scope, &ast, "hello", ())?; + let r: INT = engine.call_fn(&mut scope, &ast, "hello", ())?; assert_eq!(r, 42); assert_eq!( @@ -60,6 +60,27 @@ fn test_call_fn() -> Result<(), Box> { Ok(()) } +#[test] +fn test_call_fn_private() -> Result<(), Box> { + let engine = Engine::new(); + let mut scope = Scope::new(); + + let ast = engine.compile("fn add(x, n) { x + n }")?; + + let r: INT = engine.call_fn(&mut scope, &ast, "add", (40 as INT, 2 as INT))?; + assert_eq!(r, 42); + + let ast = engine.compile("private fn add(x, n) { x + n }")?; + + assert!(matches!( + *engine.call_fn::<_, INT>(&mut scope, &ast, "add", (40 as INT, 2 as INT)) + .expect_err("should error"), + EvalAltResult::ErrorFunctionNotFound(fn_name, _) if fn_name == "add" + )); + + Ok(()) +} + #[test] fn test_anonymous_fn() -> Result<(), Box> { let calc_func = Func::<(INT, INT, INT), INT>::create_from_script( @@ -70,5 +91,16 @@ fn test_anonymous_fn() -> Result<(), Box> { assert_eq!(calc_func(42, 123, 9)?, 1485); + let calc_func = Func::<(INT, INT, INT), INT>::create_from_script( + Engine::new(), + "private fn calc(x, y, z) { (x + y) * z }", + "calc", + )?; + + assert!(matches!( + *calc_func(42, 123, 9).expect_err("should error"), + EvalAltResult::ErrorFunctionNotFound(fn_name, _) if fn_name == "calc" + )); + Ok(()) } diff --git a/tests/functions.rs b/tests/functions.rs new file mode 100644 index 00000000..26d9b387 --- /dev/null +++ b/tests/functions.rs @@ -0,0 +1,25 @@ +#![cfg(not(feature = "no_function"))] +use rhai::{Engine, EvalAltResult, INT}; + +#[test] +fn test_functions() -> Result<(), Box> { + let engine = Engine::new(); + + assert_eq!(engine.eval::("fn add(x, n) { x + n } add(40, 2)")?, 42); + + #[cfg(not(feature = "no_object"))] + assert_eq!( + engine.eval::("fn add(x, n) { x + n } let x = 40; x.add(2)")?, + 42 + ); + + assert_eq!(engine.eval::("fn mul2(x) { x * 2 } mul2(21)")?, 42); + + #[cfg(not(feature = "no_object"))] + assert_eq!( + engine.eval::("fn mul2(x) { x * 2 } let x = 21; x.mul2()")?, + 42 + ); + + Ok(()) +} diff --git a/tests/get_set.rs b/tests/get_set.rs index 57712304..94c3064a 100644 --- a/tests/get_set.rs +++ b/tests/get_set.rs @@ -43,20 +43,20 @@ fn test_get_set() -> Result<(), Box> { engine.register_fn("new_ts", TestStruct::new); #[cfg(not(feature = "no_index"))] - engine.register_indexer(|value: &mut TestStruct, index: INT| value.array[index as usize]); + engine.register_indexer(|value: &mut TestStruct, index: String| value.array[index.len()]); assert_eq!(engine.eval::("let a = new_ts(); a.x = 500; a.x")?, 500); assert_eq!(engine.eval::("let a = new_ts(); a.x.add(); a.x")?, 42); assert_eq!(engine.eval::("let a = new_ts(); a.y.add(); a.y")?, 0); #[cfg(not(feature = "no_index"))] - assert_eq!(engine.eval::("let a = new_ts(); a[3]")?, 4); + assert_eq!(engine.eval::(r#"let a = new_ts(); a["abc"]"#)?, 4); Ok(()) } #[test] -fn test_big_get_set() -> Result<(), Box> { +fn test_get_set_chain() -> Result<(), Box> { #[derive(Clone)] struct TestChild { x: INT, diff --git a/tests/method_call.rs b/tests/method_call.rs index 99d1d0bd..850cf247 100644 --- a/tests/method_call.rs +++ b/tests/method_call.rs @@ -10,8 +10,8 @@ fn test_method_call() -> Result<(), Box> { } impl TestStruct { - fn update(&mut self) { - self.x += 1000; + fn update(&mut self, n: INT) { + self.x += n; } fn new() -> Self { @@ -27,14 +27,23 @@ fn test_method_call() -> Result<(), Box> { engine.register_fn("new_ts", TestStruct::new); assert_eq!( - engine.eval::("let x = new_ts(); x.update(); x")?, + engine.eval::("let x = new_ts(); x.update(1000); x")?, TestStruct { x: 1001 } ); assert_eq!( - engine.eval::("let x = new_ts(); update(x); x")?, + engine.eval::("let x = new_ts(); update(x, 1000); x")?, TestStruct { x: 1 } ); Ok(()) } + +#[test] +fn test_method_call_style() -> Result<(), Box> { + let engine = Engine::new(); + + assert_eq!(engine.eval::("let x = -123; x.abs(); x")?, -123); + + Ok(()) +} diff --git a/tests/modules.rs b/tests/modules.rs index 52f6818e..4e475d1c 100644 --- a/tests/modules.rs +++ b/tests/modules.rs @@ -72,17 +72,77 @@ fn test_module_resolver() -> Result<(), Box> { assert_eq!( engine.eval::( r#" - import "hello" as h; - h::answer + import "hello" as h1; + import "hello" as h2; + h2::answer "# )?, 42 ); + engine.set_max_modules(5); + + assert!(matches!( + *engine + .eval::( + r#" + let sum = 0; + + for x in range(0, 10) { + import "hello" as h; + sum += h::answer; + } + + sum + "# + ) + .expect_err("should error"), + EvalAltResult::ErrorTooManyModules(_) + )); + + #[cfg(not(feature = "no_function"))] + assert!(matches!( + *engine + .eval::( + r#" + let sum = 0; + + fn foo() { + import "hello" as h; + sum += h::answer; + } + + for x in range(0, 10) { + foo(); + } + + sum + "# + ) + .expect_err("should error"), + EvalAltResult::ErrorInFunctionCall(fn_name, _, _) if fn_name == "foo" + )); + + engine.set_max_modules(0); + + #[cfg(not(feature = "no_function"))] + engine.eval::<()>( + r#" + fn foo() { + import "hello" as h; + } + + for x in range(0, 10) { + foo(); + } + "#, + )?; + Ok(()) } #[test] +#[cfg(not(feature = "no_function"))] fn test_module_from_ast() -> Result<(), Box> { let mut engine = Engine::new(); @@ -100,7 +160,7 @@ fn test_module_from_ast() -> Result<(), Box> { x + 1 } fn add_len(x, y) { - x + y.len() + x + len(y) } private fn hidden() { throw "you shouldn't see me!"; diff --git a/tests/operations.rs b/tests/operations.rs new file mode 100644 index 00000000..c02e2381 --- /dev/null +++ b/tests/operations.rs @@ -0,0 +1,113 @@ +#![cfg(not(feature = "unchecked"))] +use rhai::{Engine, EvalAltResult}; + +#[test] +fn test_max_operations() -> Result<(), Box> { + let mut engine = Engine::new(); + engine.set_max_operations(500); + + engine.on_progress(|count| { + if count % 100 == 0 { + println!("{}", count); + } + true + }); + + engine.eval::<()>("let x = 0; while x < 20 { x += 1; }")?; + + assert!(matches!( + *engine + .eval::<()>("for x in range(0, 500) {}") + .expect_err("should error"), + EvalAltResult::ErrorTooManyOperations(_) + )); + + engine.set_max_operations(0); + + engine.eval::<()>("for x in range(0, 10000) {}")?; + + Ok(()) +} + +#[test] +fn test_max_operations_functions() -> Result<(), Box> { + let mut engine = Engine::new(); + engine.set_max_operations(500); + + engine.on_progress(|count| { + if count % 100 == 0 { + println!("{}", count); + } + true + }); + + engine.eval::<()>( + r#" + print("Test1"); + let x = 0; + + while x < 28 { + print(x); + x += 1; + } + "#, + )?; + + #[cfg(not(feature = "no_function"))] + engine.eval::<()>( + r#" + print("Test2"); + fn inc(x) { x + 1 } + let x = 0; + while x < 20 { x = inc(x); } + "#, + )?; + + #[cfg(not(feature = "no_function"))] + assert!(matches!( + *engine + .eval::<()>( + r#" + print("Test3"); + fn inc(x) { x + 1 } + let x = 0; + + while x < 28 { + print(x); + x = inc(x); + } + "#, + ) + .expect_err("should error"), + EvalAltResult::ErrorTooManyOperations(_) + )); + + Ok(()) +} + +#[test] +fn test_max_operations_eval() -> Result<(), Box> { + let mut engine = Engine::new(); + engine.set_max_operations(500); + + engine.on_progress(|count| { + if count % 100 == 0 { + println!("{}", count); + } + true + }); + + assert!(matches!( + *engine + .eval::<()>( + r#" + let script = "for x in range(0, 500) {}"; + eval(script); + "# + ) + .expect_err("should error"), + EvalAltResult::ErrorTooManyOperations(_) + )); + + Ok(()) +} diff --git a/tests/stack.rs b/tests/stack.rs index 503bcbde..ee7eedc4 100644 --- a/tests/stack.rs +++ b/tests/stack.rs @@ -1,32 +1,79 @@ #![cfg(not(feature = "no_function"))] -use rhai::{Engine, EvalAltResult}; +use rhai::{Engine, EvalAltResult, ParseErrorType}; #[test] -fn test_stack_overflow() -> Result<(), Box> { +fn test_stack_overflow_fn_calls() -> Result<(), Box> { let engine = Engine::new(); assert_eq!( engine.eval::( r" - fn foo(n) { if n == 0 { 0 } else { n + foo(n-1) } } - foo(25) + fn foo(n) { if n <= 1 { 0 } else { n + foo(n-1) } } + foo(8) ", )?, - 325 + 35 ); - match engine.eval::<()>( + #[cfg(not(feature = "unchecked"))] + assert!(matches!( + *engine.eval::<()>( r" fn foo(n) { if n == 0 { 0 } else { n + foo(n-1) } } foo(1000) - ", - ) { - Ok(_) => panic!("should be stack overflow"), - Err(err) => match *err { - EvalAltResult::ErrorStackOverflow(_) => (), - _ => panic!("should be stack overflow"), - }, - } + ").expect_err("should error"), + EvalAltResult::ErrorInFunctionCall(name, _, _) if name.starts_with("foo > foo > foo") + )); + + Ok(()) +} + +#[test] +fn test_stack_overflow_parsing() -> Result<(), Box> { + let mut engine = Engine::new(); + + assert!(matches!( + *engine.compile(r" + let a = (1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+(1+1)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) + ").expect_err("should error"), + err if err.error_type() == &ParseErrorType::ExprTooDeep + )); + + engine.set_max_expr_depths(100, 6); + + engine.compile("1 + 2")?; + engine.compile( + r" + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 0 + + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 0 + + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 0 + + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 0 + + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 0 + 0 + + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 0 + + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 0 + + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 0 + + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 0 + + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + ", + )?; + + assert!(matches!( + *engine.compile(r" + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 0 + + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 0 + + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 0 + + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 0 + + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 0 + + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 0 + + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 0 + + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 0 + + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 0 + + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + ").expect_err("should error"), + err if err.error_type() == &ParseErrorType::ExprTooDeep + )); + + engine.compile("fn abc(x) { x + 1 }")?; Ok(()) }