ADT codegen working for simple types

[scheme.git] / codegen.scm

diff --git a/codegen.scm b/codegen.scm
index b90e7cdcefff689f56ce3b9cb911de408949b872..7a37097096882bc4c60d5262c6c81a4c3b9ba371 100644 (file)
--- a/codegen.scm
+++ b/codegen.scm
@@ -363,35 +363,81 @@
     (emit "~a:" exit-label)))
 
 (define (data-tor env e)
-  (and (list? e)
+  (if (not (list? e)) #f    
       (assoc (car e) (flat-map data-tors (env-data-layouts env)))))
 
+                                       ; returns the internal offset in bytes of a product within an ADT
+                                       ; given the constructor layout
+                                       ; constructor-layout: (foo (Int Bool))
+(define (data-product-offset data-layouts type sum index)
+  (let* ([products (cdr (assoc sum (cdr (assoc type data-layouts))))]
+        [to-traverse (list-head products index)])
+    (fold-left
+     (lambda (acc t) (+ acc (type-size data-layouts t)))
+     wordsize ; skip the tag in the first word
+     to-traverse)))
+
+(define (data-sum-tag data-layouts type sum)
+
+  (define (go acc sums)
+    (when (null? sums) (error #f "data-sum-tag no sum for type" sum type))
+    (if (eqv? sum (car sums))
+       acc
+       (go (+ 1 acc) (cdr sums))))
+  (let* ([type-sums (cdr (assoc type data-layouts))])
+    (go 0 (map car type-sums))))
+
 (define (codegen-data-tor e si env)
 
   (define (codegen-destructor tor)
-    (when (not (eqv? 'stack (ast-type (cadr e))))
-      (error #f "expected stack value"))
-    (let* ([stack-expr (cadr e)]
-         [stack-body (caddr stack-expr)]
-         [stack-type (cadr stack-expr)])
-      
-    (codegen-expr stack-body si env)
-    (let ([index (cadr tor)]
-         [products 2]
-         [to-traverse (list-head products index)]
-         [offset (fold-left
-                  (lambda (acc t) (+ acc (type-size t)))
-                  wordsize ; skip tag in first word
-                  to-traverse)])
-      3
-      )))
+    (let* ([res (codegen-expr (cadr e) si env)]
+          [info (cadr tor)]
+          [index (caddr info)]
+          [type (car info)]
+          [sum (cadr info)])
+      (when (not (stack-expr? res))
+       (error #f "codegened something that wasn't a stack expression"))
+                                       ;TODO handle stack types
+      (emit "movq ~a(%rbp), %rax"
+           (- si (data-product-offset (env-data-layouts env) type sum index)))))                                     
+
+  (define (codegen-constructor tor)
+    (let* ([info (cadr tor)]
+          [type (car info)]
+          [sum (cadr info)]
+          [constructor (car e)]
+
+          [args (cdr e)]
+
+          [tag (data-sum-tag (env-data-layouts env)
+                             type
+                             sum)]
+          
+          [insert-product
+           (lambda (expr i)
+             (let ([res (codegen-expr expr si env)]
+                   [stack-offset (- si (data-product-offset (env-data-layouts env)
+                                                            type sum
+                                                            i))])
+               (if (stack-expr? res)
+                   (error #f "todo: handle stack-exprs in stack exprs")
+                   (emit "movq %rax, ~a(%rbp)" stack-offset))))])
+
+                                       ; emit the tag
+      (emit "movq $~a, ~a(%rbp)" tag si)
+      
+      (for-each insert-product args (range 0 (length args)))
+      (type-size (env-data-layouts env) type)))
   
   (let* ([tor (data-tor env e)]
-        [constructor (eqv? 'constructor (cadr tor))])
+        [constructor (eqv? 'constructor (caddr (cadr tor)))])
     (if constructor
        (codegen-constructor tor)
        (codegen-destructor tor))))
 
+(define stack-expr? number?)
+
+                                       ; returns a number if result was stored on stack 
 (define (codegen-expr e si env)
   (emit "# ~a" e)
   (case (ast-type e)
@@ -429,7 +475,7 @@
     ('static-string (emit "movq ~a@GOTPCREL(%rip), %rax"
                          (cadr e)))
 
-    ('stack (error #f "stack value that needs explicit handling" e))
+    ('stack (codegen-expr (caddr e) si env))
 
     (else (error #f "don't know how to codegen this"))))