Remove trailing space and (- x x) matching

c1.scm

@@ -9,54 +9,54 @@
   (let ([r (read)])
     (cond
        [(fixnum? r) r]
-       [else (error "invalid fixnum in input: " r)]
-    )))
+       [else (error "invalid fixnum in input: " r)])))
+
 
 (define (interp-exp sexp)
   (match sexp
     [(? fixnum?) sexp]
     [`(read) (read-fixnum)]
     [`(- ,e) (fx- 0 (interp-exp e))]
-    [`(+ ,e1 ,e2) (fx+ (interp-exp e1) (interp-exp e2))]
-  ))
+    [`(+ ,e1 ,e2) (fx+ (interp-exp e1) (interp-exp e2))]))
+
 
 (define (interp-R0 p)
   (match p
-    [`(program ,e) (interp-exp e)]
-  ))
+    [`(program ,e) (interp-exp e)]))
+
 
 
 (define (pe-arith p)
   (match p
-    [`(program ,e) (pe-exp e)]
-  ))
+    [`(program ,e) (pe-exp e)]))
+
 
 (define (pe-exp exp)
-    (pe-remove-node-labels (pe-fold-right-constants (pe-move-reads-left (pe-do-negate exp))))
-  )
+    (pe-remove-node-labels (pe-fold-right-constants (pe-move-reads-left (pe-do-negate exp)))))
+
 
 ; removes R/C/S labels from a tree
 (define (pe-remove-node-labels tree)
   (match tree
     [`((+ ,e1 ,e2) ,_) `(+ ,(pe-remove-node-labels e1) ,(pe-remove-node-labels e2))]
     [`(,e C) e]
-    [`(,e R) e]
-  ))
+    [`(,e R) e]))
+
 
 ; partially evaluates an S/R/C-tree
 (define (pe-fold-right-constants exp)
   (match exp
     [`(,_ S)  (make-S-node (node-S-left exp) `(,(pe-fold-constants (node-S-right exp)) C))]
     [`(,_ C) `(,(pe-fold-constants exp) C)]
-    [`(,_ R) exp]
-  ))
+    [`(,_ R) exp]))
+
 
 ; evaluates a C-tree and returns the integer result
 (define (pe-fold-constants c-tree)
    (match c-tree
      [`((+ ,e1 ,e2) C) (fx+ (pe-fold-constants e1) (pe-fold-constants e2))]
-     [`(,e C) e]
-   ))
+     [`(,e C) e]))
+
 
 ; pushes down negation to literals, inside additions and elides multiple consecutive negations
 (define (pe-do-negate exp)
@@ -65,8 +65,8 @@
     [`(- (+ ,e1 ,e2)) (pe-do-negate `(+ (- ,e1) (- ,e2)))]
     [`(+ ,e1 ,e2)     `(+ ,(pe-do-negate e1) ,(pe-do-negate e2))]
     [`(- ,e)          (if (fixnum? e) (fx- 0 e) `(- ,(pe-do-negate e)))]
-    [_                exp]
-  ))
+    [_                exp]))
+
 
 ; takes an exepression and transforms it in an equivalent form such that it is either
 ; - a tree of C nodes
@@ -84,9 +84,9 @@
      [`(+ ,e1 ,e2)
       (let ([e1-rl (pe-move-reads-left e1)]
             [e2-rl (pe-move-reads-left e2)])
-        (pe-join-subtrees e1-rl e2-rl)
-      )]
-  ))
+        (pe-join-subtrees e1-rl e2-rl))]))
+
+
 
 ; join two subtrees and forms either a new C-tree, a new R-tree or a new S-tree
 (define (pe-join-subtrees e1-rl e2-rl)
@@ -96,50 +96,50 @@
        [(and (node-is-R e1-rl) (node-is-C e2-rl))  (make-S-node e1-rl e2-rl)]
        [(and (node-is-C e1-rl) (node-is-R e2-rl))  (make-S-node e2-rl e1-rl)]
        [(node-is-S e1-rl)
-          (cond
-             [(node-is-C e2-rl) (make-S-node
-                                   (node-S-left e1-rl)
-                                   (make-C-node (node-S-right e1-rl) e2-rl))]
-             [(node-is-R e2-rl) (make-S-node
-                                   (make-R-node (node-S-left e1-rl) e2-rl)
-                                   (node-S-right e1-rl))]
-             [(node-is-S e2-rl) (make-S-node
-                                   (make-R-node (node-S-left e1-rl) (node-S-left e2-rl))
-                                   (make-C-node (node-S-right e1-rl) (node-S-right e2-rl)))]
-          )]
-       [(node-is-S e2-rl) (pe-join-subtrees e2-rl e1-rl)]
-     )
-  )
+        (cond
+           [(node-is-C e2-rl) (make-S-node
+                                 (node-S-left e1-rl)
+                                 (make-C-node (node-S-right e1-rl) e2-rl))]
+           [(node-is-R e2-rl) (make-S-node
+                                 (make-R-node (node-S-left e1-rl) e2-rl)
+                                 (node-S-right e1-rl))]
+           [(node-is-S e2-rl) (make-S-node
+                                 (make-R-node (node-S-left e1-rl) (node-S-left e2-rl))
+                                 (make-C-node (node-S-right e1-rl) (node-S-right e2-rl)))])]
+
+       [(node-is-S e2-rl) (pe-join-subtrees e2-rl e1-rl)]))
+
+
 
 (define (node-is-C n)
   (match n
     [`(,_ C) #t]
-    [_       #f]
-  ))
+    [_       #f]))
+
 
 (define (node-is-R n)
   (match n
     [`(,_ R) #t]
-    [_       #f]
-  ))
+    [_       #f]))
+
 
 (define (node-is-S n)
   (match n
     [`(,_ S) #t]
-    [_       #f]
-  ))
+    [_       #f]))
+
 
 (define (node-S-left n)
   (match n
     [`((+ ,e1 ,_) S) e1]
-    [_ (error "cannot be here! (S left)")]
-  ))
+    [_ (error "cannot be here! (S left)")]))
+
 
 (define (node-S-right n)
   (match n
     [`((+ ,_ ,e2) S) e2]
-    [_ (error "cannot be here! (S right)")]
-  ))
+    [_ (error "cannot be here! (S right)")]))
+
 
 (define (make-S-node r c)
   `((+ ,r ,c) S))
@@ -151,33 +151,32 @@
   `((+ ,r1 ,r2) R))
 
 (define (test-eq a b)
-   (if (equal? a b) #t (error "assert failed: " a " != " b) ))
+   (if (equal? a b) #t (error "assert failed: " a " != " b)))
 
 (define (test-pe-eq a b) (test-eq (pe-exp a) b))
-(define (ppn exp) (begin (print (pe-exp exp)) (newline) ))
+(define (ppn exp) (begin (print (pe-exp exp)) (newline)))
 
 (test-eq (pe-do-negate `(- 3)) -3)
-(test-eq (pe-do-negate `(- (+ 3 4)) ) `(+ -3 -4) )
-(test-eq (pe-do-negate `(- (+ 2 (- (read)))) ) `(+ -2 (read)) )
-(test-eq (pe-do-negate `(+ (- 1) (- (- 2))) ) `(+ -1 2) )
-(test-eq (pe-do-negate `(- (- (- (+ (read) 1)))) ) `(+ (- (read)) -1) )
+(test-eq (pe-do-negate `(- (+ 3 4)) ) `(+ -3 -4))
+(test-eq (pe-do-negate `(- (+ 2 (- (read)))) ) `(+ -2 (read)))
+(test-eq (pe-do-negate `(+ (- 1) (- (- 2))) ) `(+ -1 2))
+(test-eq (pe-do-negate `(- (- (- (+ (read) 1)))) ) `(+ (- (read)) -1))
 
 (test-eq (node-is-C `(1 C)) #t)
 
 (test-eq (pe-move-reads-left `1) `(1 C))
-(test-eq (pe-move-reads-left `(+ 1 1) ) `((+ (1 C) (1 C)) C) )
-(test-eq (pe-move-reads-left `(+ 1 (read)) ) `((+ ((read) R) (1 C)) S) )
-(test-eq (pe-move-reads-left `(+ (read) (read)) ) `((+ ((read) R) ((read) R)) R) )
-(test-eq (pe-move-reads-left `(+ (- (read)) -2) ) `((+ ((- (read)) R) (-2 C)) S) )
+(test-eq (pe-move-reads-left `(+ 1 1) ) `((+ (1 C) (1 C)) C))
+(test-eq (pe-move-reads-left `(+ 1 (read)) ) `((+ ((read) R) (1 C)) S))
+(test-eq (pe-move-reads-left `(+ (read) (read)) ) `((+ ((read) R) ((read) R)) R))
+(test-eq (pe-move-reads-left `(+ (- (read)) -2) ) `((+ ((- (read)) R) (-2 C)) S))
 
 (test-eq (pe-fold-constants `((+ (1 C) (-3 C)) C) ) -2)
 (test-eq (pe-fold-right-constants `((+ (1 C) (-3 C)) C) ) `(-2 C))
-(test-eq (pe-fold-right-constants `((+ ((read) R) ((+ (1 C) (-3 C)) C)) S) )
-                                  `((+ ((read) R) (-2 C)) S) )
+(test-eq (pe-fold-right-constants `((+ ((read) R) ((+ (1 C) (-3 C)) C)) S))
+         `((+ ((read) R) (-2 C)) S))
 
-(test-eq (pe-remove-node-labels `((read) R) ) `(read) )
-(test-eq (pe-remove-node-labels `((+ ((read) R) ((read) R)) R) ) `(+ (read) (read)) )
-(test-eq (pe-remove-node-labels `((+ ((- (read)) R) (-2 C)) S) ) `(+ (- (read)) -2) )
-
-(test-eq (pe-exp `(+ (- (+ (read) 9)) (+ (+ (read) 1) 5)) ) `(+ (+ (- (read)) (read)) -3) )
+(test-eq (pe-remove-node-labels `((read) R) ) `(read))
+(test-eq (pe-remove-node-labels `((+ ((read) R) ((read) R)) R) ) `(+ (read) (read)))
+(test-eq (pe-remove-node-labels `((+ ((- (read)) R) (-2 C)) S) ) `(+ (- (read)) -2))
 
+(test-eq (pe-exp `(+ (- (+ (read) 9)) (+ (+ (read) 1) 5)) ) `(+ (+ (- (read)) (read)) -3))

remove-complex-oper.scm

@@ -41,13 +41,12 @@
      (begin
       (define-values (new-exp assoc-list new-tmpcount) (rco-arg e tmpcount))
       (values (wrap-associations assoc-list `(- ,new-exp)) new-tmpcount))]
-    [`(,op ,e1 ,e2)
-     #:when (or (eq? op `+) (eq? op `-))
+    [`(+ ,e1 ,e2)
      (begin
       (define-values (new-exp1 assoc-list1 new-tmpcount1) (rco-arg e1 tmpcount))
       (define-values (new-exp2 assoc-list2 new-tmpcount) (rco-arg e2 new-tmpcount1))
       (values (wrap-associations (append assoc-list1 assoc-list2)
-                                 `(,op ,new-exp1 ,new-exp2)) new-tmpcount))]
+                                 `(+ ,new-exp1 ,new-exp2)) new-tmpcount))]
     [`(let ([,var ,e]) ,body)
      (begin
       (define-values (exp-tmp exp-tmpcount) (rco-exp e tmpcount))