Release draft

Author: lemonidas

42.rkt

@@ -1,2 +1,4 @@
 #lang racket
-42
+(string-ref (make-string 7 #\x) 4)
+
+

Makefile

@@ -3,20 +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 char.o
-	gcc main.o char.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 types.h
-	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 -c char.c -o char.o
+	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 $@ $<
@@ -26,6 +30,3 @@ char.o: char.c types.h
 
 clean:
 	rm *.o *.s *.run
-
-test: 42.run
-	@test "$(shell ./42.run)" = "42"

asm/ast.rkt

@@ -1,163 +1,43 @@
 #lang racket
 (provide (all-defined-out))
 
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;;;;; The grammar of our AST
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;; type Expr =
-;; | Integer
-;; | Boolean
-;; | Character
-;; | Variable
-;; | String
-;; | Prim1 Expr
-;; | Prim2 Expr Expr
-;; | If Expr Expr Expr
-;; | cond (Clause list) Expr
-;; | Let (Binding list) Expr
-;; | Nil
-
-;; type Prim1 =
-;; | 'add1 | 'sub1 | 'zero? | box | unbox | car | cdr
-;; | 'integer? | 'boolean? | 'char? | 'integer->char | 'char->integer
-
-;; type Prim2 = '+ | '- | cons
-
-;; type Binding = Variable Expr
-
-;; type Variable = Symbol (except 'add1 'sub1 'if, 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 string-e (s)   #:transparent)
-(struct var-e  (v)     #:transparent)
-(struct prim-e (p es)  #:transparent)
-(struct if-e   (e t f) #:transparent)
-(struct cond-e (cs el) #:transparent)
-(struct let-e  (bs b)  #:transparent)
-(struct nil-e  ()      #: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 (predicates)
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;; Any -> Boolean
-;; Is x a unary primitive?
-(define (prim1? x)
-  (and (symbol? x)
-       (memq x '(add1 sub1 abs - integer->char char->integer
-                 car cdr length box?  string?  cons?  empty?
-                 box unbox string-length
-                 char? integer? boolean? zero?))))
-
-;; Any -> Boolean
-;; Is x a binary primitive?
-(define (prim2? x)
-  (and (symbol? x)
-       (memq x '(+ cons string-ref make-string char=?
-                 = <= < char=? boolean=? -))))
-
-(define (prim? x)
-  (or (prim1? x)
-      (prim2? x)))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;;;;; AST utility functions (getters)
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;; Expr -> Value
-(define (get-val v)
-  (match v
-    [(int-e x) x]
-    [(bool-e x) x]
-    [(char-e x) x]
-    [(string-e x) x]
-    [(nil-e) '()]))
-
-;; 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
-;; [Clause] -> [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
-;; [Clause] -> [Expr]
-(define (get-bods cs)
-  (match cs
-    ['() '()]
-    [(cons (clause _ b) cs) (cons b (get-preds cs))]))
-
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;;;;; AST utility functions (printers)
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;; We have switched to using `#:transparent` above, so this should only be
-;; necessary if you're desperate when debugging :'(
-
-;; Given an AST, construct an sexpr that has the same shape
-(define (ast-debug a)
-  (match a
-    [(int-e i)     `(int-e ,i)]
-    [(bool-e b)    `(bool-e ,b)]
-    [(char-e b)    `(char-e ,b)]
-    [(string-e s)  `(string-e ,s)]
-    [(var-e v)     `(var-e ,v)]
-    [(nil-e)       ''()]
-    [(prim-e p es) `(prim-e ,p ,@(map ast-debug es))]
-    [(if-e e t f)  `(if-e ,(ast-debug e)
-                          ,(ast-debug t)
-                          ,(ast-debug f))]
-    [(cond-e cs f) `(cond-e ,(clauses-debug cs) ,(ast-debug f))]
-    [(let-e bs b)  `(let-e ,(binding-debug bs) ,(ast-debug b))]))
-
-(define (binding-debug bnds)
-  (match bnds
-    ['() '()]
-    [(cons (binding v e) bnds) `((,v ,(ast-debug e)) ,@(binding-debug bnds))]))
-
-(define (clauses-debug cs)
-  (match cs
-    ['() '()]
-    [(cons (clause e b) cs) `((,(ast-debug e) ,(ast-debug b)) ,@(clauses-debug cs))]))
+;; type Expr = (Eof)
+;;           | (Empty)
+;;           | (Int Integer)
+;;           | (Bool Boolean)
+;;           | (Char Character)
+;;           | (String String)
+;;           | (Prim0 Op0)
+;;           | (Prim1 Op1 Expr)
+;;           | (Prim2 Op2 Expr Expr)
+;;           | (If Expr Expr Expr)
+;;           | (Begin Expr Expr)
+;;           | (Let Id Expr Expr)
+;;           | (Var Id)
+;; type Id   = Symbol
+;; type Op0  = 'read-byte
+;; type Op1  = 'add1 | 'sub1 | 'zero?
+;;           | 'char? | 'integer->char | 'char->integer
+;;           | 'string? | 'string-length 
+;;           | 'write-byte | 'eof-object?
+;;           | 'box | 'car | 'cdr | 'unbox
+;;           | 'empty?
+;;           | 'box? | 'cons? | 
+;; type Op2  = '+ | '- | 'eq?
+;;           | 'string-ref | 'make-string
+;;           | 'cons
+;;           | '= | '< | '<= | 'char=? | 'boolean=?
+(struct Eof    ()           #:prefab)
+(struct Empty  ()           #:prefab)
+(struct Int    (i)          #:prefab)
+(struct Bool   (b)          #:prefab)
+(struct Char   (c)          #:prefab)
+;; Added in HUSTLE+
+(struct String (s)          #:prefab)
+(struct Prim0  (p)          #:prefab)
+(struct Prim1  (p e)        #:prefab)
+(struct Prim2  (p e1 e2)    #:prefab)
+(struct If     (e1 e2 e3)   #:prefab)
+(struct Begin  (e1 e2)      #:prefab)
+(struct Let    (x e1 e2)    #:prefab)
+(struct Var    (x)          #:prefab)