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

Move to using i64 by default

Browse Source
This commit is contained in:
jonathandturner 2016-04-12 19:52:27 -07:00
parent be3d360913
commit 3dfc6e627d
3 changed files with 75 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/rhai_runner.rs
View File

@ -23,7 +23,7 @@ fn main() {
match engine.eval_file::<()>(&fname) { match engine.eval_file::<()>(&fname) {
Ok(_) => (), Ok(_) => (),
Err(e) => {println!("Error: {:?}", e)} Err(e) => {println!("Error: {}", e)}
} }
} }
} }

142
src/engine.rs
View File

@ -22,7 +22,7 @@ pub enum EvalAltResult {
ErrorAssignmentToUnknownLHS, ErrorAssignmentToUnknownLHS,
ErrorMismatchOutputType, ErrorMismatchOutputType,
ErrorCantOpenScriptFile, ErrorCantOpenScriptFile,
InternalErrorMalformedDotExpression, InternalErrorMalformedDotExpression,
LoopBreak, LoopBreak,
Return(Box<Any>) Return(Box<Any>)
} }
@ -330,21 +330,21 @@ impl Engine {
self.register_fn("clone", clone_helper as fn(T)->T); self.register_fn("clone", clone_helper as fn(T)->T);
} }
pub fn register_get<T: Clone+Any, U: Clone+Any, F>(&mut self, name: &str, get_fn: F) pub fn register_get<T: Clone+Any, U: Clone+Any, F>(&mut self, name: &str, get_fn: F)
where F : 'static+Fn(&mut T)->U { where F : 'static+Fn(&mut T)->U {
let get_name = "get$".to_string() + name; let get_name = "get$".to_string() + name;
self.register_fn(&get_name, get_fn); self.register_fn(&get_name, get_fn);
} }
pub fn register_set<T: Clone+Any, U: Clone+Any, F>(&mut self, name: &str, set_fn: F) pub fn register_set<T: Clone+Any, U: Clone+Any, F>(&mut self, name: &str, set_fn: F)
where F : 'static+Fn(&mut T, U)->() { where F : 'static+Fn(&mut T, U)->() {
let set_name = "set$".to_string() + name; let set_name = "set$".to_string() + name;
self.register_fn(&set_name, set_fn); self.register_fn(&set_name, set_fn);
} }
pub fn register_get_set<T: Clone+Any, U: Clone+Any, F, G>(&mut self, name: &str, get_fn: F, set_fn: G) pub fn register_get_set<T: Clone+Any, U: Clone+Any, F, G>(&mut self, name: &str, get_fn: F, set_fn: G)
where F : 'static+Fn(&mut T)->U, G : 'static+Fn(&mut T, U)->() { where F : 'static+Fn(&mut T)->U, G : 'static+Fn(&mut T, U)->() {
self.register_get(name, get_fn); self.register_get(name, get_fn);
@ -353,7 +353,7 @@ impl Engine {
fn get_dot_val_helper(&self, scope: &mut Scope, this_ptr: &mut Box<Any>, dot_rhs: &Expr) -> Result<Box<Any>, EvalAltResult> { fn get_dot_val_helper(&self, scope: &mut Scope, this_ptr: &mut Box<Any>, dot_rhs: &Expr) -> Result<Box<Any>, EvalAltResult> {
match *dot_rhs { match *dot_rhs {
Expr::FnCall(ref fn_name, ref args) => { Expr::FnCall(ref fn_name, ref args) => {
if args.len() == 0 { if args.len() == 0 {
return self.call_fn(&fn_name, Some(this_ptr), None, None, None, None, None); return self.call_fn(&fn_name, Some(this_ptr), None, None, None, None, None);
} }
@ -381,7 +381,7 @@ impl Engine {
let mut arg3 = try!(self.eval_expr(scope, &args[2])); let mut arg3 = try!(self.eval_expr(scope, &args[2]));
let mut arg4 = try!(self.eval_expr(scope, &args[3])); let mut arg4 = try!(self.eval_expr(scope, &args[3]));
return self.call_fn(&fn_name, Some(this_ptr), Some(&mut arg1), Some(&mut arg2), Some(&mut arg3), return self.call_fn(&fn_name, Some(this_ptr), Some(&mut arg1), Some(&mut arg2), Some(&mut arg3),
Some(&mut arg4), None); Some(&mut arg4), None);
} }
else if args.len() == 5 { else if args.len() == 5 {
@ -391,7 +391,7 @@ impl Engine {
let mut arg4 = try!(self.eval_expr(scope, &args[3])); let mut arg4 = try!(self.eval_expr(scope, &args[3]));
let mut arg5 = try!(self.eval_expr(scope, &args[4])); let mut arg5 = try!(self.eval_expr(scope, &args[4]));
return self.call_fn(&fn_name, Some(this_ptr), Some(&mut arg1), Some(&mut arg2), Some(&mut arg3), return self.call_fn(&fn_name, Some(this_ptr), Some(&mut arg1), Some(&mut arg2), Some(&mut arg3),
Some(&mut arg4), Some(&mut arg5)); Some(&mut arg4), Some(&mut arg5));
} }
else { else {
@ -406,9 +406,9 @@ impl Engine {
let idx = try!(self.eval_expr(scope, idx_raw)); let idx = try!(self.eval_expr(scope, idx_raw));
let get_fn_name = "get$".to_string() + id; let get_fn_name = "get$".to_string() + id;
if let Ok(mut val) = self.call_fn(&get_fn_name, Some(this_ptr), None, None, None, None, None) { if let Ok(mut val) = self.call_fn(&get_fn_name, Some(this_ptr), None, None, None, None, None) {
if let Ok(i) = idx.downcast::<i32>() { if let Ok(i) = idx.downcast::<i64>() {
if let Some(arr_typed) = (*val).downcast_mut() as Option<&mut Vec<Box<Any>>> { if let Some(arr_typed) = (*val).downcast_mut() as Option<&mut Vec<Box<Any>>> {
return self.call_fn("clone", Some(&mut arr_typed[*i as usize]), None, None, None, None, None); return self.call_fn("clone", Some(&mut arr_typed[*i as usize]), None, None, None, None, None);
} }
@ -433,7 +433,7 @@ impl Engine {
match result { match result {
Ok(mut v) => return self.get_dot_val_helper(scope, &mut v, inner_rhs), Ok(mut v) => return self.get_dot_val_helper(scope, &mut v, inner_rhs),
e => return e e => return e
} }
} }
_ => Err(EvalAltResult::InternalErrorMalformedDotExpression) _ => Err(EvalAltResult::InternalErrorMalformedDotExpression)
} }
@ -477,14 +477,14 @@ impl Engine {
} }
Expr::Index(ref id, ref idx_raw) => { Expr::Index(ref id, ref idx_raw) => {
let idx_boxed = try!(self.eval_expr(scope, idx_raw)); let idx_boxed = try!(self.eval_expr(scope, idx_raw));
let idx = if let Ok(i) = idx_boxed.downcast::<i32>() { i } else { return Err(EvalAltResult::ErrorIndexMismatch); }; let idx = if let Ok(i) = idx_boxed.downcast::<i64>() { i } else { return Err(EvalAltResult::ErrorIndexMismatch); };
let mut target : Option<Box<Any>> = None; let mut target : Option<Box<Any>> = None;
for &mut (ref name, ref mut val) in &mut scope.iter_mut().rev() { for &mut (ref name, ref mut val) in &mut scope.iter_mut().rev() {
if *id == *name { if *id == *name {
if let Some(arr_typed) = (*val).downcast_mut() as Option<&mut Vec<Box<Any>>> { if let Some(arr_typed) = (*val).downcast_mut() as Option<&mut Vec<Box<Any>>> {
let result = self.call_fn("clone", Some(&mut arr_typed[*idx as usize]), let result = self.call_fn("clone", Some(&mut arr_typed[*idx as usize]),
None, None, None, None, None); None, None, None, None, None);
if let Ok(clone) = result { if let Ok(clone) = result {
@ -544,14 +544,14 @@ impl Engine {
} }
}, },
e => e e => e
} }
} }
_ => Err(EvalAltResult::InternalErrorMalformedDotExpression) _ => Err(EvalAltResult::InternalErrorMalformedDotExpression)
} }
} }
_ => { _ => {
Err(EvalAltResult::InternalErrorMalformedDotExpression) Err(EvalAltResult::InternalErrorMalformedDotExpression)
} }
} }
} }
@ -589,14 +589,14 @@ impl Engine {
} }
Expr::Index(ref id, ref idx_raw) => { Expr::Index(ref id, ref idx_raw) => {
let idx_boxed = try!(self.eval_expr(scope, idx_raw)); let idx_boxed = try!(self.eval_expr(scope, idx_raw));
let idx = if let Ok(i) = idx_boxed.downcast::<i32>() { i } else { return Err(EvalAltResult::ErrorIndexMismatch); }; let idx = if let Ok(i) = idx_boxed.downcast::<i64>() { i } else { return Err(EvalAltResult::ErrorIndexMismatch); };
let mut target : Option<Box<Any>> = None; let mut target : Option<Box<Any>> = None;
for &mut (ref name, ref mut val) in &mut scope.iter_mut().rev() { for &mut (ref name, ref mut val) in &mut scope.iter_mut().rev() {
if *id == *name { if *id == *name {
if let Some(arr_typed) = (*val).downcast_mut() as Option<&mut Vec<Box<Any>>> { if let Some(arr_typed) = (*val).downcast_mut() as Option<&mut Vec<Box<Any>>> {
let result = self.call_fn("clone", Some(&mut arr_typed[*idx as usize]), let result = self.call_fn("clone", Some(&mut arr_typed[*idx as usize]),
None, None, None, None, None); None, None, None, None, None);
if let Ok(clone) = result { if let Ok(clone) = result {
@ -638,7 +638,7 @@ impl Engine {
Expr::StringConst(ref s) => Ok(Box::new(s.clone())), Expr::StringConst(ref s) => Ok(Box::new(s.clone())),
Expr::Identifier(ref id) => { Expr::Identifier(ref id) => {
for &mut (ref name, ref mut val) in &mut scope.iter_mut().rev() { for &mut (ref name, ref mut val) in &mut scope.iter_mut().rev() {
if *id == *name { if *id == *name {
return self.call_fn("clone", Some(val), None, None, None, None, None); return self.call_fn("clone", Some(val), None, None, None, None, None);
} }
} }
@ -649,7 +649,7 @@ impl Engine {
for &mut (ref name, ref mut val) in &mut scope.iter_mut().rev() { for &mut (ref name, ref mut val) in &mut scope.iter_mut().rev() {
if *id == *name { if *id == *name {
if let Ok(i) = idx.downcast::<i32>() { if let Ok(i) = idx.downcast::<i64>() {
if let Some(arr_typed) = (*val).downcast_mut() as Option<&mut Vec<Box<Any>>> { if let Some(arr_typed) = (*val).downcast_mut() as Option<&mut Vec<Box<Any>>> {
return self.call_fn("clone", Some(&mut arr_typed[*i as usize]), None, None, None, None, None); return self.call_fn("clone", Some(&mut arr_typed[*i as usize]), None, None, None, None, None);
} }
@ -685,7 +685,7 @@ impl Engine {
for &mut (ref name, ref mut val) in &mut scope.iter_mut().rev() { for &mut (ref name, ref mut val) in &mut scope.iter_mut().rev() {
if *id == *name { if *id == *name {
if let Ok(i) = idx.downcast::<i32>() { if let Ok(i) = idx.downcast::<i64>() {
if let Some(arr_typed) = (*val).downcast_mut() as Option<&mut Vec<Box<Any>>> { if let Some(arr_typed) = (*val).downcast_mut() as Option<&mut Vec<Box<Any>>> {
arr_typed[*i as usize] = rhs_val; arr_typed[*i as usize] = rhs_val;
return Ok(Box::new(())); return Ok(Box::new(()));
@ -700,7 +700,7 @@ impl Engine {
} }
} }
Err(EvalAltResult::ErrorVariableNotFound(id.clone())) Err(EvalAltResult::ErrorVariableNotFound(id.clone()))
} }
Expr::Dot(ref dot_lhs, ref dot_rhs) => { Expr::Dot(ref dot_lhs, ref dot_rhs) => {
self.set_dot_val(scope, dot_lhs, dot_rhs, rhs_val) self.set_dot_val(scope, dot_lhs, dot_rhs, rhs_val)
@ -758,7 +758,7 @@ impl Engine {
let mut arg4 = try!(self.eval_expr(scope, &args[3])); let mut arg4 = try!(self.eval_expr(scope, &args[3]));
let mut arg5 = try!(self.eval_expr(scope, &args[4])); let mut arg5 = try!(self.eval_expr(scope, &args[4]));
self.call_fn(&fn_name, Some(&mut arg1), Some(&mut arg2), Some(&mut arg3), Some(&mut arg4), self.call_fn(&fn_name, Some(&mut arg1), Some(&mut arg2), Some(&mut arg3), Some(&mut arg4),
Some(&mut arg5), None) Some(&mut arg5), None)
} }
else if args.len() == 6 { else if args.len() == 6 {
@ -769,7 +769,7 @@ impl Engine {
let mut arg5 = try!(self.eval_expr(scope, &args[4])); let mut arg5 = try!(self.eval_expr(scope, &args[4]));
let mut arg6 = try!(self.eval_expr(scope, &args[5])); let mut arg6 = try!(self.eval_expr(scope, &args[5]));
self.call_fn(&fn_name, Some(&mut arg1), Some(&mut arg2), Some(&mut arg3), Some(&mut arg4), self.call_fn(&fn_name, Some(&mut arg1), Some(&mut arg2), Some(&mut arg3), Some(&mut arg4),
Some(&mut arg5), Some(&mut arg6)) Some(&mut arg5), Some(&mut arg6))
} }
else { else {
@ -781,7 +781,7 @@ impl Engine {
} }
Expr::False => { Expr::False => {
Ok(Box::new(false)) Ok(Box::new(false))
} }
} }
} }
@ -853,7 +853,7 @@ impl Engine {
} }
} }
Err(_) => return Err(EvalAltResult::ErrorIfGuardMismatch) Err(_) => return Err(EvalAltResult::ErrorIfGuardMismatch)
} }
} }
} }
Stmt::Break => return Err(EvalAltResult::LoopBreak), Stmt::Break => return Err(EvalAltResult::LoopBreak),
@ -865,7 +865,7 @@ impl Engine {
Stmt::Var(ref name, ref init) => { Stmt::Var(ref name, ref init) => {
match init { match init {
& Some(ref v) => { & Some(ref v) => {
let i = try!(self.eval_expr(scope, v)); let i = try!(self.eval_expr(scope, v));
scope.push((name.clone(), i)); scope.push((name.clone(), i));
}, },
& None => { & None => {
@ -883,17 +883,17 @@ impl Engine {
if let Ok(mut f) = File::open(fname.clone()) { if let Ok(mut f) = File::open(fname.clone()) {
let mut contents = String::new(); let mut contents = String::new();
if let Ok(_) = f.read_to_string(&mut contents) { if let Ok(_) = f.read_to_string(&mut contents) {
self.eval::<T>(&contents) self.eval::<T>(&contents)
} }
else { else {
Err(EvalAltResult::ErrorCantOpenScriptFile) Err(EvalAltResult::ErrorCantOpenScriptFile)
} }
} }
else { else {
Err(EvalAltResult::ErrorCantOpenScriptFile) Err(EvalAltResult::ErrorCantOpenScriptFile)
} }
} }
pub fn eval<T:Any+Clone>(&mut self, input: &str) -> Result<T, EvalAltResult> { pub fn eval<T:Any+Clone>(&mut self, input: &str) -> Result<T, EvalAltResult> {
@ -911,7 +911,7 @@ impl Engine {
match tree { match tree {
Ok((ref os, ref fns)) => { Ok((ref os, ref fns)) => {
let mut x: Result<Box<Any>, EvalAltResult> = Ok(Box::new(())); let mut x: Result<Box<Any>, EvalAltResult> = Ok(Box::new(()));
for f in fns { for f in fns {
if f.params.len() > 6 { if f.params.len() > 6 {
return Err(EvalAltResult::ErrorFunctionArityNotSupported); return Err(EvalAltResult::ErrorFunctionArityNotSupported);
@ -919,7 +919,7 @@ impl Engine {
let name = f.name.clone(); let name = f.name.clone();
let local_f = f.clone(); let local_f = f.clone();
let ent = self.fns.entry(name).or_insert(Vec::new()); let ent = self.fns.entry(name).or_insert(Vec::new());
(*ent).push(FnType::InternalFn(local_f)); (*ent).push(FnType::InternalFn(local_f));
} }
for o in os { for o in os {
@ -961,7 +961,7 @@ impl Engine {
)* )*
) )
} }
macro_rules! reg_cmp { macro_rules! reg_cmp {
($engine:expr, $x:expr, $op:expr, $( $y:ty ),*) => ( ($engine:expr, $x:expr, $op:expr, $( $y:ty ),*) => (
$( $(
@ -1006,7 +1006,7 @@ impl Engine {
} }
pub fn new() -> Engine { pub fn new() -> Engine {
let mut engine = Engine { let mut engine = Engine {
fns: HashMap::new() fns: HashMap::new()
}; };
@ -1021,7 +1021,7 @@ impl Engine {
fn test_number_literal() { fn test_number_literal() {
let mut engine = Engine::new(); let mut engine = Engine::new();
if let Ok(result) = engine.eval::<i32>("65") { if let Ok(result) = engine.eval::<i64>("65") {
assert_eq!(result, 65); assert_eq!(result, 65);
} }
else { else {
@ -1033,26 +1033,26 @@ fn test_number_literal() {
fn test_ops() { fn test_ops() {
let mut engine = Engine::new(); let mut engine = Engine::new();
if let Ok(result) = engine.eval::<i32>("60 + 5") { if let Ok(result) = engine.eval::<i64>("60 + 5") {
assert_eq!(result, 65); assert_eq!(result, 65);
} }
else { else {
assert!(false); assert!(false);
} }
if let Ok(result) = engine.eval::<i32>("(1 + 2) * (6 - 4) / 2") { if let Ok(result) = engine.eval::<i64>("(1 + 2) * (6 - 4) / 2") {
assert_eq!(result, 3); assert_eq!(result, 3);
} }
else { else {
assert!(false); assert!(false);
} }
} }
#[test] #[test]
fn test_mismatched_op() { fn test_mismatched_op() {
let mut engine = Engine::new(); let mut engine = Engine::new();
match engine.eval::<i32>("60 + \"hello\"") { match engine.eval::<i64>("60 + \"hello\"") {
Err(EvalAltResult::ErrorFunctionArgMismatch) => (), Err(EvalAltResult::ErrorFunctionArgMismatch) => (),
_ => assert!(false) _ => assert!(false)
} }
@ -1086,7 +1086,7 @@ fn test_bool_op2() {
fn test_op_prec() { fn test_op_prec() {
let mut engine = Engine::new(); let mut engine = Engine::new();
if let Ok(result) = engine.eval::<i32>("var x = 0; if x == 10 || true { x = 1} x") { if let Ok(result) = engine.eval::<i64>("var x = 0; if x == 10 || true { x = 1} x") {
assert_eq!(result, 1); assert_eq!(result, 1);
} }
else { else {
@ -1098,21 +1098,21 @@ fn test_op_prec() {
fn test_if() { fn test_if() {
let mut engine = Engine::new(); let mut engine = Engine::new();
if let Ok(result) = engine.eval::<i32>("if true { 55 }") { if let Ok(result) = engine.eval::<i64>("if true { 55 }") {
assert_eq!(result, 55); assert_eq!(result, 55);
} }
else { else {
assert!(false); assert!(false);
} }
if let Ok(result) = engine.eval::<i32>("if false { 55 } else { 44 }") { if let Ok(result) = engine.eval::<i64>("if false { 55 } else { 44 }") {
assert_eq!(result, 44); assert_eq!(result, 44);
} }
else { else {
assert!(false); assert!(false);
} }
if let Ok(result) = engine.eval::<i32>("if true { 55 } else { 44 }") { if let Ok(result) = engine.eval::<i64>("if true { 55 } else { 44 }") {
assert_eq!(result, 55); assert_eq!(result, 55);
} }
else { else {
@ -1124,7 +1124,7 @@ fn test_if() {
fn test_while() { fn test_while() {
let mut engine = Engine::new(); let mut engine = Engine::new();
if let Ok(result) = engine.eval::<i32>("var x = 0; while x < 10 { x = x + 1; if x > 5 { break } } x") { if let Ok(result) = engine.eval::<i64>("var x = 0; while x < 10 { x = x + 1; if x > 5 { break } } x") {
assert_eq!(result, 6); assert_eq!(result, 6);
} }
else { else {
@ -1137,18 +1137,18 @@ fn test_var_scope() {
let mut engine = Engine::new(); let mut engine = Engine::new();
let mut scope: Scope = Vec::new(); let mut scope: Scope = Vec::new();
if let Ok(_) = engine.eval_with_scope::<()>(&mut scope, "var x = 4 + 5") { } else { assert!(false); } if let Ok(_) = engine.eval_with_scope::<()>(&mut scope, "var x = 4 + 5") { } else { assert!(false); }
if let Ok(result) = engine.eval_with_scope::<i32>(&mut scope, "x") { if let Ok(result) = engine.eval_with_scope::<i64>(&mut scope, "x") {
assert_eq!(result, 9); assert_eq!(result, 9);
} }
else { else {
assert!(false); assert!(false);
} }
if let Ok(_) = engine.eval_with_scope::<()>(&mut scope, "x = x + 1; x = x + 2;") { } else { assert!(false); } if let Ok(_) = engine.eval_with_scope::<()>(&mut scope, "x = x + 1; x = x + 2;") { } else { assert!(false); }
if let Ok(result) = engine.eval_with_scope::<i32>(&mut scope, "x") { if let Ok(result) = engine.eval_with_scope::<i64>(&mut scope, "x") {
assert_eq!(result, 12); assert_eq!(result, 12);
} }
else { else {
@ -1157,7 +1157,7 @@ fn test_var_scope() {
if let Ok(_) = engine.eval_with_scope::<()>(&mut scope, "{var x = 3}") { } else { assert!(false); } if let Ok(_) = engine.eval_with_scope::<()>(&mut scope, "{var x = 3}") { } else { assert!(false); }
if let Ok(result) = engine.eval_with_scope::<i32>(&mut scope, "x") { if let Ok(result) = engine.eval_with_scope::<i64>(&mut scope, "x") {
assert_eq!(result, 12); assert_eq!(result, 12);
} }
else { else {
@ -1169,7 +1169,7 @@ fn test_var_scope() {
fn test_method_call() { fn test_method_call() {
#[derive(Clone)] #[derive(Clone)]
struct TestStruct { struct TestStruct {
x: i32 x: i64
} }
impl TestStruct { impl TestStruct {
@ -1202,15 +1202,15 @@ fn test_method_call() {
fn test_get_set() { fn test_get_set() {
#[derive(Clone)] #[derive(Clone)]
struct TestStruct { struct TestStruct {
x: i32 x: i64
} }
impl TestStruct { impl TestStruct {
fn get_x(&mut self) -> i32 { fn get_x(&mut self) -> i64 {
self.x self.x
} }
fn set_x(&mut self, new_x: i32) { fn set_x(&mut self, new_x: i64) {
self.x = new_x; self.x = new_x;
} }
@ -1226,7 +1226,7 @@ fn test_get_set() {
engine.register_get_set("x", TestStruct::get_x, TestStruct::set_x); engine.register_get_set("x", TestStruct::get_x, TestStruct::set_x);
engine.register_fn("new_ts", TestStruct::new); engine.register_fn("new_ts", TestStruct::new);
if let Ok(result) = engine.eval::<i32>("var a = new_ts(); a.x = 500; a.x") { if let Ok(result) = engine.eval::<i64>("var a = new_ts(); a.x = 500; a.x") {
assert_eq!(result, 500); assert_eq!(result, 500);
} }
else { else {
@ -1238,15 +1238,15 @@ fn test_get_set() {
fn test_big_get_set() { fn test_big_get_set() {
#[derive(Clone)] #[derive(Clone)]
struct TestChild { struct TestChild {
x: i32 x: i64
} }
impl TestChild { impl TestChild {
fn get_x(&mut self) -> i32 { fn get_x(&mut self) -> i64 {
self.x self.x
} }
fn set_x(&mut self, new_x: i32) { fn set_x(&mut self, new_x: i64) {
self.x = new_x; self.x = new_x;
} }
@ -1285,7 +1285,7 @@ fn test_big_get_set() {
engine.register_fn("new_tp", TestParent::new); engine.register_fn("new_tp", TestParent::new);
if let Ok(result) = engine.eval::<i32>("var a = new_tp(); a.child.x = 500; a.child.x") { if let Ok(result) = engine.eval::<i64>("var a = new_tp(); a.child.x = 500; a.child.x") {
assert_eq!(result, 500); assert_eq!(result, 500);
} }
else { else {
@ -1297,14 +1297,14 @@ fn test_big_get_set() {
fn test_internal_fn() { fn test_internal_fn() {
let mut engine = Engine::new(); let mut engine = Engine::new();
if let Ok(result) = engine.eval::<i32>("fn addme(a, b) { a+b } addme(3, 4)") { if let Ok(result) = engine.eval::<i64>("fn addme(a, b) { a+b } addme(3, 4)") {
assert_eq!(result, 7); assert_eq!(result, 7);
} }
else { else {
assert!(false); assert!(false);
} }
if let Ok(result) = engine.eval::<i32>("fn bob() { return 4; 5 } bob()") { if let Ok(result) = engine.eval::<i64>("fn bob() { return 4; 5 } bob()") {
assert_eq!(result, 4); assert_eq!(result, 4);
} }
else { else {
@ -1316,7 +1316,7 @@ fn test_internal_fn() {
fn test_big_internal_fn() { fn test_big_internal_fn() {
let mut engine = Engine::new(); let mut engine = Engine::new();
if let Ok(result) = engine.eval::<i32>("fn mathme(a, b, c, d, e, f) { a - b * c + d * e - f } mathme(100, 5, 2, 9, 6, 32)") { if let Ok(result) = engine.eval::<i64>("fn mathme(a, b, c, d, e, f) { a - b * c + d * e - f } mathme(100, 5, 2, 9, 6, 32)") {
assert_eq!(result, 112); assert_eq!(result, 112);
} }
else { else {
@ -1340,14 +1340,14 @@ fn test_string() {
fn test_arrays() { fn test_arrays() {
let mut engine = Engine::new(); let mut engine = Engine::new();
if let Ok(result) = engine.eval::<i32>("var x = [1, 2, 3]; x[1]") { if let Ok(result) = engine.eval::<i64>("var x = [1, 2, 3]; x[1]") {
assert_eq!(result, 2); assert_eq!(result, 2);
} }
else { else {
assert!(false); assert!(false);
} }
if let Ok(result) = engine.eval::<i32>("var y = [1, 2, 3]; y[1] = 5; y[1]") { if let Ok(result) = engine.eval::<i64>("var y = [1, 2, 3]; y[1] = 5; y[1]") {
assert_eq!(result, 5); assert_eq!(result, 5);
} }
else { else {
@ -1359,7 +1359,7 @@ fn test_arrays() {
fn test_array_with_structs() { fn test_array_with_structs() {
#[derive(Clone)] #[derive(Clone)]
struct TestStruct { struct TestStruct {
x: i32 x: i64
} }
impl TestStruct { impl TestStruct {
@ -1367,11 +1367,11 @@ fn test_array_with_structs() {
self.x += 1000; self.x += 1000;
} }
fn get_x(&mut self) -> i32 { fn get_x(&mut self) -> i64 {
self.x self.x
} }
fn set_x(&mut self, new_x: i32) { fn set_x(&mut self, new_x: i64) {
self.x = new_x; self.x = new_x;
} }
@ -1388,14 +1388,14 @@ fn test_array_with_structs() {
engine.register_fn("update", TestStruct::update); engine.register_fn("update", TestStruct::update);
engine.register_fn("new_ts", TestStruct::new); engine.register_fn("new_ts", TestStruct::new);
if let Ok(result) = engine.eval::<i32>("var a = [new_ts()]; a[0].x") { if let Ok(result) = engine.eval::<i64>("var a = [new_ts()]; a[0].x") {
assert_eq!(result, 1); assert_eq!(result, 1);
} }
else { else {
assert!(false); assert!(false);
} }
if let Ok(result) = engine.eval::<i32>("var a = [new_ts()]; a[0].x = 100; a[0].update(); a[0].x") { if let Ok(result) = engine.eval::<i64>("var a = [new_ts()]; a[0].x = 100; a[0].update(); a[0].x") {
assert_eq!(result, 1100); assert_eq!(result, 1100);
} }
else { else {

6
src/parser.rs
View File

@ -90,11 +90,11 @@ pub enum Stmt { If(Box<Expr>, Box<Stmt>), IfElse(Box<Expr>, Box<Stmt>, Box<Stmt>
Var(String, Option<Box<Expr>>), Block(Box<Vec<Stmt>>), Expr(Box<Expr>), Break, Return, ReturnWithVal(Box<Expr>) } Var(String, Option<Box<Expr>>), Block(Box<Vec<Stmt>>), Expr(Box<Expr>), Break, Return, ReturnWithVal(Box<Expr>) }
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub enum Expr { IntConst(i32), Identifier(String), StringConst(String), FnCall(String, Box<Vec<Expr>>), pub enum Expr { IntConst(i64), Identifier(String), StringConst(String), FnCall(String, Box<Vec<Expr>>),
Assignment(Box<Expr>, Box<Expr>), Dot(Box<Expr>, Box<Expr>), Index(String, Box<Expr>), Array(Box<Vec<Expr>>), True, False } Assignment(Box<Expr>, Box<Expr>), Dot(Box<Expr>, Box<Expr>), Index(String, Box<Expr>), Array(Box<Vec<Expr>>), True, False }
#[derive(Debug)] #[derive(Debug)]
pub enum Token { IntConst(i32), Identifier(String), StringConst(String), LCurly, RCurly, LParen, RParen, LSquare, RSquare, pub enum Token { IntConst(i64), Identifier(String), StringConst(String), LCurly, RCurly, LParen, RParen, LSquare, RSquare,
Plus, Minus, Multiply, Divide, Semicolon, Colon, Comma, Period, Equals, True, False, Var, If, Else, While, Plus, Minus, Multiply, Divide, Semicolon, Colon, Comma, Period, Equals, True, False, Var, If, Else, While,
LessThan, GreaterThan, Bang, LessThanEqual, GreaterThanEqual, EqualTo, NotEqualTo, Pipe, Or, Ampersand, And, Fn, LessThan, GreaterThan, Bang, LessThanEqual, GreaterThanEqual, EqualTo, NotEqualTo, Pipe, Or, Ampersand, And, Fn,
Break, Return, LexErr(LexError) } Break, Return, LexErr(LexError) }
@ -122,7 +122,7 @@ impl<'a> Iterator for TokenIterator<'a> {
let out : String = result.iter().cloned().collect(); let out : String = result.iter().cloned().collect();
if let Ok(val) = out.parse::<i32>() { if let Ok(val) = out.parse::<i64>() {
return Some(Token::IntConst(val)); return Some(Token::IntConst(val));
} }
return Some(Token::LexErr(LexError::MalformedNumber)); return Some(Token::LexErr(LexError::MalformedNumber));