Assignment 4 / spring 2021

Author: lemonidas

42.rkt

@@ -3,17 +3,24 @@ UNAME := $(shell uname)
 
 ifeq ($(UNAME), Darwin)
   format=macho64
-else ifeq ($(UNAME), Linux)
-  format=elf64
 else
-  format=win64
+  format=elf64
 endif
 
-%.run: %.o main.o
-	gcc main.o $< -o $@
+%.run: %.o runtime.o
+	gcc runtime.o $< -o $@
+
+runtime.o: main.o char.o io.o
+	ld -r main.o char.o io.o -o runtime.o
 
-main.o: main.c
-	gcc -c main.c -o main.o
+main.o: main.c types.h runtime.h
+	gcc -fPIC -c main.c -o main.o
+
+char.o: char.c types.h
+	gcc -fPIC -c char.c -o char.o
+
+io.o: io.c runtime.h
+	gcc -fPIC -c io.c -o io.o
 
 %.o: %.s
 	nasm -f $(format) -o $@ $<
@@ -23,6 +30,3 @@ main.o: main.c
 
 clean:
 	rm *.o *.s *.run
-
-test: 42.run
-	@test "$(shell ./42.run)" = "42"

Makefile

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

README.md

@@ -6,55 +6,70 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; type Expr =
-;; | Integer
-;; | Boolean
-;; | Character
-;; | Variable
-;; | 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.)
+;; | (Eof)
+;; | (Int Integer)
+;; | (Bool Boolean)
+;; | (Char Character)
+;; | (Prim0 Op0)
+;; | (Prim1 Op1 Expr)
+;; | (Prim2 Op2 Expr Expr)
+;; | (PrimVar OpVar (ListOf Expr))
+;; | (If Expr Expr Expr)
+;; | (Begin Expr Expr)
+;; | (Let  (ListOf Binding) Expr)
+;; | (Let* (ListOf Binding) Expr)
+;; | (Var Id)
+;; | (Cond Clauses (Expr))
+
+;; type Clauses = Listof (Expr, Expr)
+;; type Id  = Symbol
+;; type Op0 = 'read-byte
+;; type Op1 = 'add1 | 'sub1 | 'zero? | abs | - | not
+;;          | 'char? | integer? | boolean?
+;;          | 'integer->char | 'char->integer
+;;          | 'write-byte | 'eof-object?
+;; type Op2 = '+ | '-
+;; type OpVar = '+ 
+;; type Binding = (Id, Expr)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;;;; The AST data structure
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; The AST can be viewed as having 'kinds' of nodes.
 ;;
-;; * The nodes that represnt an expression themselves
+;; * The nodes that represent 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)
+(struct Eof   ()         #:prefab)
+(struct Int   (i)        #:prefab)
+(struct Bool  (b)        #:prefab)
+(struct Char  (c)        #:prefab)
+(struct Prim0 (p)        #:prefab)
+(struct Prim1 (p e)      #:prefab)
+(struct Prim2 (p e1 e2)  #:prefab)
+(struct PrimVar (p es)   #:prefab)
+(struct If    (e1 e2 e3) #:prefab)
+(struct Begin (e1 e2)    #:prefab)
+(struct Let   (bs e)     #:prefab)
+(struct Let*  (bs e)     #:prefab)
+(struct Var   (x)        #:prefab)
+(struct Cond  (cs e)     #:prefab)
 
 ;; 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 clause takes an _arbitrary_ expression and a body.
+(struct Clause  (e body) #:prefab)
 
 ;; 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)
+(struct Binding (v e) #:prefab)
+
+;; Finally, here's a struct to return when an expression is ill-formed.
+(struct IllFormedError () #:prefab)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;;;; AST utility functions (getters)
@@ -66,50 +81,27 @@
 (define (get-vars bs)
   (match bs
     ['() '()]
-    [(cons (binding v _) bs) (cons v (get-vars 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))]))
+    [(cons (Binding _ def) bs) (cons def (get-defs bs))]))
 
 
 ;; Get all of the predicate expressions from a list of clauses
-;; [Binding] -> [Expr]
+;; [Clause] -> [Expr]
 (define (get-preds cs)
   (match cs
     ['() '()]
-    [(cons (clause p _) cs) (cons p (get-preds cs))]))
+    [(cons (Clause p _) cs) (cons p (get-preds cs))]))
 
 ;; Get all of the bodies expressions from a list of clauses
-;; [Binding] -> [Expr]
+;; [Clause] -> [Expr]
 (define (get-bods cs)
   (match cs
     ['() '()]
-    [(cons (clause _ b) cs) (cons b (get-preds cs))]))
-
-;; 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))]))
-
-(define (binding->sexpr bnds)
-  (match bnds
-    ['() '()]
-    [(cons (binding v e) bnds) `((,v ,(ast->sexpr e)) ,@(binding->sexpr bnds))]))
+    [(cons (Clause _ b) cs) (cons b (get-preds cs))]))
 
-(define (clauses->sexpr cs)
-  (match cs
-    ['() '()]
-    [(cons (clause e b) cs) `((,(ast->sexpr e) ,(ast->sexpr b)) ,@(clauses->sexpr cs))]))

asm/ast.rkt

@@ -0,0 +1,57 @@
+#include <stdio.h>
+#include <inttypes.h>
+#include "types.h"
+
+void print_codepoint(int64_t);
+
+void print_char (int64_t v) {
+  int64_t codepoint = v >> char_shift;
+  printf("#\\");
+  switch (codepoint) {
+  case 0:
+    printf("nul"); break;
+  case 8:
+    printf("backspace"); break;
+  case 9:
+    printf("tab"); break;
+  case 10:
+    printf("newline"); break;
+  case 11:
+    printf("vtab"); break;
+  case 12:
+    printf("page"); break;
+  case 13:
+    printf("return"); break;
+  case 32:
+    printf("space"); break;
+  case 127:
+    printf("rubout"); break;
+  default:
+    print_codepoint(v);
+  }
+}
+
+void print_codepoint(int64_t v) {
+  int64_t codepoint = v >> char_shift;
+  // Print using UTF-8 encoding of codepoint
+  // https://en.wikipedia.org/wiki/UTF-8
+  if (codepoint < 128) {
+    printf("%c", (char) codepoint);
+  } else if (codepoint < 2048) {
+    printf("%c%c",
+	   (char)(codepoint >> 6) | 192,
+	   ((char)codepoint & 63) | 128);
+  } else if (codepoint < 65536) {
+    printf("%c%c%c",
+	   (char)(codepoint >> 12) | 224,
+	   ((char)(codepoint >> 6) & 63) | 128,
+	   ((char)codepoint & 63) | 128);
+  } else {
+    printf("%c%c%c%c",
+	   (char)(codepoint >> 18) | 240,
+	   ((char)(codepoint >> 12) & 63) | 128,
+	   ((char)(codepoint >> 6) & 63) | 128,
+	   ((char)codepoint & 63) | 128);
+  }
+}
+