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 ;; TODO really in ast ?
  46 (define-type byte-cell
  47   adr
  48   (interferes-with unprintable:)
  49   (coalesceable-with unprintable:))
  50 (define (new-byte-cell)
  51   (make-byte-cell #f '() '()))
  52 (define (get-register n)
  53   (make-byte-cell n '() '()))
  54
  55 (define-type byte-lit
  56   val)
  57 (define (new-byte-lit x)
  58   (make-byte-lit x))
  59
  60 (define (nb-bytes type)
  61   (case type
  62     ((void)  0) ;; TODO have more types
  63     ((byte)  1)
  64     ((int8)  1)
  65     ((int16) 2)
  66     ((int32) 4)
  67     ((int)   4) ;; TODO should the default int be 32 bits ?
  68     (else (error "wrong number of bytes ?"))))
  69
  70 (define (int->value n type)
  71   (let ((len (nb-bytes type)))
  72     (let loop ((len len) (n n) (rev-bytes '()))
  73       (if (= len 0)
  74           (new-value (reverse rev-bytes))
  75           (loop (- len 1)
  76                 (arithmetic-shift n -8)
  77                 (cons (new-byte-lit (modulo n 256))
  78                       rev-bytes))))))
  79
  80 (define (extend value type)
  81   value);;;;;;;;;;;;;;;;;;;;;
  82
  83 (define (alloc-value type)
  84   (let ((len (nb-bytes type)))
  85     (let loop ((len len) (rev-bytes '()))
  86       (if (= len 0)
  87           (new-value (reverse rev-bytes)) ;; TODO why reverse, everything is empty
  88           (loop (- len 1)
  89                 (cons (new-byte-cell)
  90                       rev-bytes))))))
  91
  92 (define-type-of-def def-variable
  93   type
  94   value
  95   unprintable:
  96   sets)
  97 (define (new-def-variable subasts id refs type value sets)
  98   (multi-link-parent!
  99    subasts
 100    (make-def-variable #f subasts id refs type value sets)))
 101
 102 (define-type-of-def def-procedure
 103   type
 104   value
 105   params
 106   entry
 107   live-after-calls)
 108 (define (new-def-procedure subasts id refs type value params)
 109   (multi-link-parent!
 110    subasts
 111    (make-def-procedure #f subasts id refs type value params #f '())))
 112
 113
 114 (define-type-of-ast expr
 115   extender: define-type-of-expr
 116   type)
 117
 118 (define-type-of-expr literal
 119   val)
 120 (define (new-literal type val)
 121   (make-literal #f '() type val))
 122
 123 (define-type-of-expr ref
 124   def-var)
 125 (define (new-ref type def)
 126   (make-ref #f '() type def))
 127
 128 (define-type-of-expr array-ref
 129   id
 130   index)
 131 (define (new-array-ref id index)
 132   (make-array-ref #f '() 'byte id index)) ;; TODO the manual memory zone is byte indexed
 133
 134 (define-type-of-expr oper
 135   op)
 136 (define (new-oper subasts type op)
 137   (multi-link-parent!
 138    subasts
 139    (make-oper #f subasts type op)))
 140
 141 (define-type-of-expr call
 142   def-proc)
 143 (define (new-call subasts type proc-def)
 144   (multi-link-parent!
 145    subasts
 146    (make-call #f subasts type proc-def)))
 147
 148 (define-type-of-ast block
 149   name) ; blocks that begin with a label have a name, the other have #f
 150 (define (new-block subasts)
 151   (multi-link-parent!
 152    subasts
 153    (make-block #f subasts #f)))
 154 (define (new-named-block name subasts)
 155   (multi-link-parent!
 156    subasts
 157    (make-block #f subasts name)))
 158
 159 (define-type-of-ast if)
 160 (define (new-if subasts)
 161   (multi-link-parent!
 162    subasts
 163    (make-if #f subasts)))
 164
 165 (define-type-of-ast switch)
 166 (define (new-switch subasts)
 167   (multi-link-parent!
 168    subasts
 169    (make-switch #f subasts)))
 170
 171 (define-type-of-ast while)
 172 (define (new-while subasts)
 173   (multi-link-parent!
 174    subasts
 175    (make-while #f subasts)))
 176
 177 (define-type-of-ast do-while)
 178 (define (new-do-while subasts)
 179   (multi-link-parent!
 180    subasts
 181    (make-do-while #f subasts)))
 182
 183 (define-type-of-ast for)
 184 (define (new-for subasts)
 185   (multi-link-parent!
 186    subasts
 187    (make-for #f subasts)))
 188
 189 (define-type-of-ast return)
 190 (define (new-return subasts)
 191   (multi-link-parent!
 192    subasts
 193    (make-return #f subasts)))
 194
 195 (define-type-of-ast break)
 196 (define (new-break)
 197   (make-break #f '()))
 198
 199 (define-type-of-ast continue)
 200 (define (new-continue)
 201   (make-continue #f '()))
 202
 203 (define-type-of-ast goto)
 204 (define (new-goto label)
 205   (make-goto #f (list label)))
 206
 207 (define-type-of-ast program)
 208 (define (new-program subasts) ;; TODO add suport for main
 209   (multi-link-parent!
 210    subasts
 211    (make-program #f subasts)))
 212
 213 (define-type op
 214   extender: define-type-of-op
 215   (six-id unprintable:)
 216   id
 217   unprintable:
 218   type-rule
 219   constant-fold
 220   code-gen)
 221
 222 (define-type-of-op op1)
 223 (define-type-of-op op2)