moved exit from Lany to Larray

Author: jsiek

compiler.py

@@ -15,34 +15,66 @@ class Compiler:
     # Remove Complex Operands
     ############################################################################
 
-    def rco_exp(self, e: expr) -> Tuple[expr, Temporaries]:
+    def rco_exp(self, e: expr, need_atomic : bool) -> Tuple[expr, Temporaries]:
         match e:
-          case  Constant(int):
-            
+          case  Constant(n):
+            return Constant(n), []
           case Call(Name('input_int'),[]):
-          
+            if need_atomic:
+              tmp = Name(generate_name('tmp'))
+              return tmp, [(tmp, Call(Name('input_int'),[]))]
+            else:
+              return Call(Name('input_int'),[]), []
           case UnaryOp(USub(), exp):
-             (new_exp, temps) = self.rco_exp(exp)
-             
+             (atm, temps) = self.rco_exp(exp, True)
+             usub = UnaryOp(USub(), atm)
+             if need_atomic:
+               tmp = Name(generate_name('tmp'))
+               return tmp, temps + [(tmp, usub)]
+             else:
+               return usub, temps
           case BinOp(exp1, Add(), exp2):
-             (new_exp1, temps1) = self.rco_exp(exp1)
-             (new_exp2, temps2) = self.rco_exp(exp2)
-          
+             (atm1, temps1) = self.rco_exp(exp1, True)
+             (atm2, temps2) = self.rco_exp(exp2, True)
+             add = BinOp(atm1, Add(), atm2)
+             if need_atomic:
+               tmp = Name(generate_name('tmp'))
+               return tmp, temps1 + temps2 + [(tmp, add)]
+             else:
+               return add, temps1 + temps2
           case BinOp(exp1, Sub(), exp2):
-             (new_exp1, temps1) = self.rco_exp(exp1)
-             (new_exp2, temps2) = self.rco_exp(exp2)
-          
+             (atm1, temps1) = self.rco_exp(exp1, True)
+             (atm2, temps2) = self.rco_exp(exp2, True)
+             sub = BinOp(atm1, Sub(), atm2)
+             if need_atomic:
+               tmp = Name(generate_name('tmp'))
+               return tmp, temps1 + temps2 + [(tmp, sub)]
+             else:
+               return sub, temps1 + temps2
           case Name(var):
-          
+             return Name(var), []
           case _:
             raise Exception('rco_exp unexpected ' + repr(e))
 
     def rco_stmt(self, s: stmt) -> List[stmt]:
-        # YOUR CODE HERE
-        raise Exception('rco_stmt not implemented')
+      match s:
+        case Expr(Call(Name('print'), [exp])):
+           (atm, temps) = self.rco_exp(exp, True)
+           return [Assign([var], init) for (var,init) in temps] + [Expr(Call(Name('print'), [atm]))]
+        case Expr(exp) :
+           (atm, temps) = self.rco_exp(exp, False)
+           return [Assign([var], init) for (var,init) in temps]
+        case Assign([Name(var)], exp):
+           (atm, temps) = self.rco_exp(exp, False)
+           return [Assign([x], init) for (x,init) in temps] + [Assign([Name(var)], atm)]
+        case _:
+          raise Exception('rco_stmt not implemented')
 
     def remove_complex_operands(self, p: Module) -> Module:
-        # YOUR CODE HERE
+        match p:
+          case Module(ss):
+            sss = [self.rco_stmt(s) for s in ss]
+            return Module(sum(sss, []))
         raise Exception('remove_complex_operands not implemented')
 
 

simple-test.py

@@ -80,7 +80,7 @@ def execute_and_check(program_filename, program_ast):
       tests = [dirpath + t for t in filter(is_python_extension, filenames)]
       break
   else:
-      tests = [os.getcwd() + '/tests/var/' + 'sub-input.py']
+      tests = [os.getcwd() + '/tests/var/' + 'sub-input-flat.py']
 
   # Evaluate the compiler on each test program.
   for program_filename in tests:

type_check_Lany.py

@@ -56,8 +56,6 @@ def type_check_exp(self, e, env):
       case TagOf(value):
         self.check_exp(value, AnyType(), env)
         return IntType()
-      case Call(Name('exit'), []):
-        return Bottom()
       case AnnLambda(params, returns, body):
         new_env = {x:t for (x,t) in env.items()}
         for (x,t) in params:

type_check_Larray.py

@@ -94,6 +94,8 @@ def type_check_exp(self, e, env):
         return IntType()
       case AllocateArray(length, typ):
         return typ
+      case Call(Name('exit'), []):
+        return Bottom()
       case _:
         return super().type_check_exp(e, env)
 

utils.py

@@ -1195,6 +1195,8 @@ def compile_and_test(compiler, compiler_name,
     trace('\n# source program: ' + os.path.basename(program_root) + '\n')
     trace(program)
     trace('')
+    trace(repr(program))
+    trace('')
 
     if 'source' in type_check_dict.keys():
         trace('\n# type checking source program\n')
@@ -1366,6 +1368,7 @@ def compile_and_test(compiler, compiler_name,
         trace('\n# ' + passname + '\n')
         program = compiler.remove_complex_operands(program)
         trace(program)
+        trace(repr(program))
         if passname in type_check_dict.keys():
             type_check_dict[passname](program)
         total_passes += 1
@@ -1378,6 +1381,7 @@ def compile_and_test(compiler, compiler_name,
         trace('\n# ' + passname + '\n')
         program = compiler.explicate_control(program)
         trace(program)
+        trace(repr(program))
         if passname in type_check_dict.keys():
             type_check_dict[passname](program)
             trace('type checking passed')