support code updates

Author: sandyw219

Diff for: interp_Cfun.py

@@ -25,6 +25,8 @@ def interp_exp(self, e, env):
     match e:
       case Call(Name('input_int'), []):
         return super().interp_exp(e, env)      
+      case Call(Name('len'), [tup]):
+        return super().interp_exp(e, env)      
       case Call(func, args):
         f = self.interp_exp(func, env)
         vs = [self.interp_exp(arg, env) for arg in args]
@@ -38,8 +40,8 @@ def interp_stmts(self, ss, env):
     if len(ss) == 0:
       raise Exception('interp_stmts function ended without return')
     match ss[0]:
-      case Return(value):
-        return self.interp_exp(value, env)
+      case TailCall(func, args):
+        return self.interp_exp(Call(func, args), env)
       case _:
         return super().interp_stmts(ss, env)
 
@@ -50,10 +52,9 @@ def interp(self, p):
         for d in defs:
             match d:
               case FunctionDef(name, params, blocks, dl, returns, comment):
-                env[name] = Function(name, [p.arg for p in params.args],
-                                     blocks, env)
+                env[name] = Function(name, [x for (x,t) in params], blocks, env)
         self.blocks = {}
         self.apply_fun(env['main'], [], None)
       case _:
         raise Exception('interp: unexpected ' + repr(p))
-    
+    

Diff for: interp_Cif.py

@@ -21,4 +21,4 @@ def interp(self, p):
         env = {}
         self.blocks = blocks
         self.interp_stmts(blocks[label_name('start')], env)
-    
+    

Diff for: interp_Clambda.py

@@ -0,0 +1,13 @@
+from ast import *
+from interp_Cfun import InterpCfun
+from utils import *
+
+class InterpClambda(InterpCfun):
+
+  def interp_exp(self, e, env):
+    match e:
+      case AllocateClosure(length, typ, arity):
+        array = [None] * length
+        return array
+      case _:
+        return super().interp_exp(e, env)

Diff for: interp_Ctup.py

@@ -38,4 +38,4 @@ def interp_stmts(self, ss, env):
         tup[index] = self.interp_exp(value, env)
         return self.interp_stmts(ss[1:], env)
       case _:
-        return super().interp_stmts(ss, env)
+        return super().interp_stmts(ss, env)

Diff for: interp_Lfun.py

@@ -26,7 +26,7 @@ def apply_fun(self, fun, args, e):
 
   def interp_exp(self, e, env):
     match e:
-      case Call(Name('input_int'), []):
+      case Call(Name(f), args) if (f == 'input_int') or (f == 'len') or (f == 'print'):
         return super().interp_exp(e, env)      
       case Call(func, args):
         f = self.interp_exp(func, env)
@@ -53,8 +53,11 @@ def interp(self, p):
         for d in defs:
             match d:
               case FunctionDef(name, params, bod, dl, returns, comment):
-                env[name] = Function(name, [p.arg for p in params.args],
-                                     bod, env)
+                if isinstance(params, ast.arguments):
+                    ps = [p.arg for p in params.args]
+                else:
+                    ps = [x for (x,t) in params]
+                env[name] = Function(name, ps, bod, env)
         self.apply_fun(env['main'], [], None)
       case _:
-        raise Exception('interp: unexpected ' + repr(p))
+        raise Exception('interp: unexpected ' + repr(p))

Diff for: interp_Lif.py

@@ -67,4 +67,4 @@ def interp_stmts(self, ss, env):
             return self.interp_stmts(orelse + ss[1:], env)
       case _:
         return super().interp_stmts(ss, env)
-    
+    

Diff for: interp_Lint.py

@@ -75,4 +75,4 @@ def interp(self, p):
   ast1_1 = BinOp(read, Add(), neg_eight)
   pr = Expr(Call(Name('print'), [ast1_1]))
   p = Module([pr])
-  interp(p)
+  interp(p)

Diff for: interp_Llambda.py

@@ -0,0 +1,30 @@
+from ast import *
+from interp_Lfun import InterpLfun, Function
+from utils import *
+
+class InterpLlambda(InterpLfun):
+
+  def interp_exp(self, e, env):
+    match e:
+      case FunRefArity(id, arity):
+        return env[id]
+      case Lambda(params, body):
+        return Function('lambda', params, [Return(body)], env)
+      case Closure(arity, args):
+        return tuple([self.interp_exp(arg, env) for arg in args])
+      case AllocateClosure(length, typ, arity):
+        array = [None] * length
+        return array
+      case _:
+        return super().interp_exp(e, env)
+    
+  def interp_stmts(self, ss, env):
+    if len(ss) == 0:
+      return
+    match ss[0]:
+      case AnnAssign(lhs, typ, value, simple):
+        env[lhs.id] = self.interp_exp(value, env)
+        return self.interp_stmts(ss[1:], env)
+      case _:
+        return super().interp_stmts(ss, env)
+        

Diff for: interp_Ltup.py

@@ -14,7 +14,8 @@ def interp_cmp(self, cmp):
   def interp_exp(self, e, env):
     match e:
       case Tuple(es, Load()):
-        return tuple([self.interp_exp(e, env) for e in es])
+        # use a list for mutability
+        return [self.interp_exp(e, env) for e in es]
       case Subscript(tup, index, Load()):
         t = self.interp_exp(tup, env)
         n = self.interp_exp(index, env)
@@ -53,4 +54,4 @@ def interp_stmts(self, ss, env):
   pr = Expr(Call(Name('print'), [t1_at_0]))
   p = Module([pr])
   InterpLtup().interp(p)
-    
+    

Diff for: interp_Lvar.py

@@ -35,4 +35,4 @@ def interp(self, p):
   pr = Expr(Call(Name('print'), [ast1_1]))
   p = Module([pr])
   interp = InterpLvar()
-  interp.interp_Lvar(p)
+  interp.interp_Lvar(p)

Diff for: interp_Lwhile.py

@@ -14,4 +14,4 @@ def interp_stmts(self, ss, env):
         return self.interp_stmts(ss[1:], env)
       case _:
         return super().interp_stmts(ss, env)
-    
+    

Diff for: interp_Pwhile.py

@@ -14,4 +14,4 @@ def interp_stmts(self, ss, env):
         return self.interp_stmts(ss[1:], env)
       case _:
         return super().interp_stmts(ss, env)
-    
+    

Diff for: type_check_Cfun.py

@@ -1,45 +1,41 @@
 from ast import *
 from utils import *
-from type_check_Ctup import check_type_equal, TypeCheckCtup
+from type_check_Ctup import TypeCheckCtup
 import copy
 
 class TypeCheckCfun(TypeCheckCtup):
-    
-  # def parse_type_annot(self, annot):
-  #     match annot:
-  #       case Name(id):
-  #         if id == 'int':
-  #           return int
-  #         elif id == 'bool':
-  #           return bool
-  #         else:
-  #           raise Exception('parse_type_annot: unexpected ' + repr(annot))
-  #       case TupleType(ts):
-  #         return TupleType([self.parse_type_annot(t) for t in ts])
-  #       case FunctionType(ps, rt):
-  #         return FunctionType([self.parse_type_annot(t) for t in ps],
-  #                             self.parse_type_annot(rt))
-  #       case Subscript(Name('Callable'), Tuple([ps, rt])):
-  #         return FunctionType([self.parse_type_annot(t) for t in ps.elts],
-  #                             self.parse_type_annot(rt))
-  #       case Subscript(Name('tuple'), Tuple(ts)):
-  #         return TupleType([self.parse_type_annot(t) for t in ts])
-  #       case _:
-  #           raise Exception('parse_type_annot: unexpected ' + repr(annot))
-    
+
+  def check_type_equal(self, t1, t2, e):
+    if t1 == Bottom() or t2 == Bottom():
+      return
+    match t1:
+      case FunctionType(ps1, rt1):
+        match t2:
+          case FunctionType(ps2, rt2):
+            for (p1,p2) in zip(ps1, ps2):
+              self.check_type_equal(p1, p2, e)
+              self.check_type_equal(rt1, rt2, e)
+          case _:
+            raise Exception('error: ' + repr(t1) + ' != ' + repr(t2) \
+                            + ' in ' + repr(e))
+      case _:
+        super().check_type_equal(t1, t2, e)
+  
   def type_check_exp(self, e, env):
     match e:
       case FunRef(id):
         return env[id]
       case Call(Name('input_int'), []):
         return super().type_check_exp(e, env)      
+      case Call(Name('len'), [tup]):
+        return super().type_check_exp(e, env)      
       case Call(func, args):
         func_t = self.type_check_exp(func, env)
         args_t = [self.type_check_exp(arg, env) for arg in args]
         match func_t:
           case FunctionType(params_t, return_t):
             for (arg_t, param_t) in zip(args_t, params_t):
-                check_type_equal(param_t, arg_t, e)
+                self.check_type_equal(param_t, arg_t, e)
             return return_t
           case Bottom():
             return Bottom()
@@ -68,14 +64,14 @@ def type_check_def(self, d, env):
       case _:
         raise Exception('type_check_def: unexpected ' + repr(d))
 
-  def type_check_stmts(self, ss, env):
-    if len(ss) == 0:
-      return
-    match ss[0]:
+  def type_check_stmt(self, s, env):
+    match s:
       case Return(value):
-        return self.type_check_exp(value, env)
+        self.type_check_exp(value, env)
+      case TailCall(func, args):
+        self.type_check_exp(Call(func, args), env)
       case _:
-        return super().type_check_stmts(ss, env)
+        super().type_check_stmt(s, env)
 
   def type_check(self, p):
     match p:
@@ -90,3 +86,4 @@ def type_check(self, p):
             self.type_check_def(d, env)
       case _:
         raise Exception('type_check: unexpected ' + repr(p))
+

Diff for: type_check_Cif.py

@@ -2,14 +2,14 @@
 from utils import CProgram, Goto, trace, Bottom, Let
 import copy
 
-def check_type_equal(t1, t2, e):
+class TypeCheckCif:
+
+  def check_type_equal(self, t1, t2, e):
     if t1 == Bottom() or t2 == Bottom():
-        pass
+      pass
     elif t1 != t2:
-        raise Exception('error: ' + repr(t1) + ' != ' + repr(t2) \
-                        + ' in ' + repr(e))
-
-class TypeCheckCif:
+      raise Exception('error: ' + repr(t1) + ' != ' + repr(t2) \
+                      + ' in ' + repr(e))
 
   def type_check_atm(self, e, env):
     match e:
@@ -30,35 +30,35 @@ def type_check_exp(self, e, env):
         return self.type_check_atm(e, env)
       case IfExp(test, body, orelse):
         test_t = self.type_check_exp(test, env)
-        check_type_equal(bool, test_t, test)
+        self.check_type_equal(bool, test_t, test)
         body_t = self.type_check_exp(body, env)
         orelse_t = self.type_check_exp(orelse, env)
-        check_type_equal(body_t, orelse_t, e)
+        self.check_type_equal(body_t, orelse_t, e)
         return body_t
       case BinOp(left, op, right) if isinstance(op, Add) or isinstance(op, Sub):
         l = self.type_check_atm(left, env)
-        check_type_equal(l, int, e)
+        self.check_type_equal(l, int, e)
         r = self.type_check_atm(right, env)
-        check_type_equal(r, int, e)
+        self.check_type_equal(r, int, e)
         return int
       case UnaryOp(USub(), v):
         t = self.type_check_atm(v, env)
-        check_type_equal(t, int, e)
+        self.check_type_equal(t, int, e)
         return int
       case UnaryOp(Not(), v):
         t = self.type_check_exp(v, env)
-        check_type_equal(t, bool, e)
+        self.check_type_equal(t, bool, e)
         return bool 
       case Compare(left, [cmp], [right]) if isinstance(cmp, Eq) or isinstance(cmp, NotEq):
         l = self.type_check_atm(left, env)
         r = self.type_check_atm(right, env)
-        check_type_equal(l, r, e)
+        self.check_type_equal(l, r, e)
         return bool
       case Compare(left, [cmp], [right]):
         l = self.type_check_atm(left, env)
-        check_type_equal(l, int, left)
+        self.check_type_equal(l, int, left)
         r = self.type_check_atm(right, env)
-        check_type_equal(r, int, right)
+        self.check_type_equal(r, int, right)
         return bool
       case Call(Name('input_int'), []):
         return int
@@ -70,23 +70,27 @@ def type_check_exp(self, e, env):
       case _:
         raise Exception('error in type_check_exp, unexpected ' + repr(e))
 
+  def type_check_stmts(self, ss, env):
+      for s in ss:
+          self.type_check_stmt(s, env)
+      
   def type_check_stmt(self, s, env):
     match s:      
       case Assign([lhs], value):
         t = self.type_check_exp(value, env)
         if lhs.id in env:
-          check_type_equal(env.get(lhs.id, Bottom()), t, s)
+          self.check_type_equal(env.get(lhs.id, Bottom()), t, s)
         else:
           env[lhs.id] = t
       case Expr(Call(Name('print'), [arg])):
         t = self.type_check_exp(arg, env)
-        check_type_equal(t, int, s)
+        self.check_type_equal(t, int, s)
       case Expr(value):
         self.type_check_exp(value, env)
       case If(Compare(left, [cmp], [right]), body, orelse):
         left_t = self.type_check_atm(left, env)
         right_t = self.type_check_atm(right, env)
-        check_type_equal(left_t, right_t, s) # not quite strict enough
+        self.check_type_equal(left_t, right_t, s) # not quite strict enough
         self.type_check_stmts(body, env)
         self.type_check_stmts(orelse, env)
       case Goto(label):
@@ -96,10 +100,6 @@ def type_check_stmt(self, s, env):
       case _:
         raise Exception('error in type_check_stmt, unexpected' + repr(s))
 
-  def type_check_stmts(self, ss, env):
-    for s in ss:
-        self.type_check_stmt(s, env)
-
   def type_check(self, p):
     match p:
       case CProgram(body):
@@ -112,4 +112,4 @@ def type_check(self, p):
                   break
           p.var_types = env
       case _:
-        raise Exception('error in type_check, unexpected ' + repr(p))
+        raise Exception('error in type_check, unexpected ' + repr(p))

Diff for: type_check_Clambda.py

@@ -0,0 +1,12 @@
+from utils import AllocateClosure
+from type_check_Cfun import TypeCheckCfun
+
+class TypeCheckClambda(TypeCheckCfun):
+    
+  def type_check_exp(self, e, env):
+    match e:
+      case AllocateClosure(length, typ, arity):
+        return typ
+      case _:
+        return super().type_check_exp(e, env)
+