test programs (yet to be compiled/executed); syntax tree structure and a naive transpiler to python code

ssloy · ssloy · commit 4c46a43550e6 · 2024-01-13T00:53:22.000+01:00
diff --git a/LICENSE.txt b/LICENSE.txt
@@ -0,0 +1,14 @@
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.
+
diff --git a/Makefile b/Makefile
@@ -0,0 +1,34 @@
+SHELL := bash
+.ONESHELL:
+.SHELLFLAGS := -eu -o pipefail -c
+.DELETE_ON_ERROR:
+MAKEFLAGS += --warn-undefined-variables
+MAKEFLAGS += --no-builtin-rules
+
+VENV := $(shell echo $${VIRTUAL_ENV-.venv})
+PY3 := $(shell command -v python3 2	/dev/null)
+PYTHON := $(VENV)/bin/python
+INSTALL_STAMP := $(VENV)/.install.stamp
+
+.PHONY: test run clean
+
+$(PYTHON):
+	@if [ -z $(PY3) ]; then echo "Python 3 could not be found."; exit 2; fi
+	echo $(PY3) -m venv $(VENV)
+	$(PY3) -m venv $(VENV)
+
+$(INSTALL_STAMP): $(PYTHON) requirements.txt
+	$(PYTHON) -m pip install -r requirements.txt
+	touch $(INSTALL_STAMP)
+
+test: $(INSTALL_STAMP)
+	$(PYTHON) -m pytest --cov . -v --cov-report term-missing ./tests/
+
+run: $(INSTALL_STAMP)
+	@$(PYTHON) compiler.py
+
+clean:
+	rm -rf $(VENV) .pytest_cache .coverage
+	find . -type f -name *.pyc -delete
+	find . -type d -name __pycache__ -delete
+
diff --git a/README.md b/README.md
@@ -47,3 +47,9 @@ fun main() {
 There will no be dynamic memory allocation, no pointers, no garbage collection. There will be nested functions, function overloading and type checking.
 
 And as usual, there will be a program with a raytracer :)
+
+## run tests
+```sh
+make test
+```
+
diff --git a/requirements.txt b/requirements.txt
@@ -0,0 +1,3 @@
+sly
+pytest
+pytest-cov
diff --git a/syntree.py b/syntree.py
@@ -0,0 +1,64 @@
+class Type:
+    VOID   = 0
+    INT    = 1
+    BOOL   = 2
+    STRING = 3
+
+class Function:
+    def __init__(self, name, args, var, fun, body, deco=None):
+        self.name = name       # function name, string
+        self.args = args       # function arguments, list of tuples (name, type)
+        self.var  = var        # local variables, list of tuples (name, type)
+        self.fun  = fun        # nested functions, list of Function nodes
+        self.body = body       # function body, list of statement nodes (Print/Return/Assign/While/IfThenElse/FunCall)
+        self.deco = deco or {} # decoration dictionary to be filled by the parser (line number) and by the semantic analyzer (return type, scope id etc)
+
+# statements
+class Print:
+    def __init__(self, expr, newline, deco=None):
+        self.expr, self.newline, self.deco = expr, newline, deco or {}
+
+class Return:
+    def __init__(self, expr, deco=None):
+        self.expr, self.deco = expr, deco or {}
+
+class Assign:
+    def __init__(self, name, expr, deco=None):
+        self.name, self.expr, self.deco = name, expr, deco or {}
+
+class While:
+    def __init__(self, expr, body, deco=None):
+        self.expr, self.body, self.deco = expr, body, deco or {}
+
+class IfThenElse:
+    def __init__(self, expr, ibody, ebody, deco=None):
+        self.expr, self.ibody, self.ebody, self.deco = expr, ibody, ebody, deco or {}
+
+# expressions
+class ArithOp:
+    def __init__(self, op, left, right, deco=None):
+        self.op, self.left, self.right, self.deco = op, left, right, deco or {}
+
+class LogicOp:
+    def __init__(self, op, left, right, deco=None):
+        self.op, self.left, self.right, self.deco = op, left, right, deco or {}
+
+class Integer:
+    def __init__(self, value, deco=None):
+        self.value, self.deco = value, deco or {}
+
+class Boolean:
+    def __init__(self, value, deco=None):
+        self.value, self.deco = value, deco or {}
+
+class String:
+    def __init__(self, value, deco=None):
+        self.value, self.deco = value, deco or {}
+
+class Var:
+    def __init__(self, name, deco=None):
+        self.name, self.deco = name, deco or {}
+
+class FunCall: # depending on the context, a function call can be a statement or an expression
+    def __init__(self, name, args, deco=None):
+        self.name, self.args, self.deco = name, args, deco or {}
diff --git a/test-data/fixed-point.expected b/test-data/fixed-point.expected
@@ -0,0 +1 @@
+-3.14158
diff --git a/test-data/fixed-point.wend b/test-data/fixed-point.wend
@@ -0,0 +1,86 @@
+fun main() {
+
+    // This program outputs a decimal representation of a signed 32-bit fixed point number.
+    // It prints the number one character at a time without ever printing an integer type expression,
+    // like we would make it with aid of _write system call.
+
+    fun print_fixed_point(x:int, shift:int) {
+        var decpr:int;
+        var i:int;
+
+        fun decpr(shift:int) : int { // number of meaningful digits after the decimal point
+            var decpr:int;
+            decpr = 0;
+            while shift>0 {
+                decpr = decpr + 1;
+                shift = shift / 10;
+            }
+            return decpr;
+        }
+
+        fun print_digit(d:int) {
+            if d==0 {
+                print "0";
+            } else {
+                if d==1 {
+                    print "1";
+                } else {
+                    if d==2 {
+                        print "2";
+                    } else {
+                        if d==3 {
+                            print "3";
+                        } else {
+                            if d==4 {
+                                print "4";
+                            } else {
+                                if d==5 {
+                                    print "5";
+                                } else {
+                                    if d==6 {
+                                        print "6";
+                                    } else {
+                                        if d==7 {
+                                            print "7";
+                                        } else {
+                                            if d==8 {
+                                                print "8";
+                                            } else {
+                                                if d==9 {
+                                                    print "9";
+                                                } else {
+                                                    print "invalid input";
+                                                }}}}}}}}}}
+        }
+
+        fun print_integer(x:int) {
+            if x>0 {
+                print_integer(x / 10);
+                print_digit(x % 10); // recursion to reverse the print
+            }
+        }
+
+        if x<0 {
+            print "-";
+            x = -x;
+        }
+
+        print_integer(x / shift);
+        print ".";
+
+        decpr = decpr(shift);
+        i = 0;
+        x = (x % shift) * 10;
+        while i<decpr {
+            print_digit((x / shift) % 10);
+            x = (x % shift) * 10;
+            i = i + 1;
+        }
+        println "";
+    }
+
+    // print number -pi up to 16 bits (10^-5) precision
+    // 205887 = int(pi * 2^16)
+    print_fixed_point(-205887, 65536);
+}
+
diff --git a/test-data/helloworld.expected b/test-data/helloworld.expected
@@ -0,0 +1 @@
+hello world
diff --git a/test-data/helloworld.wend b/test-data/helloworld.wend
@@ -0,0 +1,4 @@
+fun main() {
+    println "hello world";
+}
+
diff --git a/test-data/mutual-recursion.expected b/test-data/mutual-recursion.expected
@@ -0,0 +1 @@
+odd(-255) = True
diff --git a/test-data/mutual-recursion.wend b/test-data/mutual-recursion.wend
@@ -0,0 +1,31 @@
+fun main() {
+    var n:int;
+
+    fun even(n:int) : bool {
+        if n == 0 {
+            return true;
+        } else {
+            return odd(abs(n) - 1);
+        }
+    }
+
+    fun odd(n:int) : bool {
+        if n == 0 {
+            return false;
+        } else {
+            return even(abs(n) - 1);
+        }
+    }
+
+    fun abs(n:int) : int {
+        if n < 0 {
+            return -n;
+        } else {
+            return n;
+        }
+    }
+
+    n = -255;
+    print "odd("; print n; print ") = "; println odd(n);
+}
+
diff --git a/test-data/overload.expected b/test-data/overload.expected
@@ -0,0 +1,3 @@
+0
+1
+2
diff --git a/test-data/overload.wend b/test-data/overload.wend
@@ -0,0 +1,21 @@
+fun main() {
+    fun main(x:int) : int {
+        return x;
+    }
+
+    fun main(x:int, y:int) : int {
+        return x + y;
+    }
+
+    fun main(x:bool) : int {
+        if x {
+            return 0;
+        }
+        return 2;
+    }
+
+    println main(0);
+    println main(0, 1);
+    println main(false);
+}
+
diff --git a/test-data/popcount.expected b/test-data/popcount.expected
@@ -0,0 +1 @@
+number of 1s in the binary representation of 534219 is 9
diff --git a/test-data/popcount.wend b/test-data/popcount.wend
@@ -0,0 +1,22 @@
+fun main() {
+    var test:int;
+
+    // count number of set bits in binary representation of a positive integer n
+    fun popcount(n:int) : int {
+        var cnt:int;
+
+        cnt = 0;
+        while n > 0 {
+            cnt = cnt + n % 2;
+            n = n / 2;
+        }
+        return cnt;
+    }
+
+    test = 534219;
+    print "number of 1s in the binary representation of ";
+    print test;
+    print " is ";
+    println popcount(test);
+}
+
diff --git a/test-data/scope.expected b/test-data/scope.expected
@@ -0,0 +1 @@
+3
diff --git a/test-data/scope.wend b/test-data/scope.wend
@@ -0,0 +1,17 @@
+fun main() {
+    var x:int;
+
+    fun f(y:int) {
+        fun g(y:int) {
+            x = y + 1;
+        }
+
+      x = y;
+      g(x + 1);
+    }
+
+    x = 0;
+    f(x + 1);
+    println x;
+}
+
diff --git a/test-data/sqrt.expected b/test-data/sqrt.expected
@@ -0,0 +1 @@
+14519
diff --git a/test-data/sqrt.wend b/test-data/sqrt.wend
@@ -0,0 +1,37 @@
+fun main() {
+    // square root of a fixed-point number
+    // stored in a 32 bit integer variable, shift is the precision
+
+    fun sqrt(n:int, shift:int) : int {
+        var x:int;
+        var x_old:int;
+        var n_one:int;
+
+        if n > 65535 { // pay attention to potential overflows
+            return 2 * sqrt(n / 4, shift);
+        }
+        x = shift; // initial guess 1.0, can do better, but oh well
+        n_one = n * shift; // need to compensate for fixp division
+        while true {
+            x_old = x;
+            x = (x + n_one / x) / 2;
+            if abs(x - x_old) <= 1 {
+                return x;
+            }
+        }
+    }
+
+    fun abs(x:int) : int {
+        if x < 0 {
+            return -x;
+        } else {
+            return x;
+        }
+    }
+
+    // 25735 is approximately equal to pi * 8192;
+    // expected value of the output is sqrt(pi) * 8192 approx 14519
+
+    println sqrt(25735, 8192);
+}
+
diff --git a/tests/__init__.py b/tests/__init__.py
diff --git a/tests/__pycache__/__init__.cpython-311.pyc b/tests/__pycache__/__init__.cpython-311.pyc
diff --git a/tests/__pycache__/test_syntree.cpython-311-pytest-7.4.4.pyc b/tests/__pycache__/test_syntree.cpython-311-pytest-7.4.4.pyc
diff --git a/tests/test_syntree.py b/tests/test_syntree.py
diff --git a/transpy_naive.py b/transpy_naive.py

-Original file line number
+Diff line change
@@ @@ -0,0 +1,4 @@ @@
 +fun main() {
 +    println "hello world";
 +}
++