Merge pull request #2 from gilascale/feature/assignment-semantics

feature: assignment semantics

Author: jkingstonc

README.md

@@ -58,6 +58,8 @@ v.display()
 
 ### Bugs
 
+- fix the define vs assign issue at the moment, at the moment they are the same
+  thing
 - creating 2 long lists causes the first list to be an element of the second
   list?
 - fix tuple parsing...
@@ -95,12 +97,8 @@ v.display()
 
 ### Language Features
 
-- garbage collection
-  - bug is with the compilation of prelude included, we are executing the
-    prelude twice
-  - i think a fix for this is changing how its loaded up... we need to do an
-    'import' of the prelude into the global scope
-- ranges can be parsed anywhere
+- setting a value outside a scope
+  - i.e. iterating a variable in a function doesn't work
 - implicit returns
 - void types
 - tuple unpacking

example/test.gila

@@ -2,18 +2,11 @@
 
 
 
+l1 = [1,3,5,7,9]
 
-l1 = [3,4,2,1,3,3]
+x = 0
 
-l2 = [4,3,5,3,9,3]
-
-
-
-
-s = SliceIterator(counter=0,s=l1)
-
-print(s)
-
-
-for _ in s
-    print("foo")
+for _ in 0..len(l1) do
+    print(l1[x])
+    x = x + 1
+end

src/codegen.rs

@@ -1332,20 +1332,18 @@ impl BytecodeGenerator {
         panic!()
     }
 
-    // todo we need a map or something to map these to registers
-    fn gen_variable(
+    fn lookup_variable_recursively(
         &mut self,
         annotation_context: AnnotationContext,
-        pos: Position,
+        pos: &Position,
         t: &Token,
-    ) -> u8 {
-        // todo we assume it exists so return the map
+    ) -> Option<u8> {
         let result = self.codegen_context.chunks[self.codegen_context.current_chunk_pointer]
             .variable_map
             .get(&t.as_identifier());
 
         if let Some(v) = result {
-            return *v;
+            return Some(*v);
         } else {
             let reg = alloc_slot!(self);
             let mut counter = self.codegen_context.current_chunk_pointer;
@@ -1363,16 +1361,29 @@ impl BytecodeGenerator {
                         },
                         pos.line as usize,
                     );
-                    return reg;
+                    return Some(reg);
                 }
                 if counter == 0 {
-                    break;
+                    return None;
                 }
                 counter -= 1;
             }
         }
+    }
 
-        panic!("variable not found in any scope {:?}", t)
+    // todo we need a map or something to map these to registers
+    fn gen_variable(
+        &mut self,
+        annotation_context: AnnotationContext,
+        pos: Position,
+        t: &Token,
+    ) -> u8 {
+        // todo we assume it exists so return the map
+        let res = self.lookup_variable_recursively(annotation_context, &pos, t);
+        if res.is_some() {
+            return res.unwrap();
+        }
+        panic!();
     }
 
     fn get_variable(
@@ -1404,9 +1415,14 @@ impl BytecodeGenerator {
 
         match value {
             Some(v) => {
-                let location = self.visit(annotation_context, &v);
+                let location = self.visit(annotation_context.clone(), &v);
 
-                let var_location = alloc_perm_slot!(self);
+                let existing_var = self.lookup_variable_recursively(annotation_context, &pos, var);
+                let var_location = if existing_var.is_some() {
+                    existing_var.unwrap()
+                } else {
+                    alloc_perm_slot!(self)
+                };
 
                 self.codegen_context.chunks[self.codegen_context.current_chunk_pointer]
                     .variable_map

src/execution.rs

@@ -640,6 +640,36 @@ impl Object {
                         }
                         _ => return Ok(false),
                     },
+                    GCRefData::SLICE(s) => match other {
+                        Object::GC_REF(other_gc_ref) => {
+                            let other_res = shared_execution_context.heap.deref(&other_gc_ref);
+                            if other_res.is_err() {
+                                return Err(other_res.err().unwrap());
+                            }
+                            match other_res.unwrap() {
+                                GCRefData::SLICE(other_s) => {
+                                    if s.s.len() != other_s.s.len() {
+                                        return Ok(false);
+                                    }
+                                    let mut i = 0;
+                                    for item in s.s {
+                                        let eq_res = item
+                                            .equals(shared_execution_context, other_s.s[i].clone());
+                                        if eq_res.is_err() {
+                                            return Err(eq_res.err().unwrap());
+                                        }
+                                        if eq_res.unwrap() {
+                                            return Ok(false);
+                                        }
+                                        i += 1;
+                                    }
+                                    return Ok(true);
+                                }
+                                _ => return Ok(false),
+                            }
+                        }
+                        _ => return Ok(false),
+                    },
                     _ => todo!(),
                 }
                 Ok(true)