Merge branch 'this'

Author: aceinetx

examples/class.zen

@@ -3,30 +3,35 @@ mod stdlib;
 // ZenLang is not object oriented - therefore it doesn't have classes
 // But you can make something similar
 fn class_new {
-    let inst = {"a" = 0, "b" = 0};
-    return inst;
+    return {
+			"add_a" = class_add_a,
+			"add_b" = class_add_b,
+			"print" = class_print,
+			"a" = 0, 
+			"b" = 0
+		};
 }
 
-fn class_add_a self n {
+fn class_add_a n {
     let self.a = self.a + n;
     return null;
 }
 
-fn class_add_b self n {
+fn class_add_b n {
     let self.b = self.b + n;
     return null;
 }
 
-fn class_print self {
+fn class_print {
     let res = self.a + self.b;
     println(res);
     return null;
 }
 
 fn main {
     let class = class_new();
-    class_add_a(class, 42);
-    class_add_b(class, 69);
-    class_print(class);
+		class.add_a(42);
+		class.add_b(69);
+		class.print();
     return null;
 }

examples/stack.zen

@@ -1,34 +1,41 @@
 mod stdlib;
 
 fn stack_new {
-    return {"data" = []};
+    return {
+			"top" = stack_top,
+			"push" = stack_push,
+			"pop" = stack_pop,
+			"size" = stack_size,
+			"is_empty" = stack_is_empty,
+			"data" = []
+		};
 }
 
-fn stack_top self {
+fn stack_top {
     return array_last(self.data);
 }
 
-fn stack_push self element {
+fn stack_push element {
     let self.data = array_push(self.data, element);
     return null;
 }
 
-fn stack_pop self {
+fn stack_pop {
     let self.data = array_pop(self.data);
     return null;
 }
 
-fn stack_size self {
+fn stack_size {
     return array_size(self.data);
 }
 
-fn stack_is_empty self {
-    return stack_size(self) == 0;
+fn stack_is_empty {
+    return self.size() == 0;
 }
 
 fn main {
     let stack = stack_new();
-  	stack_push(stack, 69);
-    println(stack_top(stack));
-    return stack_is_empty(stack);
+		stack.push(69);
+    println(stack.top());
+    return stack.is_empty();
 }

zenlang/src/value.rs

@@ -201,3 +201,9 @@ impl Display for Value {
         }
     }
 }
+
+impl Default for Value {
+    fn default() -> Self {
+        return Value::Null();
+    }
+}

zenlang/src/vm/opcodes/vm_call.rs

@@ -2,6 +2,7 @@ use crate::strong_u64::U64BitsControl;
 use crate::value::*;
 use crate::vm::VM;
 use alloc::format;
+use alloc::string::*;
 
 impl VM {
     pub fn op_call(&mut self) {
@@ -13,6 +14,11 @@ impl VM {
                 self.pc.sub_low(1);
                 self.add_scope();
 
+                let this_name = &String::from("self");
+                let scope = self.scopes.last_mut().unwrap();
+                scope.create_if_doesnt_exist(this_name);
+                *scope.get_mut(this_name).unwrap() = core::mem::take(&mut self.self_var);
+
                 let start = self.bfas_stack_start.pop().unwrap();
                 let end = self.bfas_stack_end.pop().unwrap();
                 let diff = end - start;

zenlang/src/vm/opcodes/vm_iafs.rs

@@ -19,6 +19,7 @@ impl VM {
             self.error = format!("iafs failed: no more values on stack for array");
             return;
         }
+        self.self_var = array.clone();
 
         match array {
             Value::Object(obj) => match &*obj.borrow() {

zenlang/src/vm/vm.rs

@@ -21,6 +21,7 @@ pub struct VM {
     pub platform: Option<Box<dyn Platform>>,
     pub global_scope: Scope,
     pub halted: bool,
+    pub self_var: Value,
     pub(crate) bfas_stack_start: Vec<i64>,
     pub(crate) bfas_stack_end: Vec<i64>,
 }
@@ -38,6 +39,7 @@ impl VM {
             platform: None,
             global_scope: Scope::new(),
             halted: false,
+            self_var: Value::Null(),
             bfas_stack_start: Vec::new(),
             bfas_stack_end: Vec::new(),
         };

zenlang/tests/vm_self.rs

@@ -0,0 +1,118 @@
+extern crate alloc;
+
+use zenlang::compiler::*;
+use zenlang::parser::*;
+use zenlang::tokenizer::*;
+use zenlang::value::*;
+use zenlang::vm::*;
+
+fn expect_to_return(code: String, value: Value) {
+    let mut tokenizer = Tokenizer::new(code);
+    let mut parser = Parser::new(&mut tokenizer);
+    let mut compiler = Compiler::new(&mut parser);
+    if let Err(e) = compiler.compile() {
+        assert_eq!(e, "");
+    }
+    let mut vm = VM::new();
+    let module = compiler.get_module();
+    println!("{:?}", module.opcodes);
+
+    let _ = vm.load_module(&zenlang::stdlib::compile_stdlib_module());
+    let _ = vm.load_module(module);
+
+    if let Err(e) = vm.set_entry_function("main") {
+        assert_eq!(e, "");
+    }
+
+    vm.run_until_halt();
+
+    println!("vm.ret: {:?}", vm.ret);
+    assert_eq!(vm.error, "");
+    assert!(vm.ret.equal(&value, &vm));
+}
+
+#[test]
+fn vm_test_self_1() {
+    expect_to_return(
+        r#"
+fn f2 {
+    let self.hi = self.hi + 3;
+}
+
+fn f {
+    let self.hi = 1;
+    self.test2();
+}
+
+fn main {
+    let obj = {
+        "test" = f,
+        "test2" = f2,
+    };
+    obj.test();
+    return obj.hi;
+} "#
+        .into(),
+        Value::Number(4.0),
+    );
+}
+
+#[test]
+fn vm_test_self_2() {
+    expect_to_return(
+        r#"
+fn f2 {
+    let self.hi = 3;
+}
+
+fn f {
+    let self.hi = 1;
+    let obj = {
+        "test" = f2
+    };
+    obj.test();
+    let self.hi = obj.hi - 1;
+}
+
+fn main {
+    let obj = {
+        "test" = f,
+    };
+    obj.test();
+    return obj.hi;
+} "#
+        .into(),
+        Value::Number(2.0),
+    );
+}
+
+#[test]
+fn vm_test_self_3() {
+    expect_to_return(
+        r#"
+fn f2 {
+    let self.hi = 3;
+}
+
+fn f {
+    let self.hi = 1;
+    let obj = {
+        "test" = f2
+    };
+    obj.test();
+    let self.hi = obj.hi - 1;
+}
+
+fn main {
+    let obj = {
+        "obj" = {
+            "test" = f,
+        }
+    };
+    obj.obj.test();
+    return obj.obj.hi;
+} "#
+        .into(),
+        Value::Number(2.0),
+    );
+}