From 7b5ba3fbf7509501183566a8456a70c801fac44c Mon Sep 17 00:00:00 2001 From: TudbuT Date: Sat, 18 Feb 2023 20:05:24 +0100 Subject: [PATCH] fix some logic errors, simplify *-fns.rs --- src/dyn_fns.rs | 151 +++++++++-------------------- src/lexer.rs | 1 + src/runtime.rs | 15 ++- src/std_fns.rs | 251 +++++++------------------------------------------ 4 files changed, 97 insertions(+), 321 deletions(-) diff --git a/src/dyn_fns.rs b/src/dyn_fns.rs index 6f7dc8f..7e5d4c2 100644 --- a/src/dyn_fns.rs +++ b/src/dyn_fns.rs @@ -188,6 +188,7 @@ pub fn dyn_read(stack: &mut Stack) { stack.get_frame(), )), origin: stack.get_frame(), + cname: None, })) .spl(), ); @@ -196,109 +197,49 @@ pub fn dyn_read(stack: &mut Stack) { } } -pub fn register(r: &mut Stack, o: Arc) { - r.define_func( - "dyn-__dump".to_owned(), - AFunc::new(Func { - ret_count: 0, - to_call: FuncImpl::Native(dyn_dump), - origin: o.clone(), - }), - ); - r.define_func( - "dyn-def".to_owned(), - AFunc::new(Func { - ret_count: 0, - to_call: FuncImpl::Native(dyn_def), - origin: o.clone(), - }), - ); - r.define_func( - "dyn-func".to_owned(), - AFunc::new(Func { - ret_count: 0, - to_call: FuncImpl::Native(dyn_func), - origin: o.clone(), - }), - ); - r.define_func( - "dyn-construct".to_owned(), - AFunc::new(Func { - ret_count: 0, - to_call: FuncImpl::Native(dyn_construct), - origin: o.clone(), - }), - ); - r.define_func( - "dyn-def-field".to_owned(), - AFunc::new(Func { - ret_count: 0, - to_call: FuncImpl::Native(dyn_def_field), - origin: o.clone(), - }), - ); - r.define_func( - "dyn-def-method".to_owned(), - AFunc::new(Func { - ret_count: 0, - to_call: FuncImpl::Native(dyn_def_method), - origin: o.clone(), - }), - ); - r.define_func( - "dyn-include".to_owned(), - AFunc::new(Func { - ret_count: 0, - to_call: FuncImpl::Native(dyn_include), - origin: o.clone(), - }), - ); - r.define_func( - "dyn-while".to_owned(), - AFunc::new(Func { - ret_count: 0, - to_call: FuncImpl::Native(dyn_while), - origin: o.clone(), - }), - ); - r.define_func( - "dyn-if".to_owned(), - AFunc::new(Func { - ret_count: 0, - to_call: FuncImpl::Native(dyn_if), - origin: o.clone(), - }), - ); - r.define_func( - "dyn-call".to_owned(), - AFunc::new(Func { - ret_count: 0, - to_call: FuncImpl::Native(dyn_call), - origin: o.clone(), - }), - ); - r.define_func( - "dyn-objcall".to_owned(), - AFunc::new(Func { - ret_count: 0, - to_call: FuncImpl::Native(dyn_objcall), - origin: o.clone(), - }), - ); - r.define_func( - "dyn-all-types".to_owned(), - AFunc::new(Func { - ret_count: 1, - to_call: FuncImpl::Native(dyn_all_types), - origin: o.clone(), - }), - ); - r.define_func( - "dyn-read".to_owned(), - AFunc::new(Func { - ret_count: 1, - to_call: FuncImpl::Native(dyn_read), - origin: o.clone(), - }), - ) +pub fn dyn_readf(stack: &mut Stack) { + if let Value::Str(n) = stack.pop().lock_ro().native.clone() { + if let Value::Str(s) = stack.pop().lock_ro().native.clone() { + stack.push( + Value::Func(AFunc::new(Func { + ret_count: 0, + to_call: FuncImpl::SPL(lexer::lex(s, n.clone(), stack.get_frame())), + origin: stack.get_frame(), + cname: Some(n), + })) + .spl(), + ); + } else { + panic!("incorrect usage of dyn-call"); + } + } else { + panic!("incorrect usage of dyn-call"); + } +} + +pub fn register(r: &mut Stack, o: Arc) { + let fns: [(&str, fn(&mut Stack), u32); 14] = [ + ("dyn-__dump", dyn_dump, 0), + ("dyn-def", dyn_def, 0), + ("dyn-func", dyn_func, 0), + ("dyn-construct", dyn_construct, 0), + ("dyn-def-field", dyn_def_field, 0), + ("dyn-def-method", dyn_def_method, 0), + ("dyn-include", dyn_include, 0), + ("dyn-while", dyn_while, 0), + ("dyn-if", dyn_if, 0), + ("dyn-call", dyn_call, 0), + ("dyn-objcall", dyn_objcall, 0), + ("dyn-all-types", dyn_all_types, 1), + ("dyn-read", dyn_read, 1), + ("dyn-readf", dyn_readf, 1), + ]; + for f in fns { + r.define_func(f.0.to_owned(), AFunc::new(Func { + ret_count: f.2, + to_call: FuncImpl::Native(f.1), + origin: o.clone(), + cname: None, + })); + } } diff --git a/src/lexer.rs b/src/lexer.rs index bb19d75..f7cdb90 100644 --- a/src/lexer.rs +++ b/src/lexer.rs @@ -57,6 +57,7 @@ fn read_block(str_words: &[String], isfn: bool, origin: Arc) -> (Option <...> |`."), to_call: FuncImpl::SPL(block.1), origin: origin.to_owned(), + cname: None, })))) } "construct" => { diff --git a/src/runtime.rs b/src/runtime.rs index 4994680..ce626a5 100644 --- a/src/runtime.rs +++ b/src/runtime.rs @@ -189,7 +189,11 @@ impl Stack { } pub fn call(&mut self, func: &AFunc) { - self.frames.push(Arc::new(Frame::new(func.origin.clone()))); + let mut f = Frame::new(func.origin.clone()); + if let Some(ref cname) = func.cname { + f.origin.file = cname.clone(); + } + self.frames.push(Arc::new(f)); func.to_call.call(self); self.frames.pop().unwrap(); } @@ -222,6 +226,7 @@ impl Stack { stack.push(stack.get_var(tmpname.clone())) }))), origin: frame.clone(), + cname: Some("RUNTIME".to_owned()), }), ); let tmpname = name.clone(); @@ -234,6 +239,7 @@ impl Stack { stack.set_var(tmpname.clone(), v); }))), origin: frame.clone(), + cname: Some("RUNTIME".to_owned()), }), ); frame.variables.lock().insert(name, Value::Null.spl()); @@ -400,6 +406,7 @@ pub struct Func { pub ret_count: u32, pub to_call: FuncImpl, pub origin: Arc, + pub cname: Option, } impl PartialEq for Func { @@ -464,6 +471,7 @@ impl Type { stack.push(o.lock_ro().property_map.get(&tmpname).unwrap().clone()); }))), origin: origin.clone(), + cname: Some("RUNTIME".to_owned()), }), ); let tmpname = name.clone(); @@ -477,6 +485,7 @@ impl Type { o.lock().property_map.insert(tmpname.clone(), v); }))), origin, + cname: Some("RUNTIME".to_owned()), }), ); self.properties.push(name); @@ -603,6 +612,7 @@ impl Words { ret_count: rem, to_call: FuncImpl::SPL(words), origin: stack.get_frame(), + cname: None, }), ), Keyword::Construct(name, fields, methods) => { @@ -627,6 +637,7 @@ impl Words { ret_count: v.0, to_call: FuncImpl::SPL(v.1), origin: origin.clone(), + cname: None, }), ) }, @@ -686,6 +697,7 @@ impl Words { stack.push(ftmp.clone().spl()); }))), origin: stack.get_frame(), + cname: None, })); } } else { @@ -726,6 +738,7 @@ impl Words { stack.push(ftmp.clone().spl()); }))), origin: stack.get_frame(), + cname: None, })); } } else { diff --git a/src/std_fns.rs b/src/std_fns.rs index 00142c9..cdced0f 100644 --- a/src/std_fns.rs +++ b/src/std_fns.rs @@ -313,220 +313,41 @@ pub fn call(stack: &mut Stack) { } pub fn register(r: &mut Stack, o: Arc) { - r.define_func( - "pop".to_owned(), - AFunc::new(Func { - ret_count: 0, - to_call: FuncImpl::Native(pop), + let fns: [(&str, fn(&mut Stack), u32); 27] = [ + ("pop", pop, 0), + ("dup", dup, 2), + ("clone", clone, 1), + ("swap", swap, 2), + ("print", print, 0), + ("call", call, 0), + ("gettype", gettype, 1), + ("settype", settype, 1), + ("anew", array_new, 1), + ("array-len", array_len, 1), + ("array-get", array_get, 1), + ("array-set", array_set, 1), + ("eq", eq, 1), + ("lt", lt, 1), + ("gt", gt, 1), + ("not", not, 1), + ("+", plus, 1), + ("-", minus, 1), + ("/", slash, 1), + ("*", star, 1), + ("_int", to_int, 1), + ("_long", to_long, 1), + ("_mega", to_mega, 1), + ("_float", to_float, 1), + ("_double", to_double, 1), + ("_array", to_array, 1), + ("_str", to_str, 1), + ]; + for f in fns { + r.define_func(f.0.to_owned(), AFunc::new(Func { + ret_count: f.2, + to_call: FuncImpl::Native(f.1), origin: o.clone(), - }), - ); - r.define_func( - "dup".to_owned(), - AFunc::new(Func { - ret_count: 2, - to_call: FuncImpl::Native(dup), - origin: o.clone(), - }), - ); - r.define_func( - "clone".to_owned(), - AFunc::new(Func { - ret_count: 1, - to_call: FuncImpl::Native(clone), - origin: o.clone(), - }), - ); - r.define_func( - "swap".to_owned(), - AFunc::new(Func { - ret_count: 2, - to_call: FuncImpl::Native(swap), - origin: o.clone(), - }), - ); - r.define_func( - "print".to_owned(), - AFunc::new(Func { - ret_count: 0, - to_call: FuncImpl::Native(print), - origin: o.clone(), - }), - ); - r.define_func( - "call".to_owned(), - AFunc::new(Func { - ret_count: 0, - to_call: FuncImpl::Native(call), - origin: o.clone(), - }), - ); - r.define_func( - "gettype".to_owned(), - AFunc::new(Func { - ret_count: 1, - to_call: FuncImpl::Native(gettype), - origin: o.clone(), - }), - ); - r.define_func( - "settype".to_owned(), - AFunc::new(Func { - ret_count: 1, - to_call: FuncImpl::Native(settype), - origin: o.clone(), - }), - ); - r.define_func( - "anew".to_owned(), - AFunc::new(Func { - ret_count: 1, - to_call: FuncImpl::Native(array_new), - origin: o.clone(), - }), - ); - r.define_func( - "array-len".to_owned(), - AFunc::new(Func { - ret_count: 1, - to_call: FuncImpl::Native(array_len), - origin: o.clone(), - }), - ); - r.define_func( - "array-get".to_owned(), - AFunc::new(Func { - ret_count: 1, - to_call: FuncImpl::Native(array_get), - origin: o.clone(), - }), - ); - r.define_func( - "array-set".to_owned(), - AFunc::new(Func { - ret_count: 0, - to_call: FuncImpl::Native(array_set), - origin: o.clone(), - }), - ); - r.define_func( - "eq".to_owned(), - AFunc::new(Func { - ret_count: 0, - to_call: FuncImpl::Native(eq), - origin: o.clone(), - }), - ); - r.define_func( - "lt".to_owned(), - AFunc::new(Func { - ret_count: 0, - to_call: FuncImpl::Native(lt), - origin: o.clone(), - }), - ); - r.define_func( - "gt".to_owned(), - AFunc::new(Func { - ret_count: 0, - to_call: FuncImpl::Native(gt), - origin: o.clone(), - }), - ); - r.define_func( - "not".to_owned(), - AFunc::new(Func { - ret_count: 0, - to_call: FuncImpl::Native(not), - origin: o.clone(), - }), - ); - r.define_func( - "+".to_owned(), - AFunc::new(Func { - ret_count: 1, - to_call: FuncImpl::Native(plus), - origin: o.clone(), - }), - ); - r.define_func( - "-".to_owned(), - AFunc::new(Func { - ret_count: 1, - to_call: FuncImpl::Native(minus), - origin: o.clone(), - }), - ); - r.define_func( - "/".to_owned(), - AFunc::new(Func { - ret_count: 1, - to_call: FuncImpl::Native(slash), - origin: o.clone(), - }), - ); - r.define_func( - "*".to_owned(), - AFunc::new(Func { - ret_count: 1, - to_call: FuncImpl::Native(star), - origin: o.clone(), - }), - ); - r.define_func( - "_int".to_owned(), - AFunc::new(Func { - ret_count: 1, - to_call: FuncImpl::Native(to_int), - origin: o.clone(), - }), - ); - r.define_func( - "_long".to_owned(), - AFunc::new(Func { - ret_count: 1, - to_call: FuncImpl::Native(to_long), - origin: o.clone(), - }), - ); - r.define_func( - "_mega".to_owned(), - AFunc::new(Func { - ret_count: 1, - to_call: FuncImpl::Native(to_mega), - origin: o.clone(), - }), - ); - r.define_func( - "_float".to_owned(), - AFunc::new(Func { - ret_count: 1, - to_call: FuncImpl::Native(to_float), - origin: o.clone(), - }), - ); - r.define_func( - "_double".to_owned(), - AFunc::new(Func { - ret_count: 1, - to_call: FuncImpl::Native(to_double), - origin: o.clone(), - }), - ); - r.define_func( - "_array".to_owned(), - AFunc::new(Func { - ret_count: 1, - to_call: FuncImpl::Native(to_array), - origin: o.clone(), - }), - ); - r.define_func( - "_str".to_owned(), - AFunc::new(Func { - ret_count: 1, - to_call: FuncImpl::Native(to_str), - origin: o.clone(), - }), - ); + cname: None, + })); + } }