Fix grammar produced by explicate-control

explicate-control.scm

@@ -7,7 +7,7 @@
 (define (explicate-control sexp)
   (match sexp
     [`(program ,info ,exp)
-      `(program ,info ,(explicate-control-tail exp))]))
+      `(program ,info ((start . ,(explicate-control-tail exp))))]))
 
 ; after a remove-complex-opera*, all expressions
 ; are compatible with C0

test-explicate-control.scm

@@ -26,34 +26,39 @@
 (test-eq
  (pass (list-ref programs 0))
  `(program ()
-           (return (+ 2 3))))
+           ((start .
+             (return (+ 2 3))))))
 
 (test-eq
  (pass (list-ref programs 1))
  `(program ()
-           (seq (assign tmp.1 (- 2))
+           ((start .
-             (return (+ tmp.1 3)))))
+             (seq (assign tmp.1 (- 2))
+              (return (+ tmp.1 3)))))))
 
 (test-eq
   (pass (list-ref programs 2))
   `(program ()
-     (seq (assign x.1 20)
+            ((start .
-      (seq (assign x.2 22)
+              (seq (assign x.1 20)
-       (seq (assign y.1 (+ x.1 x.2))
+               (seq (assign x.2 22)
-        (return y.1))))))
+                (seq (assign y.1 (+ x.1 x.2))
+                 (return y.1))))))))
 
 (test-eq
  (pass (list-ref programs 3))
  `(program ()
-           (seq (assign a.1 42)
+           ((start .
-                (seq (assign b.1 a.1)
+             (seq (assign a.1 42)
-                     (return b.1)))))
+                  (seq (assign b.1 a.1)
+                       (return b.1)))))))
 
 (test-eq
  (pass (list-ref programs 4))
  `(program ()
-           (seq (assign tmp.1 (- 1)) 
+           ((start .
-                (seq (assign x.1 (+ tmp.1 2)) 
+             (seq (assign tmp.1 (- 1))
-                     (seq (assign tmp.2 (+ x.1 2)) 
+                  (seq (assign x.1 (+ tmp.1 2))
-                          (seq (assign tmp.3 (+ 4 5)) 
+                       (seq (assign tmp.2 (+ x.1 2))
-                               (return (+ tmp.2 tmp.3))))))))
+                            (seq (assign tmp.3 (+ 4 5))
+                                 (return (+ tmp.2 tmp.3))))))))))

test-uncover-locals.scm

@@ -0,0 +1,15 @@
+#lang racket
+
+(require "uncover-locals.scm")
+(require "test-util.scm")
+
+(define programs
+    (list
+     `(program ()
+               ((start . (seq (assign x.1 20) (seq (assign x.2 3) (return (+ x.1 x.2)))))))))
+
+(test-eq
+ (cadr (uncover-locals (list-ref programs 0)))
+ `(locals . (x.1 x.2)))
+
+

uncover-locals.scm

@@ -0,0 +1,22 @@
+#lang racket
+
+(provide uncover-locals)
+
+(define (uncover-locals p)
+  (match p
+    [`(program ,data ,c0-blocks)
+     `(program ,(append data (cons `locals (uncover-locals-blocks c0-blocks))) c0-blocks)]))
+
+(define (uncover-locals-blocks c0-blocks)
+  (if (empty? c0-blocks)
+    `()
+    (append (uncover-locals-block (car c0-blocks)) (uncover-locals-blocks (cdr c0-blocks)))))
+
+(define (uncover-locals-block c0-block)
+  (match c0-block
+   [`(,label . ,tail) (uncover-locals-tail tail)]))
+
+(define (uncover-locals-tail c0-tail)
+  (match c0-tail
+    [`(return ,exp) `()]
+    [`(seq (assign ,var ,exp) ,next) (cons var (uncover-locals-tail next))]))