ast.scm

   1 ;;; definition of ast types
   2
   3 (define-type ast
   4   extender: define-type-of-ast
   5   (parent unprintable:)
   6   subasts)
   7
   8 (define (link-parent! subast parent)
   9   (ast-parent-set! subast parent)
  10   parent)
  11
  12 (define (multi-link-parent! subasts parent)
  13   (for-each (lambda (subast) (link-parent! subast parent))
  14             subasts)
  15   parent)
  16
  17 (define (unlink-parent! subast)
  18   (let ((parent (ast-parent subast)))
  19     (if (and (def-variable? subast) (def-procedure? parent))
  20         (def-procedure-params-set!
  21           parent
  22           (remove subast (def-procedure-params parent)))
  23         (ast-subasts-set!
  24          parent
  25          (remove subast (ast-subasts parent))))
  26     (ast-parent-set! subast #f)
  27     subast))
  28
  29 (define (subast1 ast) (car (ast-subasts ast)))
  30 (define (subast2 ast) (cadr (ast-subasts ast)))
  31 (define (subast3 ast) (caddr (ast-subasts ast)))
  32 (define (subast4 ast) (cadddr (ast-subasts ast)))
  33
  34 (define-type-of-ast def
  35   extender: define-type-of-def
  36   id
  37   unprintable:
  38   refs)
  39
  40 (define-type value
  41   bytes)
  42 (define (new-value bytes)
  43   (make-value bytes))
  44
  45 (define-type byte-cell
  46   adr
  47   (interferes-with unprintable:)
  48   (coalesceable-with unprintable:))
  49 (define (new-byte-cell)
  50   (make-byte-cell #f '() '()))
  51
  52 (define-type byte-lit
  53   val)
  54 (define (new-byte-lit x)
  55   (make-byte-lit x))
  56
  57 (define (nb-bytes type)
  58   (case type
  59     ((void) 0)
  60     ((int) 1) ;; TODO have more types
  61     (else (error "wrong number of bytes ?"))))
  62
  63 (define (int->value n type)
  64   (let ((len (nb-bytes type)))
  65     (let loop ((len len) (n n) (rev-bytes '()))
  66       (if (= len 0)
  67           (new-value (reverse rev-bytes))
  68           (loop (- len 1)
  69                 (arithmetic-shift n -8)
  70                 (cons (new-byte-lit (modulo n 256))
  71                       rev-bytes))))))
  72
  73 (define (extend value type)
  74   value);;;;;;;;;;;;;;;;;;;;;
  75
  76 (define (alloc-value type)
  77   (let ((len (nb-bytes type)))
  78     (let loop ((len len) (rev-bytes '()))
  79       (if (= len 0)
  80           (new-value (reverse rev-bytes)) ;; TODO why reverse, everything is empty
  81           (loop (- len 1)
  82                 (cons (new-byte-cell)
  83                       rev-bytes))))))
  84
  85 (define-type-of-def def-variable
  86   type
  87   value
  88   unprintable:
  89   sets)
  90 (define (new-def-variable subasts id refs type value sets)
  91   (multi-link-parent!
  92    subasts
  93    (make-def-variable #f subasts id refs type value sets)))
  94
  95 (define-type-of-def def-procedure
  96   type
  97   value
  98   params
  99   entry
 100   live-after-calls)
 101 (define (new-def-procedure subasts id refs type value params)
 102   (multi-link-parent!
 103    subasts
 104    (make-def-procedure #f subasts id refs type value params #f '())))
 105
 106
 107 (define-type-of-ast expr
 108   extender: define-type-of-expr
 109   type)
 110
 111 (define-type-of-expr literal
 112   val)
 113 (define (new-literal type val)
 114   (make-literal #f '() type val))
 115
 116 (define-type-of-expr ref
 117   def-var)
 118 (define (new-ref type def)
 119   (make-ref #f '() type def))
 120
 121 (define-type-of-expr oper
 122   op)
 123 (define (new-oper subasts type op)
 124   (multi-link-parent!
 125    subasts
 126    (make-oper #f subasts type op)))
 127
 128 (define-type-of-expr call
 129   def-proc)
 130 (define (new-call subasts type proc-def)
 131   (multi-link-parent!
 132    subasts
 133    (make-call #f subasts type proc-def)))
 134
 135 (define-type-of-ast block
 136   name) ; blocks that begin with a label have a name, the other have #f
 137 (define (new-block subasts)
 138   (multi-link-parent!
 139    subasts
 140    (make-block #f subasts #f)))
 141 (define (new-named-block name subasts)
 142   (multi-link-parent!
 143    subasts
 144    (make-block #f subasts name)))
 145
 146 (define-type-of-ast if)
 147 (define (new-if subasts)
 148   (multi-link-parent!
 149    subasts
 150    (make-if #f subasts)))
 151
 152 (define-type-of-ast switch)
 153 (define (new-switch subasts)
 154   (multi-link-parent!
 155    subasts
 156    (make-switch #f subasts)))
 157
 158 (define-type-of-ast while)
 159 (define (new-while subasts)
 160   (multi-link-parent!
 161    subasts
 162    (make-while #f subasts)))
 163
 164 (define-type-of-ast do-while)
 165 (define (new-do-while subasts)
 166   (multi-link-parent!
 167    subasts
 168    (make-do-while #f subasts)))
 169
 170 (define-type-of-ast for)
 171 (define (new-for subasts)
 172   (multi-link-parent!
 173    subasts
 174    (make-for #f subasts)))
 175
 176 (define-type-of-ast return)
 177 (define (new-return subasts)
 178   (multi-link-parent!
 179    subasts
 180    (make-return #f subasts)))
 181
 182 (define-type-of-ast break)
 183 (define (new-break)
 184   (make-break #f '()))
 185
 186 (define-type-of-ast continue)
 187 (define (new-continue)
 188   (make-continue #f '()))
 189
 190 (define-type-of-ast goto)
 191 (define (new-goto label)
 192   (make-goto #f (list label)))
 193
 194 (define-type-of-ast program)
 195 (define (new-program subasts) ;; TODO add suport for main
 196   (multi-link-parent!
 197    subasts
 198    (make-program #f subasts)))
 199
 200 (define-type op
 201   extender: define-type-of-op
 202   (six-id unprintable:)
 203   id
 204   unprintable:
 205   type-rule
 206   constant-fold
 207   code-gen)
 208
 209 (define-type-of-op op1)
 210 (define-type-of-op op2)