Refactor process for updating references (#2)

* Add new ROOPL programs

* Fix backend => frontend

* Add new tests to target

* Fix naming

* Fix update of variable referencing

* Add new ROOPL programs to examples list

Author: haysch

Makefile

@@ -17,8 +17,10 @@ rplpp-test: build
 	stack exec rooplpp test/BinaryTree.rplpp
 	stack exec rooplpp test/BinaryTreeArrayUsage.rplpp
 	stack exec rooplpp test/LinkedList.rplpp
+	stack exec rooplpp test/LinkedListReversal.rplpp
 	stack exec rooplpp test/DoublyLinkedList.rplpp
 	stack exec rooplpp test/Fibonacci.rplpp
+	stack exec rooplpp test/FindMinMax.rplpp
 	stack exec rooplpp test/SimpleArithmetic.rplpp
 	stack exec rooplpp test/SimpleConditional.rplpp
 	stack exec rooplpp test/SimpleLoop.rplpp

ROOPLPP.cabal

@@ -5,7 +5,7 @@ synopsis:             ROOPL++ suite. Supports compilation, interpretation and pr
 license:              MIT
 license-file:         LICENSE
 homepage:             https://github.com/haysch/ROOPLPP
-author:               Lasse Hay-Schmidt (interpreter/inverter) & Martin Holm Cservenka (backend)
+author:               Lasse Hay-Schmidt (interpreter/inverter) & Martin Holm Cservenka (frontend)
 maintainer:           [email protected]
 category:             Language
 -- copyright:

src/AST.hs

@@ -143,8 +143,8 @@ type Store = Map Location IExpression
 
 type ObjectScope = [Env]
 
-type Ref = Map SIdentifier SIdentifier
-type ReferenceScope = [Ref]
+type References = Map (SIdentifier, Maybe SIdentifier) (SIdentifier, Maybe SIdentifier)
+type ReferenceScope = [References]
 
 data IExpression = Const Integer
                  | Object TypeName Env

src/Interpreter.hs

@@ -22,7 +22,7 @@ stringifyDataType IntegerType = "int"
 stringifyDataType (ObjectType tn) = tn
 stringifyDataType (ObjectArrayType tn) = tn ++ "[]"
 stringifyDataType IntegerArrayType = "int[]"
-stringifyDataType NilType = "nil"
+stringifyDataType NilType = "null"
 stringifyDataType dt = error $ "Unsupported datatype: " ++ show dt
 
 stringifyBinOp :: BinOp -> String
@@ -55,7 +55,7 @@ stringifySExpression (ArrayElement (n, e)) st =
     let n' = lookupId n st
         e' = stringifySExpression e st
      in printf "%s[%s]" n' e'
-stringifySExpression Nil _ = "nil"
+stringifySExpression Nil _ = "null"
 stringifySExpression (Binary binop e1 e2) st =
     let binop' = stringifyBinOp binop
         e1' = stringifySExpression e1 st
@@ -147,4 +147,4 @@ stringifyIExpression (Const _) = "int"
 stringifyIExpression (IntegerArray _) = "int[]"
 stringifyIExpression (Object tn _) = tn
 stringifyIExpression (ObjectArray tn _) = printf "%s[]" tn
-stringifyIExpression Null = "nil"
+stringifyIExpression Null = "null"

src/Stringify.hs

@@ -6,26 +6,34 @@ class Program
     // A reversible programming language and its invertible self-interpreter, 2007.
     // https://dl.acm.org/doi/10.1145/1244381.1244404
 
-    int n
-    int x1
-    int x2
+    int outx1
+    int outx2
 
     method main()
-        n += 4
-        call fib()
+        local int n = 4
+        local int x1 = 0
+        local int x2 = 0
+        call fib(n, x1, x2)
+        outx1 ^= x1
+        outx2 ^= x2
+        uncall fib(n, x1, x2)
+        delocal int x2 = 0
+        delocal int x1 = 0
+        delocal int n = 4
+
 
     // method main_bwd()
     //     x1 += 5
     //     x2 += 8
     //     uncall fib()
 
-    method fib()
+    method fib(int n, int x1, int x2)
         if n = 0 then
             x1 += 1
             x2 += 1
         else
             n -= 1
-            call fib()
+            call fib(n, x1, x2)
             x1 += x2
             x1 <=> x2
         fi x1 = x2

test/Fibonacci.rplpp

@@ -0,0 +1,61 @@
+class Foo
+    int y
+    
+    method set(int x)
+        y ^= x
+
+    method swap(int x)
+        x <=> y
+
+class Program
+    int min
+    int max
+    int[] xs
+
+    method main()
+        local int length = 4
+        local int m = 0
+        new int[length] xs
+        
+        xs[0] += 4
+        xs[1] += 2
+        xs[2] += 8
+        xs[3] += 6
+        
+        call findMin(m, length)
+        min ^= m
+        uncall findMin(m, length)
+        
+        call findMax(m, length)
+        max ^= m
+        uncall findMax(m, length)
+        
+        delocal int m = 0
+        delocal int length = 4
+        
+    method findMin(int m, int n)
+        m ^= xs[0]
+        local int i = 1
+        from i = 1 do
+            if xs[i] < m then
+                xs[i] -= m
+                m += xs[i]
+            else skip
+            fi xs[i] < 0
+            i += 1
+        loop skip
+        until i = n
+        delocal int i = n
+        
+    method findMax(int m, int n)
+        local int i = 0
+        from i = 0 do
+            if xs[i] > m then
+                m -= xs[i]
+                m <=> xs[i]
+            else skip
+            fi xs[i] < 0
+            i += 1
+        loop skip
+        until i = n
+        delocal int i = n

test/FindMinMax.rplpp

@@ -0,0 +1,59 @@
+class Cell
+    int data
+    Cell next
+
+    method addToData(int value)
+        data += value
+
+    method addFromData(int value)
+        value += data
+
+    method swapNext(Cell cell)
+        next <=> cell
+
+//////////////////////////////////////////
+// Summation of a list of natural numbers
+// R.Glueck, 210330
+//////////////////////////////////////////
+class Program
+    Cell right
+    Cell left
+    int sum
+
+    method main()
+        //////////////////////////////////////// 
+        // begin: Create list right -> [1, ..., n]
+        local int n = 5  // n >= 0
+        from n != 0 do skip
+        loop
+            local Cell cell = nil
+            new Cell cell
+            call cell::swapNext(right)
+            call cell::addToData(n)
+            right <=> cell
+            n -= 1
+            delocal Cell cell = nil
+        until n = 0
+        delocal int n = 0
+        // end: Create list right -> [1, ..., n]
+        ////////////////////////////////////////
+
+        ////////////////////////////////////////
+        // begin: Summation of list values
+        // left -> nil, right -> [1,...,n], sum = 0
+        from left = nil do skip           // walk forward through list
+        loop
+            call right::addFromData(sum)  // payload operation: summation
+            call right::swapNext(left)    // swap pointers: cell points left
+            left <=> right                // left->[i,..,1], right->[i+1,...,n]
+        until right = nil
+        // left->[n,..,1], right->nil, sum = 1 + ... + n
+        from right = nil do skip          // walk backward through list
+        loop
+            left <=> right
+            call right::swapNext(left)    // swap pointers: cell points right
+            skip                          // payload operation: none
+        until left = nil
+        // left->nil, right->[1,...,n], sum = 1 + ... + n
+        // end:  Summation of list values
+        ////////////////////////////////////////

test/LinkedListReversal.rplpp

@@ -8,12 +8,14 @@ class Foo
 
 class Program
     int z
-    Foo f
 
     method main()
+        local Foo f = nil
         new Foo f
         local int x = 0
         call f::addTwo(x)
         z += x
         uncall f::addTwo(x)
         delocal int x = 0
+        delete Foo f
+        delocal Foo f = nil

test/SimpleMethodCall.rplpp

@@ -0,0 +1 @@
+{ "foo": { "value": 5 }, "bar": { "value": 5, "value2": 10 }, "fooList": [{ "value": 0 }, { "value": 0 }, { "value": 0, "value2": 0 }, null, null], "barList": [null, null, null, null, null], "intList": [10, 10, 5, 0, 0], "singleton": null, "length": 3735943886 }

test/result/ArrayUsageExample.out

@@ -0,0 +1 @@
+{ "sumResult": 3, "tree": { "root": { "left": { "left": { "left": null, "right": null, "value": 2 }, "right": null, "value": 1 }, "right": null, "value": 0 } }, "nodeCount": 3 }

test/result/ArrayUsageExample.out.json

@@ -0,0 +1 @@
+{ "tree": { "root": { "value": 3, "left": { "value": 2, "left": { "value": 1, "left": null, "right": null }, "right": null }, "right": { "value": 4, "left": null, "right": null } } }, "nodeCount": 4, "nodeVals": [3, 2, 4, 1] }

test/result/BinaryTree.out

@@ -0,0 +1 @@
+{ "list": { "head": { "data": 0, "index": 0, "left": null, "right": { "data": 1, "index": 1, "left": { "data": 0, "index": 0, "left": null, "right": null, "self": null }, "right": { "data": 2, "index": 2, "left": { "data": 1, "index": 1, "left": null, "right": null, "self": null }, "right": { "data": 3, "index": 3, "left": { "data": 2, "index": 2, "left": null, "right": null, "self": null }, "right": { "data": 4, "index": 4, "left": { "data": 3, "index": 3, "left": null, "right": null, "self": null }, "right": { "data": 5, "index": 5, "left": { "data": 4, "index": 4, "left": null, "right": null, "self": null }, "right": { "data": 6, "index": 6, "left": { "data": 5, "index": 5, "left": null, "right": null, "self": null }, "right": { "data": 7, "index": 7, "left": { "data": 6, "index": 6, "left": null, "right": null, "self": null }, "right": { "data": 8, "index": 8, "left": { "data": 7, "index": 7, "left": null, "right": null, "self": null }, "right": { "data": 9, "index": 9, "left": { "data": 8, "index": 8, "left": null, "right": null, "self": null }, "right": null, "self": { "data": 9, "index": 9, "left": null, "right": null, "self": null } }, "self": null }, "self": null }, "self": null }, "self": null }, "self": null }, "self": null }, "self": null }, "self": null }, "self": null }, "length": 10 }, "listLength": 10 }

test/result/BinaryTree.out.json

@@ -0,0 +1 @@
+{ "outx1": 5, "outx2": 8 }

test/result/BinaryTreeArrayUsage.out

@@ -0,0 +1 @@
+{ "min": 2, "max": 8, "xs": [4, 2, 8, 6] }

test/result/BinaryTreeArrayUsage.out.json

@@ -0,0 +1 @@
+{ "linkedList": { "head": { "next": { "next": { "next": { "next": { "next": { "next": { "next": { "next": { "next": { "next": null, "data": 9 }, "data": 8 }, "data": 7 }, "data": 6 }, "data": 5 }, "data": 4 }, "data": 3 }, "data": 2 }, "data": 1 }, "data": 0 }, "listLength": 10 }, "sumResult": 0, "listLength": 10 }

test/result/DoublyLinkedList.out

@@ -0,0 +1 @@
+{ "right": { "data": 1, "next": { "data": 2, "next": { "data": 3, "next": { "data": 4, "next": { "data": 5, "next": null } } } } }, "left": null, "sum": 15 }

test/result/DoublyLinkedList.out.json

@@ -0,0 +1 @@
+{ "z": 2 }

test/result/Fibonacci.out

@@ -33,13 +33,15 @@
                 <li><a href="#examples/SimpleConditional">Conditional</a></li>
                 <li><a href="#examples/SimpleLoop">Loop</a></li>
                 <li><a href="#examples/SimpleMethodCall">Method Calling</a></li>
-                <li><p class="li-section">Complex</p></li>
+                <li><p class="li-section">Advanced</p></li>
                 <li><a href="#examples/ArrayUsageExample">Array Usage</a></li>
                 <li><a href="#examples/BinaryTree">Binary Tree</a></li>
                 <li><a href="#examples/BinaryTreeArrayUsage">Binary Tree using Array</a></li>
                 <li><a href="#examples/DoublyLinkedList">Doubly Linked List</a></li>
                 <li><a href="#examples/Fibonacci">Fibonacci</a></li>
+                <li><a href="#examples/FindMinMax">Find Min & Max</a></li>
                 <li><a href="#examples/LinkedList">LinkedList</a></li>
+                <li><a href="#examples/LinkedListReversal">LinkedList Reversal</a></li>
               </ul>
             </li>
             <li><a href="#about" data-toggle="modal">About</a></li>