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

Merge pull request #419 from schungx/master

Browse Source 
New string functions.
This commit is contained in:
Stephen Chung 2021-06-20 17:34:50 +08:00 committed by GitHub
commit c11ea90202
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 479 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CHANGELOG.md
View File

@ -23,6 +23,8 @@ New features
* An integer value can now be indexed to get/set a single bit.
* The `bits` method of an integer can be used to iterate through its bits.
* New `$bool$`, `$int$`, `$float$` and `$string$` expression types for custom syntax.
* New methods `to_hex`, `to_octal` and `to_binary` for integer numbers.
* New methods `to_upper`, `to_lower`, `make_upper`, `make_lower` for strings/characters.
Version 0.20.2

36
src/engine.rs
View File

@ -248,7 +248,6 @@ pub const FN_ANONYMOUS: &str = "anon$";
pub const OP_EQUALS: &str = "==";
/// Standard method function for containment testing.
///
/// The `in` operator is implemented as a call to this method.
pub const OP_CONTAINS: &str = "contains";
@ -1233,7 +1232,7 @@ impl Engine {
}
}
let is_ref = target.is_ref();
let is_ref_mut = target.is_ref();
// Pop the last index value
let idx_val = idx_values
@ -1293,10 +1292,11 @@ impl Engine {
let hash_set =
FnCallHashes::from_native(crate::calc_fn_hash(FN_IDX_SET, 3));
let args = &mut [target, &mut idx_val_for_setter, &mut new_val];
let pos = Position::NONE;
self.exec_fn_call(
mods, state, lib, FN_IDX_SET, hash_set, args, is_ref, true,
new_pos, None, level,
mods, state, lib, FN_IDX_SET, hash_set, args, is_ref_mut, true,
pos, None, level,
)?;
}
@ -1374,8 +1374,8 @@ impl Engine {
let args = &mut [target.as_mut()];
let (mut orig_val, _) = self
.exec_fn_call(
mods, state, lib, getter, hash, args, is_ref, true, *pos, None,
level,
mods, state, lib, getter, hash, args, is_ref_mut, true, *pos,
None, level,
)
.or_else(|err| match *err {
// Try an indexer if property does not exist
@ -1417,7 +1417,8 @@ impl Engine {
let hash = FnCallHashes::from_native(*hash_set);
let args = &mut [target.as_mut(), &mut new_val];
self.exec_fn_call(
mods, state, lib, setter, hash, args, is_ref, true, *pos, None, level,
mods, state, lib, setter, hash, args, is_ref_mut, true, *pos, None,
level,
)
.or_else(|err| match *err {
// Try an indexer if property does not exist
@ -1425,10 +1426,11 @@ impl Engine {
let args = &mut [target, &mut name.into(), &mut new_val];
let hash_set =
FnCallHashes::from_native(crate::calc_fn_hash(FN_IDX_SET, 3));
let pos = Position::NONE;
self.exec_fn_call(
mods, state, lib, FN_IDX_SET, hash_set, args, is_ref, true,
*pos, None, level,
mods, state, lib, FN_IDX_SET, hash_set, args, is_ref_mut, true,
pos, None, level,
)
.map_err(
|idx_err| match *idx_err {
@ -1446,7 +1448,8 @@ impl Engine {
let hash = FnCallHashes::from_native(*hash_get);
let args = &mut [target.as_mut()];
self.exec_fn_call(
mods, state, lib, getter, hash, args, is_ref, true, *pos, None, level,
mods, state, lib, getter, hash, args, is_ref_mut, true, *pos, None,
level,
)
.map_or_else(
|err| match *err {
@ -1517,7 +1520,7 @@ impl Engine {
let args = &mut arg_values[..1];
let (mut val, updated) = self
.exec_fn_call(
mods, state, lib, getter, hash_get, args, is_ref, true,
mods, state, lib, getter, hash_get, args, is_ref_mut, true,
*pos, None, level,
)
.or_else(|err| match *err {
@ -1563,7 +1566,7 @@ impl Engine {
let mut arg_values = [target.as_mut(), val];
let args = &mut arg_values;
self.exec_fn_call(
mods, state, lib, setter, hash_set, args, is_ref, true,
mods, state, lib, setter, hash_set, args, is_ref_mut, true,
*pos, None, level,
)
.or_else(
@ -1577,7 +1580,7 @@ impl Engine {
);
self.exec_fn_call(
mods, state, lib, FN_IDX_SET, hash_set, args,
is_ref, true, *pos, None, level,
is_ref_mut, true, *pos, None, level,
)
.or_else(|idx_err| match *idx_err {
EvalAltResult::ErrorIndexingType(_, _) => {
@ -1972,6 +1975,7 @@ impl Engine {
_ if indexers => {
let args = &mut [target, &mut idx];
let hash_get = FnCallHashes::from_native(crate::calc_fn_hash(FN_IDX_GET, 2));
let idx_pos = Position::NONE;
self.exec_fn_call(
mods, state, lib, FN_IDX_GET, hash_get, args, true, true, idx_pos, None, level,
@ -1980,7 +1984,11 @@ impl Engine {
}
_ => EvalAltResult::ErrorIndexingType(
self.map_type_name(target.type_name()).into(),
format!(
"{} [{}]",
self.map_type_name(target.type_name()),
self.map_type_name(idx.type_name())
),
Position::NONE,
)
.into(),

3
src/engine_api.rs
View File

@ -2,7 +2,8 @@
use crate::dynamic::Variant;
use crate::engine::{EvalContext, Imports, State};
use crate::fn_native::{FnCallArgs, SendSync};
use crate::fn_call::FnCallArgs;
use crate::fn_native::SendSync;
use crate::fn_register::RegisterNativeFunction;
use crate::optimize::OptimizationLevel;
use crate::parse::ParseState;

13
src/error.rs
View File

@ -59,8 +59,7 @@ pub enum EvalAltResult {
/// Bit-field indexing out-of-bounds.
/// Wrapped values are the current number of bits in the bit-field and the index number.
ErrorBitFieldBounds(usize, INT, Position),
/// Trying to index into a type that is not an array, an object map, or a string, and has no
/// indexer function defined. Wrapped value is the type name.
/// Trying to index into a type that has no indexer function defined. Wrapped value is the type name.
ErrorIndexingType(String, Position),
/// The `for` statement encounters a type that is not an iterator.
ErrorFor(Position),
@ -101,14 +100,12 @@ impl EvalAltResult {
#[allow(deprecated)]
Self::ErrorSystem(_, s) => s.description(),
Self::ErrorParsing(p, _) => p.desc(),
Self::ErrorInFunctionCall(_,_, _, _) => "Error in called function",
Self::ErrorInFunctionCall(_, _, _, _) => "Error in called function",
Self::ErrorInModule(_, _, _) => "Error in module",
Self::ErrorFunctionNotFound(_, _) => "Function not found",
Self::ErrorUnboundThis(_) => "'this' is not bound",
Self::ErrorMismatchDataType(_, _, _) => "Data type is incorrect",
Self::ErrorIndexingType(_, _) => {
"Indexing can only be performed on an array, an object map, a string, or a type with an indexer function defined"
}
Self::ErrorIndexingType(_, _) => "No indexer of the appropriate types defined",
Self::ErrorArrayBounds(0, _, _) => "Empty array has nothing to access",
Self::ErrorArrayBounds(_, _, _) => "Array index out of bounds",
Self::ErrorStringBounds(0, _, _) => "Empty string has nothing to index",
@ -126,7 +123,7 @@ impl EvalAltResult {
Self::ErrorTooManyModules(_) => "Too many modules imported",
Self::ErrorStackOverflow(_) => "Stack overflow",
Self::ErrorDataTooLarge(_, _) => "Data size exceeds maximum limit",
Self::ErrorTerminated(_,_) => "Script terminated.",
Self::ErrorTerminated(_, _) => "Script terminated.",
Self::ErrorRuntime(_, _) => "Runtime error",
Self::LoopBreak(true, _) => "Break statement not inside a loop",
Self::LoopBreak(false, _) => "Continue statement not inside a loop",
@ -175,7 +172,7 @@ impl fmt::Display for EvalAltResult {
Self::ErrorDotExpr(s, _) if !s.is_empty() => f.write_str(s)?,
Self::ErrorIndexingType(s, _) => write!(f, "Indexer not registered for type '{}'", s)?,
Self::ErrorIndexingType(s, _) => write!(f, "Indexer not registered for '{}'", s)?,
Self::ErrorUnboundThis(_)
| Self::ErrorFor(_)

3
src/fn_builtin.rs
View File

@ -1,7 +1,8 @@
//! Built-in implementations for common operators.
use crate::engine::OP_CONTAINS;
use crate::fn_native::{FnCallArgs, NativeCallContext};
use crate::fn_call::FnCallArgs;
use crate::fn_native::NativeCallContext;
use crate::{Dynamic, ImmutableString, RhaiResult, INT};
use std::any::TypeId;
#[cfg(feature = "no_std")]

53
src/fn_call.rs
View File

@ -7,7 +7,7 @@ use crate::engine::{
MAX_DYNAMIC_PARAMETERS,
};
use crate::fn_builtin::{get_builtin_binary_op_fn, get_builtin_op_assignment_fn};
use crate::fn_native::{FnAny, FnCallArgs};
use crate::fn_native::FnAny;
use crate::module::NamespaceRef;
use crate::optimize::OptimizationLevel;
use crate::{
@ -30,6 +30,9 @@ use std::{
#[cfg(not(feature = "no_object"))]
use crate::Map;
/// Arguments to a function call, which is a list of [`&mut Dynamic`][Dynamic].
pub type FnCallArgs<'a> = [&'a mut Dynamic];
/// A type that temporarily stores a mutable reference to a `Dynamic`,
/// replacing it with a cloned copy.
#[derive(Debug, Default)]
@ -102,13 +105,13 @@ impl Drop for ArgBackup<'_> {
pub fn ensure_no_data_race(
fn_name: &str,
args: &FnCallArgs,
is_ref: bool,
is_method_call: bool,
) -> Result<(), Box<EvalAltResult>> {
#[cfg(not(feature = "no_closure"))]
if let Some((n, _)) = args
.iter()
.enumerate()
.skip(if is_ref { 1 } else { 0 })
.skip(if is_method_call { 1 } else { 0 })
.find(|(_, a)| a.is_locked())
{
return EvalAltResult::ErrorDataRace(
@ -298,7 +301,7 @@ impl Engine {
name: &str,
hash: u64,
args: &mut FnCallArgs,
is_ref: bool,
is_method_call: bool,
is_op_assign: bool,
pos: Position,
) -> Result<(Dynamic, bool), Box<EvalAltResult>> {
@ -316,7 +319,7 @@ impl Engine {
// Calling pure function but the first argument is a reference?
let mut backup: Option<ArgBackup> = None;
if is_ref && func.is_pure() && !args.is_empty() {
if is_method_call && func.is_pure() && !args.is_empty() {
backup = Some(Default::default());
backup.as_mut().map(|bk| bk.change_first_arg_to_copy(args));
}
@ -373,7 +376,11 @@ impl Engine {
assert!(args.len() == 2);
EvalAltResult::ErrorIndexingType(
self.map_type_name(args[0].type_name()).to_string(),
format!(
"{} [{}]",
self.map_type_name(args[0].type_name()),
self.map_type_name(args[1].type_name())
),
pos,
)
.into()
@ -385,7 +392,12 @@ impl Engine {
assert!(args.len() == 3);
EvalAltResult::ErrorIndexingType(
self.map_type_name(args[0].type_name()).to_string(),
format!(
"{} [{}] = {}",
self.map_type_name(args[0].type_name()),
self.map_type_name(args[1].type_name()),
self.map_type_name(args[2].type_name())
),
pos,
)
.into()
@ -620,8 +632,8 @@ impl Engine {
fn_name: &str,
hashes: FnCallHashes,
args: &mut FnCallArgs,
is_ref: bool,
_is_method: bool,
is_ref_mut: bool,
_is_method_call: bool,
pos: Position,
_capture_scope: Option<Scope>,
_level: usize,
@ -634,7 +646,7 @@ impl Engine {
// Check for data race.
#[cfg(not(feature = "no_closure"))]
ensure_no_data_race(fn_name, args, is_ref)?;
ensure_no_data_race(fn_name, args, is_ref_mut)?;
// These may be redirected from method style calls.
match fn_name {
@ -722,7 +734,7 @@ impl Engine {
});
}
let result = if _is_method {
let result = if _is_method_call {
// Method call of script function - map first argument to `this`
let (first, rest) = args
.split_first_mut()
@ -753,7 +765,7 @@ impl Engine {
// Normal call of script function
// The first argument is a reference?
let mut backup: Option<ArgBackup> = None;
if is_ref && !args.is_empty() {
if is_ref_mut && !args.is_empty() {
backup = Some(Default::default());
backup.as_mut().map(|bk| bk.change_first_arg_to_copy(args));
}
@ -780,7 +792,9 @@ impl Engine {
// Native function call
let hash = hashes.native;
self.call_native_fn(mods, state, lib, fn_name, hash, args, is_ref, false, pos)
self.call_native_fn(
mods, state, lib, fn_name, hash, args, is_ref_mut, false, pos,
)
}
/// Evaluate a list of statements with no `this` pointer.
@ -872,7 +886,7 @@ impl Engine {
pos: Position,
level: usize,
) -> Result<(Dynamic, bool), Box<EvalAltResult>> {
let is_ref = target.is_ref();
let is_ref_mut = target.is_ref();
let (result, updated) = match fn_name {
KEYWORD_FN_PTR_CALL if target.is::<FnPtr>() => {
@ -932,7 +946,8 @@ impl Engine {
// Map it to name(args) in function-call style
self.exec_fn_call(
mods, state, lib, fn_name, new_hash, &mut args, is_ref, true, pos, None, level,
mods, state, lib, fn_name, new_hash, &mut args, is_ref_mut, true, pos, None,
level,
)
}
KEYWORD_FN_PTR_CURRY => {
@ -1004,7 +1019,7 @@ impl Engine {
args.extend(call_args.iter_mut());
self.exec_fn_call(
mods, state, lib, fn_name, hash, &mut args, is_ref, true, pos, None, level,
mods, state, lib, fn_name, hash, &mut args, is_ref_mut, true, pos, None, level,
)
}
}?;
@ -1227,7 +1242,7 @@ impl Engine {
// Normal function call - except for Fn, curry, call and eval (handled above)
let mut arg_values = StaticVec::with_capacity(args_expr.len());
let mut args = StaticVec::with_capacity(args_expr.len() + curry.len());
let mut is_ref = false;
let mut is_ref_mut = false;
let capture = if capture_scope && !scope.is_empty() {
Some(scope.clone_visible())
} else {
@ -1269,7 +1284,7 @@ impl Engine {
args.extend(arg_values.iter_mut())
} else {
// Turn it into a method call only if the object is not shared and not a simple value
is_ref = true;
is_ref_mut = true;
let obj_ref = target.take_ref().expect("never fails because `target` is a reference if it is not a value and not shared");
args.push(obj_ref);
args.extend(arg_values.iter_mut());
@ -1288,7 +1303,7 @@ impl Engine {
}
self.exec_fn_call(
mods, state, lib, name, hashes, &mut args, is_ref, false, pos, capture, level,
mods, state, lib, name, hashes, &mut args, is_ref_mut, false, pos, capture, level,
)
.map(|(v, _)| v)
}

187
src/fn_native.rs
View File

@ -2,18 +2,14 @@
use crate::ast::{FnAccess, FnCallHashes};
use crate::engine::Imports;
use crate::fn_call::FnCallArgs;
use crate::plugin::PluginFunction;
use crate::token::is_valid_identifier;
use crate::{
calc_fn_hash, Dynamic, Engine, EvalAltResult, EvalContext, Identifier, Module, Position,
RhaiResult, StaticVec,
calc_fn_hash, Dynamic, Engine, EvalAltResult, EvalContext, Module, Position, RhaiResult,
};
use std::fmt;
#[cfg(feature = "no_std")]
use std::prelude::v1::*;
use std::{
convert::{TryFrom, TryInto},
fmt, mem,
};
/// Trait that maps to `Send + Sync` only under the `sync` feature.
#[cfg(feature = "sync")]
@ -204,12 +200,12 @@ impl<'a> NativeCallContext<'a> {
pub fn call_fn_dynamic_raw(
&self,
fn_name: impl AsRef<str>,
is_method: bool,
is_method_call: bool,
args: &mut [&mut Dynamic],
) -> RhaiResult {
let fn_name = fn_name.as_ref();
let hash = if is_method {
let hash = if is_method_call {
FnCallHashes::from_script_and_native(
calc_fn_hash(fn_name, args.len() - 1),
calc_fn_hash(fn_name, args.len()),
@ -226,8 +222,8 @@ impl<'a> NativeCallContext<'a> {
fn_name,
hash,
args,
is_method,
is_method,
is_method_call,
is_method_call,
Position::NONE,
None,
0,
@ -271,175 +267,6 @@ pub fn shared_take<T>(value: Shared<T>) -> T {
.expect("resource should have no outstanding references")
}
/// Arguments to a function call, which is a list of [`&mut Dynamic`][Dynamic].
pub type FnCallArgs<'a> = [&'a mut Dynamic];
/// A general function pointer, which may carry additional (i.e. curried) argument values
/// to be passed onto a function during a call.
#[derive(Debug, Clone, Hash)]
pub struct FnPtr(Identifier, StaticVec<Dynamic>);
impl FnPtr {
/// Create a new function pointer.
#[inline(always)]
#[must_use]
pub fn new(name: impl Into<Identifier>) -> Result<Self, Box<EvalAltResult>> {
name.into().try_into()
}
/// Create a new function pointer without checking its parameters.
#[inline(always)]
#[must_use]
pub(crate) fn new_unchecked(name: Identifier, curry: StaticVec<Dynamic>) -> Self {
Self(name.into(), curry)
}
/// Get the name of the function.
#[inline(always)]
#[must_use]
pub fn fn_name(&self) -> &str {
self.get_fn_name().as_ref()
}
/// Get the name of the function.
#[inline(always)]
#[must_use]
pub(crate) fn get_fn_name(&self) -> &Identifier {
&self.0
}
/// Get the underlying data of the function pointer.
#[inline(always)]
#[must_use]
pub(crate) fn take_data(self) -> (Identifier, StaticVec<Dynamic>) {
(self.0, self.1)
}
/// Get the curried arguments.
#[inline(always)]
#[must_use]
pub fn curry(&self) -> &[Dynamic] {
self.1.as_ref()
}
/// Add a new curried argument.
#[inline(always)]
pub fn add_curry(&mut self, value: Dynamic) -> &mut Self {
self.1.push(value);
self
}
/// Set curried arguments to the function pointer.
#[inline(always)]
pub fn set_curry(&mut self, values: impl IntoIterator<Item = Dynamic>) -> &mut Self {
self.1 = values.into_iter().collect();
self
}
/// Is the function pointer curried?
#[inline(always)]
#[must_use]
pub fn is_curried(&self) -> bool {
!self.1.is_empty()
}
/// Get the number of curried arguments.
#[inline(always)]
#[must_use]
pub fn num_curried(&self) -> usize {
self.1.len()
}
/// Does the function pointer refer to an anonymous function?
///
/// Not available under `no_function`.
#[cfg(not(feature = "no_function"))]
#[inline(always)]
#[must_use]
pub fn is_anonymous(&self) -> bool {
self.0.starts_with(crate::engine::FN_ANONYMOUS)
}
/// Call the function pointer with curried arguments (if any).
///
/// If this function is a script-defined function, it must not be marked private.
///
/// # WARNING
///
/// All the arguments are _consumed_, meaning that they're replaced by `()`.
/// This is to avoid unnecessarily cloning the arguments.
/// Do not use the arguments after this call. If they are needed afterwards,
/// clone them _before_ calling this function.
#[inline(always)]
#[must_use]
pub fn call_dynamic(
&self,
ctx: &NativeCallContext,
this_ptr: Option<&mut Dynamic>,
mut arg_values: impl AsMut<[Dynamic]>,
) -> RhaiResult {
let mut arg_values = arg_values.as_mut();
let mut args_data;
if self.num_curried() > 0 {
args_data = StaticVec::with_capacity(self.num_curried() + arg_values.len());
args_data.extend(self.curry().iter().cloned());
args_data.extend(arg_values.iter_mut().map(mem::take));
arg_values = args_data.as_mut();
};
let is_method = this_ptr.is_some();
let mut args = StaticVec::with_capacity(arg_values.len() + 1);
if let Some(obj) = this_ptr {
args.push(obj);
}
args.extend(arg_values.iter_mut());
ctx.call_fn_dynamic_raw(self.fn_name(), is_method, &mut args)
}
}
impl fmt::Display for FnPtr {
#[inline(always)]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Fn({})", self.0)
}
}
impl TryFrom<Identifier> for FnPtr {
type Error = Box<EvalAltResult>;
#[inline(always)]
fn try_from(value: Identifier) -> Result<Self, Self::Error> {
if is_valid_identifier(value.chars()) {
Ok(Self(value, Default::default()))
} else {
EvalAltResult::ErrorFunctionNotFound(value.to_string(), Position::NONE).into()
}
}
}
#[cfg(not(feature = "no_smartstring"))]
impl TryFrom<crate::ImmutableString> for FnPtr {
type Error = Box<EvalAltResult>;
#[inline(always)]
fn try_from(value: crate::ImmutableString) -> Result<Self, Self::Error> {
let s: Identifier = value.into();
Self::try_from(s)
}
}
impl TryFrom<String> for FnPtr {
type Error = Box<EvalAltResult>;
#[inline(always)]
fn try_from(value: String) -> Result<Self, Self::Error> {
let s: Identifier = value.into();
Self::try_from(s)
}
}
impl TryFrom<&str> for FnPtr {
type Error = Box<EvalAltResult>;
#[inline(always)]
fn try_from(value: &str) -> Result<Self, Self::Error> {
let s: Identifier = value.into();
Self::try_from(s)
}
}
/// A general function trail object.
#[cfg(not(feature = "sync"))]
pub type FnAny = dyn Fn(NativeCallContext, &mut FnCallArgs) -> RhaiResult;

178
src/fn_ptr.rs Normal file
View File

@ -0,0 +1,178 @@
//! The `FnPtr` type.
use crate::token::is_valid_identifier;
use crate::{
Dynamic, EvalAltResult, Identifier, NativeCallContext, Position, RhaiResult, StaticVec,
};
#[cfg(feature = "no_std")]
use std::prelude::v1::*;
use std::{
convert::{TryFrom, TryInto},
fmt, mem,
};
/// A general function pointer, which may carry additional (i.e. curried) argument values
/// to be passed onto a function during a call.
#[derive(Debug, Clone, Hash)]
pub struct FnPtr(Identifier, StaticVec<Dynamic>);
impl FnPtr {
/// Create a new function pointer.
#[inline(always)]
#[must_use]
pub fn new(name: impl Into<Identifier>) -> Result<Self, Box<EvalAltResult>> {
name.into().try_into()
}
/// Create a new function pointer without checking its parameters.
#[inline(always)]
#[must_use]
pub(crate) fn new_unchecked(name: Identifier, curry: StaticVec<Dynamic>) -> Self {
Self(name.into(), curry)
}
/// Get the name of the function.
#[inline(always)]
#[must_use]
pub fn fn_name(&self) -> &str {
self.get_fn_name().as_ref()
}
/// Get the name of the function.
#[inline(always)]
#[must_use]
pub(crate) fn get_fn_name(&self) -> &Identifier {
&self.0
}
/// Get the underlying data of the function pointer.
#[inline(always)]
#[must_use]
pub(crate) fn take_data(self) -> (Identifier, StaticVec<Dynamic>) {
(self.0, self.1)
}
/// Get the curried arguments.
#[inline(always)]
#[must_use]
pub fn curry(&self) -> &[Dynamic] {
self.1.as_ref()
}
/// Add a new curried argument.
#[inline(always)]
pub fn add_curry(&mut self, value: Dynamic) -> &mut Self {
self.1.push(value);
self
}
/// Set curried arguments to the function pointer.
#[inline(always)]
pub fn set_curry(&mut self, values: impl IntoIterator<Item = Dynamic>) -> &mut Self {
self.1 = values.into_iter().collect();
self
}
/// Is the function pointer curried?
#[inline(always)]
#[must_use]
pub fn is_curried(&self) -> bool {
!self.1.is_empty()
}
/// Get the number of curried arguments.
#[inline(always)]
#[must_use]
pub fn num_curried(&self) -> usize {
self.1.len()
}
/// Does the function pointer refer to an anonymous function?
///
/// Not available under `no_function`.
#[cfg(not(feature = "no_function"))]
#[inline(always)]
#[must_use]
pub fn is_anonymous(&self) -> bool {
self.0.starts_with(crate::engine::FN_ANONYMOUS)
}
/// Call the function pointer with curried arguments (if any).
///
/// If this function is a script-defined function, it must not be marked private.
///
/// # WARNING
///
/// All the arguments are _consumed_, meaning that they're replaced by `()`.
/// This is to avoid unnecessarily cloning the arguments.
/// Do not use the arguments after this call. If they are needed afterwards,
/// clone them _before_ calling this function.
#[inline(always)]
#[must_use]
pub fn call_dynamic(
&self,
ctx: &NativeCallContext,
this_ptr: Option<&mut Dynamic>,
mut arg_values: impl AsMut<[Dynamic]>,
) -> RhaiResult {
let mut arg_values = arg_values.as_mut();
let mut args_data;
if self.num_curried() > 0 {
args_data = StaticVec::with_capacity(self.num_curried() + arg_values.len());
args_data.extend(self.curry().iter().cloned());
args_data.extend(arg_values.iter_mut().map(mem::take));
arg_values = args_data.as_mut();
};
let is_method = this_ptr.is_some();
let mut args = StaticVec::with_capacity(arg_values.len() + 1);
if let Some(obj) = this_ptr {
args.push(obj);
}
args.extend(arg_values.iter_mut());
ctx.call_fn_dynamic_raw(self.fn_name(), is_method, &mut args)
}
}
impl fmt::Display for FnPtr {
#[inline(always)]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Fn({})", self.0)
}
}
impl TryFrom<Identifier> for FnPtr {
type Error = Box<EvalAltResult>;
#[inline(always)]
fn try_from(value: Identifier) -> Result<Self, Self::Error> {
if is_valid_identifier(value.chars()) {
Ok(Self(value, Default::default()))
} else {
EvalAltResult::ErrorFunctionNotFound(value.to_string(), Position::NONE).into()
}
}
}
#[cfg(not(feature = "no_smartstring"))]
impl TryFrom<crate::ImmutableString> for FnPtr {
type Error = Box<EvalAltResult>;
#[inline(always)]
fn try_from(value: crate::ImmutableString) -> Result<Self, Self::Error> {
let s: Identifier = value.into();
Self::try_from(s)
}
}
impl TryFrom<String> for FnPtr {
type Error = Box<EvalAltResult>;
#[inline(always)]
fn try_from(value: String) -> Result<Self, Self::Error> {
let s: Identifier = value.into();
Self::try_from(s)
}
}
impl TryFrom<&str> for FnPtr {
type Error = Box<EvalAltResult>;
#[inline(always)]
fn try_from(value: &str) -> Result<Self, Self::Error> {
let s: Identifier = value.into();
Self::try_from(s)
}
}

3
src/fn_register.rs
View File

@ -3,7 +3,8 @@
#![allow(non_snake_case)]
use crate::dynamic::{DynamicWriteLock, Variant};
use crate::fn_native::{CallableFunction, FnAny, FnCallArgs, SendSync};
use crate::fn_call::FnCallArgs;
use crate::fn_native::{CallableFunction, FnAny, SendSync};
use crate::r#unsafe::unsafe_try_cast;
use crate::token::Position;
use crate::{Dynamic, EvalAltResult, NativeCallContext};

42
src/lib.rs
View File

@ -83,6 +83,7 @@ mod fn_call;
mod fn_func;
mod fn_hash;
mod fn_native;
mod fn_ptr;
mod fn_register;
mod immutable_string;
mod module;
@ -132,22 +133,14 @@ pub use dynamic::Dynamic;
pub use engine::{Engine, EvalContext, OP_CONTAINS, OP_EQUALS};
pub use error::EvalAltResult;
pub use error_parsing::{LexError, ParseError, ParseErrorType};
pub use fn_native::{FnPtr, NativeCallContext};
pub use fn_native::NativeCallContext;
pub use fn_ptr::FnPtr;
pub use fn_register::RegisterNativeFunction;
pub use immutable_string::ImmutableString;
pub use module::{FnNamespace, Module};
pub use scope::Scope;
pub use token::Position;
/// An identifier in Rhai. [`SmartString`](https://crates.io/crates/smartstring) is used because most
/// identifiers are ASCII and short, fewer than 23 characters, so they can be stored inline.
#[cfg(not(feature = "no_smartstring"))]
pub type Identifier = SmartString;
/// An identifier in Rhai.
#[cfg(feature = "no_smartstring")]
pub type Identifier = ImmutableString;
/// A trait to enable registering Rust functions.
/// This trait is no longer needed and will be removed in the future.
#[deprecated(
@ -164,6 +157,30 @@ pub trait RegisterFn {}
)]
pub trait RegisterResultFn {}
/// An identifier in Rhai. [`SmartString`](https://crates.io/crates/smartstring) is used because most
/// identifiers are ASCII and short, fewer than 23 characters, so they can be stored inline.
#[cfg(not(feature = "internals"))]
#[cfg(not(feature = "no_smartstring"))]
pub(crate) type Identifier = SmartString;
/// An identifier in Rhai.
#[cfg(not(feature = "internals"))]
#[cfg(feature = "no_smartstring")]
pub(crate) type Identifier = ImmutableString;
/// An identifier in Rhai. [`SmartString`](https://crates.io/crates/smartstring) is used because most
/// identifiers are ASCII and short, fewer than 23 characters, so they can be stored inline.
#[cfg(feature = "internals")]
#[cfg(not(feature = "no_smartstring"))]
#[deprecated = "this type is volatile and may change"]
pub type Identifier = SmartString;
/// An identifier in Rhai.
#[cfg(feature = "internals")]
#[cfg(feature = "no_smartstring")]
#[deprecated = "this type is volatile and may change"]
pub type Identifier = ImmutableString;
/// Alias to [`Rc`][std::rc::Rc] or [`Arc`][std::sync::Arc] depending on the `sync` feature flag.
pub use fn_native::Shared;
@ -310,17 +327,12 @@ type StaticVec<T> = smallvec::SmallVec<[T; 4]>;
#[cfg(feature = "internals")]
pub type StaticVec<T> = smallvec::SmallVec<[T; 4]>;
#[cfg(not(feature = "internals"))]
#[cfg(not(feature = "no_smartstring"))]
pub(crate) type SmartString = smartstring::SmartString<smartstring::Compact>;
#[cfg(feature = "no_smartstring")]
pub(crate) type SmartString = String;
#[cfg(feature = "internals")]
#[cfg(not(feature = "no_smartstring"))]
pub type SmartString = smartstring::SmartString<smartstring::Compact>;
// Compiler guards against mutually-exclusive feature flags
#[cfg(feature = "no_float")]

3
src/module/mod.rs
View File

@ -2,7 +2,8 @@
use crate::ast::{FnAccess, Ident};
use crate::dynamic::Variant;
use crate::fn_native::{shared_take_or_clone, CallableFunction, FnCallArgs, IteratorFn, SendSync};
use crate::fn_call::FnCallArgs;
use crate::fn_native::{shared_take_or_clone, CallableFunction, IteratorFn, SendSync};
use crate::fn_register::RegisterNativeFunction;
use crate::parse::IdentifierBuilder;
use crate::token::Token;

146
src/packages/string_basic.rs
View File

@ -1,7 +1,8 @@
#![allow(non_snake_case)]
use crate::plugin::*;
use crate::{def_package, FnPtr};
use crate::{def_package, FnPtr, INT};
use std::fmt::{Binary, LowerHex, Octal};
#[cfg(feature = "no_std")]
use std::prelude::v1::*;
@ -16,6 +17,7 @@ pub const FUNC_TO_DEBUG: &'static str = "to_debug";
def_package!(crate:BasicStringPackage:"Basic string utilities, including printing.", lib, {
combine_with_exported_module!(lib, "print_debug", print_debug_functions);
combine_with_exported_module!(lib, "number_formatting", number_formatting);
});
// Register print and debug
@ -147,3 +149,145 @@ mod print_debug_functions {
}
}
}
#[export_module]
mod number_formatting {
#[rhai_fn(skip)]
pub fn to_hex<T: LowerHex>(value: T) -> ImmutableString {
format!("{:x}", value).into()
}
#[rhai_fn(skip)]
pub fn to_octal<T: Octal>(value: T) -> ImmutableString {
format!("{:o}", value).into()
}
#[rhai_fn(skip)]
pub fn to_binary<T: Binary>(value: T) -> ImmutableString {
format!("{:b}", value).into()
}
#[rhai_fn(name = "to_hex")]
pub fn int_to_hex(value: INT) -> ImmutableString {
to_hex(value)
}
#[rhai_fn(name = "to_octal")]
pub fn int_to_octal(value: INT) -> ImmutableString {
to_octal(value)
}
#[cfg(not(feature = "only_i32"))]
#[cfg(not(feature = "only_i64"))]
pub mod numbers {
#[rhai_fn(name = "to_hex")]
pub fn u8_to_hex(value: u8) -> ImmutableString {
to_hex(value)
}
#[rhai_fn(name = "to_hex")]
pub fn u16_to_hex(value: u16) -> ImmutableString {
to_hex(value)
}
#[rhai_fn(name = "to_hex")]
pub fn u32_to_hex(value: u32) -> ImmutableString {
to_hex(value)
}
#[rhai_fn(name = "to_hex")]
pub fn u64_to_hex(value: u64) -> ImmutableString {
to_hex(value)
}
#[rhai_fn(name = "to_hex")]
pub fn i8_to_hex(value: i8) -> ImmutableString {
to_hex(value)
}
#[rhai_fn(name = "to_hex")]
pub fn i16_to_hex(value: i16) -> ImmutableString {
to_hex(value)
}
#[rhai_fn(name = "to_hex")]
pub fn i32_to_hex(value: i32) -> ImmutableString {
to_hex(value)
}
#[rhai_fn(name = "to_hex")]
pub fn i64_to_hex(value: i64) -> ImmutableString {
to_hex(value)
}
#[rhai_fn(name = "to_octal")]
pub fn u8_to_octal(value: u8) -> ImmutableString {
to_octal(value)
}
#[rhai_fn(name = "to_octal")]
pub fn u16_to_octal(value: u16) -> ImmutableString {
to_octal(value)
}
#[rhai_fn(name = "to_octal")]
pub fn u32_to_octal(value: u32) -> ImmutableString {
to_octal(value)
}
#[rhai_fn(name = "to_octal")]
pub fn u64_to_octal(value: u64) -> ImmutableString {
to_octal(value)
}
#[rhai_fn(name = "to_octal")]
pub fn i8_to_octal(value: i8) -> ImmutableString {
to_octal(value)
}
#[rhai_fn(name = "to_octal")]
pub fn i16_to_octal(value: i16) -> ImmutableString {
to_octal(value)
}
#[rhai_fn(name = "to_octal")]
pub fn i32_to_octal(value: i32) -> ImmutableString {
to_octal(value)
}
#[rhai_fn(name = "to_octal")]
pub fn i64_to_octal(value: i64) -> ImmutableString {
to_octal(value)
}
#[rhai_fn(name = "to_binary")]
pub fn u8_to_binary(value: u8) -> ImmutableString {
to_binary(value)
}
#[rhai_fn(name = "to_binary")]
pub fn u16_to_binary(value: u16) -> ImmutableString {
to_binary(value)
}
#[rhai_fn(name = "to_binary")]
pub fn u32_to_binary(value: u32) -> ImmutableString {
to_binary(value)
}
#[rhai_fn(name = "to_binary")]
pub fn u64_to_binary(value: u64) -> ImmutableString {
to_binary(value)
}
#[rhai_fn(name = "to_binary")]
pub fn i8_to_binary(value: i8) -> ImmutableString {
to_binary(value)
}
#[rhai_fn(name = "to_binary")]
pub fn i16_to_binary(value: i16) -> ImmutableString {
to_binary(value)
}
#[rhai_fn(name = "to_binary")]
pub fn i32_to_binary(value: i32) -> ImmutableString {
to_binary(value)
}
#[rhai_fn(name = "to_binary")]
pub fn i64_to_binary(value: i64) -> ImmutableString {
to_binary(value)
}
#[cfg(not(any(target_arch = "wasm32", target_arch = "wasm64")))]
pub mod num_128 {
#[rhai_fn(name = "to_hex")]
pub fn u128_to_hex(value: u128) -> ImmutableString {
to_hex(value)
}
#[rhai_fn(name = "to_octal")]
pub fn i128_to_octal(value: i128) -> ImmutableString {
to_octal(value)
}
#[rhai_fn(name = "to_binary")]
pub fn i128_to_binary(value: i128) -> ImmutableString {
to_binary(value)
}
}
}
}

46
src/packages/string_more.rs
View File

@ -100,6 +100,52 @@ mod string_functions {
}
}
pub fn to_upper(string: &str) -> ImmutableString {
string.to_uppercase().into()
}
pub fn make_upper(string: &mut ImmutableString) {
*string = to_upper(string);
}
pub fn to_lower(string: &str) -> ImmutableString {
string.to_lowercase().into()
}
pub fn make_lower(string: &mut ImmutableString) {
*string = to_lower(string);
}
#[rhai_fn(name = "to_upper")]
pub fn to_upper_char(character: char) -> char {
let mut stream = character.to_uppercase();
let ch = stream
.next()
.expect("never fails because there should be at least one character");
if stream.next().is_some() {
character
} else {
ch
}
}
#[rhai_fn(name = "make_upper")]
pub fn make_upper_char(character: &mut char) {
*character = to_upper_char(*character)
}
#[rhai_fn(name = "to_lower")]
pub fn to_lower_char(character: char) -> char {
let mut stream = character.to_lowercase();
let ch = stream
.next()
.expect("never fails because there should be at least one character");
if stream.next().is_some() {
character
} else {
ch
}
}
#[rhai_fn(name = "make_lower")]
pub fn make_lower_char(character: &mut char) {
*character = to_lower_char(*character)
}
#[rhai_fn(name = "index_of")]
pub fn index_of_char_starting_from(string: &str, character: char, start: INT) -> INT {
let start = if start < 0 {

2
src/parse.rs
View File

@ -318,7 +318,7 @@ fn parse_var_name(input: &mut TokenStream) -> Result<(String, Position), ParseEr
}
}
/// Parse ( expr )
/// Parse `(` expr `)`
fn parse_paren_expr(
input: &mut TokenStream,
state: &mut ParseState,

3
src/plugin.rs
View File

@ -1,6 +1,7 @@
//! Module defining macros for developing _plugins_.
pub use crate::fn_native::{CallableFunction, FnCallArgs};
use crate::fn_call::FnCallArgs;
pub use crate::fn_native::CallableFunction;
pub use crate::{
Dynamic, Engine, EvalAltResult, FnAccess, FnNamespace, ImmutableString, Module,
NativeCallContext, Position,

1
src/scope.rs
View File

@ -122,7 +122,6 @@ impl<'a> Scope<'a> {
/// assert!(my_scope.is_empty());
/// ```
#[inline(always)]
#[must_use]
pub fn clear(&mut self) -> &mut Self {
self.names.clear();
self.values.clear();

4
src/serde/serialize.rs
View File

@ -31,7 +31,7 @@ impl Serialize for Dynamic {
#[cfg(feature = "decimal")]
#[cfg(not(feature = "f32_float"))]
Union::Decimal(x, _, _) => {
Union::Decimal(ref x, _, _) => {
use rust_decimal::prelude::ToPrimitive;
if let Some(v) = x.to_f64() {
@ -42,7 +42,7 @@ impl Serialize for Dynamic {
}
#[cfg(feature = "decimal")]
#[cfg(feature = "f32_float")]
Union::Decimal(x, _, _) => {
Union::Decimal(ref x, _, _) => {
use rust_decimal::prelude::ToPrimitive;
if let Some(v) = x.to_f32() {