467 lines
14 KiB
Rust
467 lines
14 KiB
Rust
#![cfg(not(feature = "no_custom_syntax"))]
|
|
|
|
use rhai::{
|
|
Dynamic, Engine, EvalAltResult, ImmutableString, LexError, ParseErrorType, Position, Scope, INT,
|
|
};
|
|
|
|
#[test]
|
|
fn test_custom_syntax() -> Result<(), Box<EvalAltResult>> {
|
|
let mut engine = Engine::new();
|
|
|
|
engine.run("while false {}")?;
|
|
|
|
// Disable 'while' and make sure it still works with custom syntax
|
|
engine.disable_symbol("while");
|
|
assert!(matches!(
|
|
engine.compile("while false {}").unwrap_err().err_type(),
|
|
ParseErrorType::Reserved(err) if err == "while"
|
|
));
|
|
assert!(matches!(
|
|
engine.compile("let while = 0").unwrap_err().err_type(),
|
|
ParseErrorType::Reserved(err) if err == "while"
|
|
));
|
|
|
|
// Implement ternary operator
|
|
engine.register_custom_syntax(
|
|
["iff", "$expr$", "?", "$expr$", ":", "$expr$"],
|
|
false,
|
|
|context, inputs| match context.eval_expression_tree(&inputs[0])?.as_bool() {
|
|
Ok(true) => context.eval_expression_tree(&inputs[1]),
|
|
Ok(false) => context.eval_expression_tree(&inputs[2]),
|
|
Err(typ) => Err(Box::new(EvalAltResult::ErrorMismatchDataType(
|
|
"bool".to_string(),
|
|
typ.to_string(),
|
|
inputs[0].position(),
|
|
))),
|
|
},
|
|
)?;
|
|
|
|
assert_eq!(
|
|
engine.eval::<INT>(
|
|
"
|
|
let x = 42;
|
|
let y = iff x > 40 ? 0 : 123;
|
|
y
|
|
"
|
|
)?,
|
|
0
|
|
);
|
|
|
|
assert_eq!(
|
|
engine.eval::<INT>(
|
|
"
|
|
let x = 42;
|
|
let y = iff x == 0 ? 0 : 123;
|
|
y
|
|
"
|
|
)?,
|
|
123
|
|
);
|
|
|
|
// Custom syntax
|
|
engine.register_custom_syntax(
|
|
[
|
|
"exec", "[", "$ident$", "$symbol$", "$int$", "]", "->", "$block$", "while", "$expr$",
|
|
],
|
|
true,
|
|
|context, inputs| {
|
|
let var_name = inputs[0].get_string_value().unwrap();
|
|
let op = inputs[1].get_literal_value::<ImmutableString>().unwrap();
|
|
let max = inputs[2].get_literal_value::<INT>().unwrap();
|
|
let stmt = &inputs[3];
|
|
let condition = &inputs[4];
|
|
|
|
context.scope_mut().push(var_name.to_string(), 0 as INT);
|
|
|
|
let mut count: INT = 0;
|
|
|
|
loop {
|
|
let done = match op.as_str() {
|
|
"<" => count >= max,
|
|
"<=" => count > max,
|
|
">" => count <= max,
|
|
">=" => count < max,
|
|
"==" => count != max,
|
|
"!=" => count == max,
|
|
_ => return Err(format!("Unsupported operator: {op}").into()),
|
|
};
|
|
|
|
if done {
|
|
break;
|
|
}
|
|
|
|
// Do not rewind if the variable is upper-case
|
|
let _: Dynamic = if var_name.to_uppercase() == var_name {
|
|
#[allow(deprecated)] // not deprecated but unstable
|
|
context.eval_expression_tree_raw(stmt, false)
|
|
} else {
|
|
context.eval_expression_tree(stmt)
|
|
}?;
|
|
|
|
count += 1;
|
|
|
|
context
|
|
.scope_mut()
|
|
.push(format!("{var_name}{count}"), count);
|
|
|
|
let stop = !context
|
|
.eval_expression_tree(condition)?
|
|
.as_bool()
|
|
.map_err(|err| {
|
|
Box::new(EvalAltResult::ErrorMismatchDataType(
|
|
"bool".to_string(),
|
|
err.to_string(),
|
|
condition.position(),
|
|
))
|
|
})?;
|
|
|
|
if stop {
|
|
break;
|
|
}
|
|
}
|
|
|
|
Ok(count.into())
|
|
},
|
|
)?;
|
|
|
|
assert!(matches!(
|
|
*engine
|
|
.run("let foo = (exec [x<<15] -> { x += 2 } while x < 42) * 10;")
|
|
.unwrap_err(),
|
|
EvalAltResult::ErrorRuntime(..)
|
|
));
|
|
|
|
assert_eq!(
|
|
engine.eval::<INT>(
|
|
"
|
|
let x = 0;
|
|
let foo = (exec [x<15] -> { x += 2 } while x < 42) * 10;
|
|
foo
|
|
"
|
|
)?,
|
|
150
|
|
);
|
|
assert_eq!(
|
|
engine.eval::<INT>(
|
|
"
|
|
let x = 0;
|
|
exec [x<100] -> { x += 1 } while x < 42;
|
|
x
|
|
"
|
|
)?,
|
|
42
|
|
);
|
|
assert_eq!(
|
|
engine.eval::<INT>(
|
|
"
|
|
exec [x<100] -> { x += 1 } while x < 42;
|
|
x
|
|
"
|
|
)?,
|
|
42
|
|
);
|
|
assert_eq!(
|
|
engine.eval::<INT>(
|
|
"
|
|
let foo = 123;
|
|
exec [x<15] -> { x += 1 } while x < 42;
|
|
foo + x + x1 + x2 + x3
|
|
"
|
|
)?,
|
|
144
|
|
);
|
|
assert_eq!(
|
|
engine.eval::<INT>(
|
|
"
|
|
let foo = 123;
|
|
exec [x<15] -> { let foo = x; x += 1; } while x < 42;
|
|
foo
|
|
"
|
|
)?,
|
|
123
|
|
);
|
|
assert_eq!(
|
|
engine.eval::<INT>(
|
|
"
|
|
let foo = 123;
|
|
exec [ABC<15] -> { let foo = ABC; ABC += 1; } while ABC < 42;
|
|
foo
|
|
"
|
|
)?,
|
|
14
|
|
);
|
|
|
|
// The first symbol must be an identifier
|
|
assert_eq!(
|
|
*engine
|
|
.register_custom_syntax(["!"], false, |_, _| Ok(Dynamic::UNIT))
|
|
.unwrap_err()
|
|
.err_type(),
|
|
ParseErrorType::BadInput(LexError::ImproperSymbol(
|
|
"!".to_string(),
|
|
"Improper symbol for custom syntax at position #1: '!'".to_string()
|
|
))
|
|
);
|
|
|
|
// Check self-termination
|
|
engine
|
|
.register_custom_syntax(["test1", "$block$"], true, |_, _| Ok(Dynamic::UNIT))?
|
|
.register_custom_syntax(["test2", "}"], true, |_, _| Ok(Dynamic::UNIT))?
|
|
.register_custom_syntax(["test3", ";"], true, |_, _| Ok(Dynamic::UNIT))?;
|
|
|
|
assert_eq!(engine.eval::<INT>("test1 { x = y + z; } 42")?, 42);
|
|
assert_eq!(engine.eval::<INT>("test2 } 42")?, 42);
|
|
assert_eq!(engine.eval::<INT>("test3; 42")?, 42);
|
|
|
|
// Register the custom syntax: var x = ???
|
|
engine.register_custom_syntax(
|
|
["var", "$ident$", "=", "$expr$"],
|
|
true,
|
|
|context, inputs| {
|
|
let var_name = inputs[0].get_string_value().unwrap();
|
|
let expr = &inputs[1];
|
|
|
|
// Evaluate the expression
|
|
let value = context.eval_expression_tree(expr)?;
|
|
|
|
if !context.scope().is_constant(var_name).unwrap_or(false) {
|
|
context.scope_mut().set_value(var_name.to_string(), value);
|
|
Ok(Dynamic::UNIT)
|
|
} else {
|
|
Err(format!("variable {var_name} is constant").into())
|
|
}
|
|
},
|
|
)?;
|
|
|
|
let mut scope = Scope::new();
|
|
|
|
assert_eq!(
|
|
engine.eval_with_scope::<INT>(&mut scope, "var foo = 42; foo")?,
|
|
42
|
|
);
|
|
assert_eq!(scope.get_value::<INT>("foo"), Some(42));
|
|
assert_eq!(scope.len(), 1);
|
|
assert_eq!(
|
|
engine.eval_with_scope::<INT>(&mut scope, "var foo = 123; foo")?,
|
|
123
|
|
);
|
|
assert_eq!(scope.get_value::<INT>("foo"), Some(123));
|
|
assert_eq!(scope.len(), 1);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn test_custom_syntax_scope() -> Result<(), Box<EvalAltResult>> {
|
|
let mut engine = Engine::new();
|
|
|
|
engine.register_custom_syntax(
|
|
[
|
|
"with", "offset", "(", "$expr$", ",", "$expr$", ")", "$block$",
|
|
],
|
|
true,
|
|
|context, inputs| {
|
|
let x = context
|
|
.eval_expression_tree(&inputs[0])?
|
|
.as_int()
|
|
.map_err(|typ| {
|
|
Box::new(EvalAltResult::ErrorMismatchDataType(
|
|
"integer".to_string(),
|
|
typ.to_string(),
|
|
inputs[0].position(),
|
|
))
|
|
})?;
|
|
|
|
let y = context
|
|
.eval_expression_tree(&inputs[1])?
|
|
.as_int()
|
|
.map_err(|typ| {
|
|
Box::new(EvalAltResult::ErrorMismatchDataType(
|
|
"integer".to_string(),
|
|
typ.to_string(),
|
|
inputs[1].position(),
|
|
))
|
|
})?;
|
|
|
|
let orig_len = context.scope().len();
|
|
|
|
context.scope_mut().push_constant("x", x);
|
|
context.scope_mut().push_constant("y", y);
|
|
|
|
let result = context.eval_expression_tree(&inputs[2]);
|
|
|
|
context.scope_mut().rewind(orig_len);
|
|
|
|
result
|
|
},
|
|
)?;
|
|
|
|
assert_eq!(
|
|
engine.eval::<INT>(
|
|
"
|
|
let y = 1;
|
|
let x = 0;
|
|
with offset(44, 2) { x - y }
|
|
"
|
|
)?,
|
|
42
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn test_custom_syntax_matrix() -> Result<(), Box<EvalAltResult>> {
|
|
let mut engine = Engine::new();
|
|
|
|
engine.disable_symbol("|");
|
|
|
|
engine.register_custom_syntax(
|
|
[
|
|
"@", //
|
|
"|", "$expr$", "$expr$", "$expr$", "|", //
|
|
"|", "$expr$", "$expr$", "$expr$", "|", //
|
|
"|", "$expr$", "$expr$", "$expr$", "|",
|
|
],
|
|
false,
|
|
|context, inputs| {
|
|
let mut values = [[0; 3]; 3];
|
|
|
|
for y in 0..3 {
|
|
for x in 0..3 {
|
|
let offset = y * 3 + x;
|
|
|
|
match context.eval_expression_tree(&inputs[offset])?.as_int() {
|
|
Ok(v) => values[y][x] = v,
|
|
Err(typ) => {
|
|
return Err(Box::new(EvalAltResult::ErrorMismatchDataType(
|
|
"integer".to_string(),
|
|
typ.to_string(),
|
|
inputs[offset].position(),
|
|
)))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(Dynamic::from(values))
|
|
},
|
|
)?;
|
|
|
|
let r = engine.eval::<[[INT; 3]; 3]>(
|
|
"
|
|
let a = 42;
|
|
let b = 123;
|
|
let c = 1;
|
|
let d = 99;
|
|
|
|
@| a b 0 |
|
|
| -b a 0 |
|
|
| 0 0 c*d |
|
|
",
|
|
)?;
|
|
|
|
assert_eq!(r, [[42, 123, 0], [-123, 42, 0], [0, 0, 99]]);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn test_custom_syntax_raw() -> Result<(), Box<EvalAltResult>> {
|
|
let mut engine = Engine::new();
|
|
|
|
engine.register_custom_syntax_with_state_raw(
|
|
"hello",
|
|
|stream, look_ahead, state| match stream.len() {
|
|
0 => unreachable!(),
|
|
1 if look_ahead == "\"world\"" => {
|
|
*state = Dynamic::TRUE;
|
|
Ok(Some("$string$".into()))
|
|
}
|
|
1 => {
|
|
*state = Dynamic::FALSE;
|
|
Ok(Some("$ident$".into()))
|
|
}
|
|
2 => {
|
|
match stream[1].as_str() {
|
|
"world" if state.as_bool().unwrap_or(false) => Ok(Some("$$world".into())),
|
|
"world" => Ok(Some("$$hello".into())),
|
|
"kitty" => {
|
|
*state = (42 as INT).into();
|
|
Ok(None)
|
|
}
|
|
s => Err(LexError::ImproperSymbol(s.to_string(), String::new())
|
|
.into_err(Position::NONE)),
|
|
}
|
|
}
|
|
_ => unreachable!(),
|
|
},
|
|
true,
|
|
|context, inputs, state| {
|
|
context.scope_mut().push("foo", 999 as INT);
|
|
|
|
Ok(match inputs[0].get_string_value().unwrap() {
|
|
"world" => match inputs.last().unwrap().get_string_value().unwrap_or("") {
|
|
"$$hello" => 0 as INT,
|
|
"$$world" => 123456 as INT,
|
|
_ => 123 as INT,
|
|
},
|
|
"kitty" if inputs.len() > 1 => 999 as INT,
|
|
"kitty" => state.as_int().unwrap(),
|
|
_ => unreachable!(),
|
|
}
|
|
.into())
|
|
},
|
|
);
|
|
|
|
assert_eq!(engine.eval::<INT>(r#"hello "world""#)?, 123456);
|
|
assert_eq!(engine.eval::<INT>("hello world")?, 0);
|
|
assert_eq!(engine.eval::<INT>("hello kitty")?, 42);
|
|
assert_eq!(
|
|
engine.eval::<INT>("let foo = 0; (hello kitty) + foo")?,
|
|
1041
|
|
);
|
|
assert_eq!(engine.eval::<INT>("(hello kitty) + foo")?, 1041);
|
|
assert_eq!(
|
|
*engine.compile("hello hey").unwrap_err().err_type(),
|
|
ParseErrorType::BadInput(LexError::ImproperSymbol("hey".to_string(), String::new()))
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn test_custom_syntax_raw2() -> Result<(), Box<EvalAltResult>> {
|
|
let mut engine = Engine::new();
|
|
|
|
engine.register_custom_syntax_with_state_raw(
|
|
"#",
|
|
|symbols, lookahead, _| match symbols.len() {
|
|
1 if lookahead == "-" => Ok(Some("$symbol$".into())),
|
|
1 => Ok(Some("$int$".into())),
|
|
2 if symbols[1] == "-" => Ok(Some("$int$".into())),
|
|
2 => Ok(None),
|
|
3 => Ok(None),
|
|
_ => unreachable!(),
|
|
},
|
|
false,
|
|
move |_, inputs, _| {
|
|
let id = if inputs.len() == 2 {
|
|
-inputs[1].get_literal_value::<INT>().unwrap()
|
|
} else {
|
|
inputs[0].get_literal_value::<INT>().unwrap()
|
|
};
|
|
Ok(id.into())
|
|
},
|
|
);
|
|
|
|
assert_eq!(engine.eval::<INT>("#-1")?, -1);
|
|
assert_eq!(engine.eval::<INT>("let x = 41; x + #1")?, 42);
|
|
#[cfg(not(feature = "no_object"))]
|
|
assert_eq!(engine.eval::<INT>("#-42.abs()")?, 42);
|
|
assert_eq!(engine.eval::<INT>("#42/2")?, 21);
|
|
assert_eq!(engine.eval::<INT>("sign(#1)")?, 1);
|
|
|
|
Ok(())
|
|
}
|