Rewrite explicate-control

explicate-control.rkt

@@ -1,29 +1,29 @@
 #lang racket
 
-(require racket/fixnum)
-
 (provide explicate-control)
 
-(define (explicate-control sexp)
+(require racket/fixnum)
-  (match sexp
+(require "rvar.rkt")
-    [`(program ,info ,exp)
+(require "cvar.rkt")
-      `(program ,info ((start . ,(explicate-control-tail exp))))]))
+
+(define (explicate-control program)
+  (match program
+    [(Program info body)
+     (CProgram info (list `(start . ,(explicate-control-tail body))))]))
 
 ; after a remove-complex-opera*, all expressions
-; are compatible with C0
+; are in monadic normal form
 (define (explicate-control-tail exp)
   (match exp
-    [(? fixnum?) `(return ,exp)]
+    [(Int _) (Return exp)]
-    [(? symbol?) `(return ,exp)]
+    [(Var _) (Return exp)]
-    [`(read) `(return ,exp)]
+    [(Prim _ _) (Return exp)]
-    [`(- ,e) `(return ,exp)]
+    [(Let varname rexp body)
-    [`(+ ,e1 ,e2) `(return ,exp)]
+     (explicate-control-assign varname rexp (explicate-control-tail body))]))
-    [`(let ([,var ,rexp]) ,body)
-     (explicate-control-assign var rexp (explicate-control-tail body))]))
 
 ; stmt :=  (assign var exp)
 ; tail :=  (return exp) / (seq stmt tail)
-(define (explicate-control-assign var exp c0-body) `()
+(define (explicate-control-assign varname exp cvar-body)
   (match exp
-     [`(let ([,v ,x]) ,b) (explicate-control-assign v x (explicate-control-assign var b c0-body))]
+     [(Let v x b) (explicate-control-assign v x (explicate-control-assign varname b cvar-body))]
-     [_ `(seq (assign ,var ,exp) ,c0-body)]))
+     [_ (Seq (Assign (Var varname) exp) cvar-body)]))

test-explicate-control.rkt

@@ -1,62 +1,72 @@
 #lang racket
 
 (require "test-util.rkt")
+(require "uniquify.rkt")
 (require "remove-complex-oper.rkt")
 (require "explicate-control.rkt")
-(require "c2.rkt")
+(require "rvar.rkt")
+(require "cvar.rkt")
 
 (define programs
   (list
-   `(program () (+ 2 3))
+   (Program '() (Prim '+ (list (Int 2) (Int 3))))
-   `(program () (+ (- 2) 3))
+   (Program '() (Prim '+ (list (Prim '- (list (Int 2))) (Int 3))))
-   `(program ()
+   (Program '()
-             (let ([y (let ([x 20])
+            (Let 'y (Let 'x (Int 20)
-                        (+ x (let ([x 22]) x)))]) y))
+                         (Prim '+ (list (Var 'x) (Let 'x (Int 22) (Var 'x)))))
-   `(program ()
+                    (Var 'y)))
-      (let ([a 42])
+   (Program '()
-        (let ([b a])
+    (Let 'a (Int 42)
-          b)))
+         (Let 'b (Var 'a)
+              (Var 'b))))
 
-   `(program () (+ (let ([x (+ (- 1) 2)]) (+ x 2)) (+ 4 5)))))
+   (Program '()
+    (Prim '+ (list (Let 'x (Prim '+ (list (Prim '- (list (Int 1))) (Int 2)))
+                       (Prim '+ (list (Var 'x) (Int 2))))
+                   (Prim '+ (list (Int 4) (Int 5))))))))
 
-(define (pass program) (explicate-control (remove-complex-opera* program)))
+(define (pass program) (explicate-control (remove-complex-opera* (uniquify program))))
 
 (test-eq
  (pass (list-ref programs 0))
- `(program ()
+ (CProgram '()
-           ((start .
+           (list `(start .
-             (return (+ 2 3))))))
+                   ,(Return (Prim '+ (list (Int 2) (Int 3))))))))
 
 (test-eq
  (pass (list-ref programs 1))
- `(program ()
+ (CProgram '()
-           ((start .
+           (list `(start .
-             (seq (assign tmp.1 (- 2))
+                   ,(Seq (Assign (Var 'tmp.0) (Prim '- (list (Int 2))))
-              (return (+ tmp.1 3)))))))
+                     (Return (Prim '+ (list (Var 'tmp.0) (Int 3)))))))))
 
 (test-eq
   (pass (list-ref programs 2))
-  `(program ()
+  (CProgram '()
-            ((start .
+           `((start .
-              (seq (assign x.1 20)
+              ,(Seq (Assign (Var 'x.1) (Int 20))
-               (seq (assign x.2 22)
+                (Seq (Assign (Var 'x.2) (Int 22))
-                (seq (assign y.1 (+ x.1 x.2))
+                 (Seq (Assign (Var 'y.1) (Prim '+ (list (Var 'x.1) (Var 'x.2))))
-                 (return y.1))))))))
+                  (Return (Var 'y.1)))))))))
 
 (test-eq
  (pass (list-ref programs 3))
- `(program ()
+ (CProgram '()
-           ((start .
+          `((start .
-             (seq (assign a.1 42)
+             ,(Seq (Assign (Var 'a.1) (Int 42))
-                  (seq (assign b.1 a.1)
+               (Seq (Assign (Var 'b.1) (Var 'a.1))
-                       (return b.1)))))))
+                (Return (Var 'b.1))))))))
 
 (test-eq
  (pass (list-ref programs 4))
- `(program ()
+ (CProgram '()
-           ((start .
+           `((start .
-             (seq (assign tmp.1 (- 1))
+              ,(Seq (Assign (Var 'tmp.0) (Prim '- (list (Int 1))))
-                  (seq (assign x.1 (+ tmp.1 2))
+                (Seq (Assign (Var 'x.1) (Prim '+ (list (Var 'tmp.0) (Int 2))))
-                       (seq (assign tmp.2 (+ x.1 2))
+                 (Seq (Assign (Var 'tmp.1) (Prim '+ (list (Var 'x.1) (Int 2))))
-                            (seq (assign tmp.3 (+ 4 5))
+                  (Seq (Assign (Var 'tmp.2) (Prim '+ (list (Int 4) (Int 5))))
-                                 (return (+ tmp.2 tmp.3))))))))))
+                   (Return (Prim '+ (list (Var 'tmp.1) (Var 'tmp.2))))))))))))
+
+(for ([program programs])
+  (test-eq (interp-RVar program)
+           (interp-CVar (pass program))))