Fall 2020 here we go

Author: jmct

Diff for: README.md

@@ -2,4 +2,4 @@
 
 Assignment 4: Variables, Binding, and Characters
 
-See: http://www.cs.umd.edu/class/spring2020/cmsc430/Assignments.html
+See: http://www.cs.umd.edu/class/fall2020/cmsc430/Assignments.html

Diff for: ast.rkt

@@ -1,20 +1,115 @@
 #lang racket
+(provide (all-defined-out))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;; The grammar of our AST
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
 ;; type Expr =
 ;; | Integer
 ;; | Boolean
 ;; | Character
 ;; | Variable
-;; | `(,Prim ,Expr)
-;; | `(if ,Expr ,Expr ,Expr)
-;; | `(cond ,@Clauses [else ,Expr])
-;; | `(let ,Bindings ,Expr)
-;; | `(let* ,Bindings ,Expr)
+;; | Prim PrimOp Expr
+;; | if Expr Expr Expr
+;; | cond (Clause list) Expr
+;; | let (Binding list) Expr
+
+;; type PrimOp =
+;; | add1 | sub1 | zero? | abs | - | char? | integer? | boolean?
+;; | integer->char | char->integer
+
+;; type Clause = Expr Expr
+;; type Binding = Variable Expr
+
+;; type Variable = Symbol (except 'let, 'add1, etc.)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;; The AST data structure
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; The AST can be viewed as having 'kinds' of nodes.
+;;
+;; * The nodes that represnt an expression themselves
+;;
+;; * The nodes that are part of an expression, but no an expression themselves
+
+;; The below are the former:
+
+(struct int-e  (i) #:transparent)
+(struct bool-e (b) #:transparent)
+(struct char-e (c) #:transparent)
+(struct var-e  (v) #:transparent)
+(struct prim-e (p e) #:transparent)
+(struct if-e   (e t f) #:transparent)
+(struct cond-e (cs el) #:transparent)
+(struct let-e  (bs b) #:transparent)
+
+;; The next two are the latter:
+
+;; a clause now takes an _arbitrary_ expression and a body.
+;; This is different than assignment 3! If you want to understand
+;; why, look at the lecture notes for Dupe.
+(struct clause  (e body) #:transparent)
+
+;; A binding holds a symbol representing the bound variable and
+;; Expr that represents the value that will be bound to that variable
+(struct binding (v e) #:transparent)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;; AST utility functions (getters)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; It will sometimes be useful to get the list of all the variables that are
+;; introduced by a `let`
+;; [Binding] -> [Symbol]
+(define (get-vars bs)
+  (match bs
+    ['() '()]
+    [(cons (binding v _) bs) (cons v (get-vars bs))]))
+
+;; Get all of the _definitions_ from a list of bindings
+;; [Binding] -> [Expr]
+(define (get-defs bs)
+  (match bs
+    ['() '()]
+    [(cons (binding _ def) bs) (cons def (get-defs bs))]))
+
+
+;; Get all of the predicate expressions from a list of clauses
+;; [Binding] -> [Expr]
+(define (get-preds cs)
+  (match cs
+    ['() '()]
+    [(cons (clause p _) cs) (cons p (get-preds cs))]))
+
+;; Get all of the bodies expressions from a list of clauses
+;; [Binding] -> [Expr]
+(define (get-bods cs)
+  (match cs
+    ['() '()]
+    [(cons (clause _ b) cs) (cons b (get-preds cs))]))
 
-;; type Prim =
-;; | 'add1 | 'sub1 | 'zero? | 'abs | '- | 'char? | 'integer? | 'boolean?
-;; | 'integer->char | 'char->integer
+;; Given an AST, construct an sexpr that has the same shape
+(define (ast->sexpr a)
+  (match a
+    [(int-e i)     `(int-e ,i)]
+    [(bool-e b)    `(bool-e ,b)]
+    [(char-e c)    `(char-e ,c)]
+    [(var-e v)     `(var-e ,v)]
+    [(prim-e p e)  `(prim-e ,p ,e)]
+    [(if-e e t f)  `(if-e ,(ast->sexpr e)
+                          ,(ast->sexpr t)
+                          ,(ast->sexpr f))]
+    [(cond-e cs f) `(cond-e ,(clauses->sexpr cs) ,(ast->sexpr f))]
+    [(let-e bs b)  `(let-e ,(binding->sexpr bs) ,(ast->sexpr b))]))
 
-;; type Clauses = (Listof `(,Expr ,Expr))
-;; type Bindings = (Listof `(,Variable ,Expr))
+(define (binding->sexpr bnds)
+  (match bnds
+    ['() '()]
+    [(cons (binding v e) bnds) `((,v ,(ast->sexpr e)) ,@(binding->sexpr bnds))]))
 
-;; type Variable = Symbol (except 'let, 'let*, 'add1, etc.)
+(define (clauses->sexpr cs)
+  (match cs
+    ['() '()]
+    [(cons (clause e b) cs) `((,(ast->sexpr e) ,(ast->sexpr b)) ,@(clauses->sexpr cs))]))

Diff for: compile.rkt

@@ -1,5 +1,15 @@
 #lang racket
 (provide (all-defined-out))
+(require "ast.rkt")
+
+;; This assignment should be completed individually.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; I pledge on my honor that I have not given or received any
+;; unauthorized assistance on this assignment.
+;;
+;; Name: TODO
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Expr -> Asm
 (define (compile e)
@@ -10,35 +20,24 @@
     (push rbp) ; push before calling
     (call error)))
 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;; Compiling expressions and their sub-parts
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; You'll need to add the ability to compile `char-e` nodes
+
 ;; Expr CEnv -> Asm
 (define (compile-e e c)
   (match e
-    [(? integer? i)
+    [(int-e i)
      `((mov rax ,(* i 4)))]
-    [(? boolean? b)
+    [(bool-e b)
      `((mov rax ,(if b #b101 #b001)))]
-    [`(add1 ,e0)
-     (let ((c0 (compile-e e0 c)))
-       `(,@c0
-         ,@assert-integer
-         (add rax 4)))]
-    [`(sub1 ,e0)
+    [(prim-e p e0)
      (let ((c0 (compile-e e0 c)))
-       `(,@c0
-         ,@assert-integer
-         (sub rax 4)))]
-    [`(zero? ,e0)
-     (let ((c0 (compile-e e0 c))
-           (l0 (gensym))
-           (l1 (gensym)))
-       `(,@c0
-         ,@assert-integer
-         (cmp rax 0)
-         (mov rax #b001) ; #f         
-         (jne ,l0)
-         (mov rax #b101) ; #t
-         ,l0))]    
-    [`(if ,e0 ,e1 ,e2)
+          `(,@c0
+            ,@(compile-prim p)))]
+    [(if-e e0 e1 e2)
      (let ((c0 (compile-e e0 c))
            (c1 (compile-e e1 c))
            (c2 (compile-e e2 c))
@@ -54,23 +53,46 @@
          ,l1))]
 
     ;; TODO: make sure this works with your generalized let
-    [(? symbol? x)
-     (let ((i (lookup x c)))
+    [(var-e v)
+     (let ((i (lookup v c)))
        `((mov rax (offset rsp ,(- (add1 i))))))]
 
     ;; TODO: generalize
-    [`(let ((,x ,e0)) ,e1)
-     (let ((c0 (compile-e e0 c))
-           (c1 (compile-e e1 (cons x c))))
+    [(let-e (list (binding x def)) bod)
+     (let ((c0 (compile-e def c))
+           (c1 (compile-e bod (cons x c))))
        `(,@c0
          (mov (offset rsp ,(- (add1 (length c)))) rax)
          ,@c1))]
 
+    ;; TODO
+    #;...))
 
+(define (compile-prim p)
+  (match p
+    ['add1 `(,@assert-integer
+             (add rax 4))]
+    ['sub1 `(,@assert-integer
+             (sub rax 4))]
+    ['zero?
+     (let ((l0 (gensym))
+           (l1 (gensym)))
+       `(,@assert-integer
+         (cmp rax 0)
+         (mov rax #b001) ; #f
+         (jne ,l0)
+         (mov rax #b101) ; #t
+         ,l0))]
+
+    ;; Primitives still left: char?, integer?, boolean?,
+    ;; char->integer, integer->char, neg, abs.
+    ;; You should be able to harvest a significant amount from your submission
+    ;; to assignment#3
     ;; TODO
     #;...))
 
 
+
 ;; Variable CEnv -> Natural
 (define (lookup x cenv)
   (match cenv

Diff for: interp.rkt

@@ -1,5 +1,8 @@
 #lang racket
 (provide (all-defined-out))
+(require (only-in "syntax.rkt" prim?))
+
+(require "ast.rkt")
 
 ;; type Value =
 ;; | Integer
@@ -17,40 +20,28 @@
 ;; Expr REnv -> Answer
 (define (interp-env e r)
   (match e
-    [(? value? v) v]
-    [(list (? prim? p) e)
+    [(int-e i) i]
+    [(bool-e b) b]
+    [(char-e c) c]
+    [(prim-e p e)
      (let ((a (interp-env e r)))
        (interp-prim p a))]
-    [`(if ,e0 ,e1 ,e2)
-     (match (interp-env e0 r)
+    [(if-e i t f)
+     (match (interp-env i r)
        ['err 'err]
        [v
         (if v
-            (interp-env e1 r)
-            (interp-env e2 r))])]    
-    [(? symbol? x)
-     (lookup r x)]
-    [`(let ,(list `(,xs ,es) ...) ,e)
-     (match (interp-envs es r)
-       ['err 'err]
-       [vs
-        (if (any-err? vs)
-          'err
-          (interp-env e (append (zip xs vs) r)))])]
-    [`(let* ,(list bs ...) ,e)
-     (match (map-accum-env bs r)
-       ['err 'err]
-       [new-r
-        (interp-env e new-r)])]
-    [(list 'cond cs ... `(else ,en))
-     (interp-cond-env cs en r)]))
-
-(define (any-err? xs)
-  (match xs
-    ['() #f]
-    ['err #t]
-    [(cons y ys)
-     (if (eq? 'err y) #t (any-err? ys))]))
+            (interp-env t r)
+            (interp-env f r))])]    
+    [(var-e v)
+     (lookup r v)]
+    [(let-e (list (binding xs es) ...) b)
+      (match (interp-envs es r)
+        ['err 'err]
+        [vs
+          (interp-env b (append (zip xs vs) r))])]
+    [(cond-e cs f)
+      (interp-cond-env cs f r)]))
 
 ;; (Listof Expr) REnv -> (Listof Value) | 'err
 (define (interp-envs es r)
@@ -61,42 +52,22 @@
        ['err 'err]
        [v (cons v (interp-envs es r))])]))
 
-;; (Listof (Symbol Expr)) REnv -> REnv | 'err 
-(define (map-accum-env bs r)
-  (match bs
-    ['() r]
-    [(cons (list b e) bss)
-     (match (interp-env e r)
-       ['err 'err]
-       [v (map-accum-env bss (cons (list b v) r))])]))
-
-;; (Listof (List Expr Expr)) Expr REnv -> Answer
-(define (interp-cond-env cs en r)
+;; (Listof (clause i b)) Expr REnv -> Answer
+(define (interp-cond-env cs f r)
   (match cs
-    ['() (interp-env en r)]
-    [(cons `(,eq ,ea) cs)
-     (match (interp-env eq r)
+    ['() (interp-env f r)]
+    [(cons (clause i b) css)
+     (match (interp-env i r)
        ['err 'err]
        [v
         (if v
-            (interp-env ea r)
-            (interp-cond-env cs en r))])]))
-
-;; Any -> Boolean
-(define (prim? x)
-  (and (symbol? x)
-       (memq x '(add1 sub1 zero? abs - char? boolean? integer? integer->char char->integer))))
-
-;; Any -> Boolean
-(define (value? x)
-  (or (integer? x)
-      (boolean? x)
-      (char? x)))
+            (interp-env b r)
+            (interp-cond-env css f r))])]))
 
 ;; Prim Answer -> Answer
 (define (interp-prim p a)
   (match (list p a)
-    [(list p 'err) 'err]
+    [(list _  'err) 'err]
     [(list '- (? integer? i0)) (- i0)]    
     [(list 'abs (? integer? i0)) (abs i0)]
     [(list 'add1 (? integer? i0)) (+ i0 1)]

Diff for: lex.rkt

@@ -52,7 +52,7 @@
 (define prims
   '("add1" "sub1" "zero?" "abs" "-" "integer->char" "char->integer" "char?" "integer?" "boolean?"))
 
-(define kws '("cond" "if" "let" "let*" "else"))
+(define kws '("cond" "if" "let" "else"))
 
 (define delim
   (string-append "$|"

Diff for: main.c

@@ -27,7 +27,7 @@ int main(int argc, char** argv) {
 }
 
 void error() {
-  printf("err");
+  printf("err\n");
   exit(1);
 }