(let ((type (global:type o)))
(cond ((or (c-array? type)
(structured-type? type)) (wrap-as (i386:label->accu `(#:address ,o))))
- (else (wrap-as (i386:label-mem->accu `(#:address ,o)))))))
+ (else (append (wrap-as (i386:label-mem->accu `(#:address ,o)))
+ (convert-accu type))))))
(define (number->accu o)
(wrap-as (i386:value->accu o)))
(define (global->info type name o init info)
(let* ((rank (->rank type))
(size (->size type))
- (array? (or (and (c-array? type) type)
- (and (pointer? type)
- (c-array? (pointer:type type))
- (pointer:type type))
- (and (pointer? type)
- (pointer? (pointer:type type))
- (c-array? (pointer:type (pointer:type type)))
- (pointer:type (pointer:type type)))))
(data (cond ((not init) (string->list (make-string size #\nul)))
- (array? (let* ((string (array-init->string init))
- (size (or (and string (max size (1+ (string-length string))))
- size))
- (data (or (and=> string string->list)
- (array-init->data size init info))))
- (append data (string->list (make-string (max 0 (- size (length data))) #\nul)))))
- (else (let ((data (init->data init info)))
- (append data (string->list (make-string (max 0 (- size (length data))) #\nul)))))))
+ ((c-array? type)
+ (let* ((string (array-init->string init))
+ (size (or (and string (max size (1+ (string-length string))))
+ size))
+ (data (or (and=> string string->list)
+ (array-init->data type size init info))))
+ (append data (string->list (make-string (max 0 (- size (length data))) #\nul)))))
+ ((structured-type? type)
+ (let ((data (init->data type init info)))
+ (append data (string->list (make-string (max 0 (- size (length data))) #\nul)))))
+ (else
+ (let ((data (init->data type init info)))
+ (append data (string->list (make-string (max 0 (- size (length data))) #\nul)))))))
(global (make-global-entry name type data)))
(clone info #:globals (append (.globals info) (list global)))))
-(define (array-init-element->data size o info)
+(define (array-init-element->data type o info)
(pmatch o
((initzer (p-expr (string ,string)))
`((#:string ,string)))
((initzer (p-expr (fixed ,fixed)))
- (int->bv32 (expr->number info fixed)))
- (_ (init->data o info))
- ;;(_ (error "array-init-element->data: not supported: " o))
- ))
-
-(define (array-init->data size o info)
+ (int->bv type (expr->number info fixed)))
+ ((initzer (initzer-list . ,inits))
+ (if (structured-type? type)
+ (map (cut init->data <> <> info) (map cdr (struct->init-fields type)) inits)
+ (begin
+ (stderr "array-init-element->data: oops:~s\n" o)
+ (stderr "type:~s\n" type)
+ (error "array-init-element->data: not supported: " o))))
+ (_ (init->data type o info))
+ (_ (error "array-init-element->data: not supported: " o))))
+
+(define (array-init->data type size o info)
(pmatch o
+ ((initzer (initzer-list . ,inits))
+ (let ((type (c-array:type type)))
+ (map (cut array-init-element->data type <> info) inits)))
+
(((initzer (initzer-list . ,inits)))
- (map (cut array-init-element->data size <> info) inits))
+ (array-init->data type size (car o) info))
((initzer (p-expr (string ,string)))
(let ((data (string->list string)))
(append data (string->list (make-string (max 0 (- size (length data))) #\nul))))))
(((initzer (p-expr (string ,string))))
- (let ((data (string->list string)))
- (if (not size) data
- (append data (string->list (make-string (max 0 (- size (length data))) #\nul))))))
+ (array-init->data type size (car o) info))
- (((initzer (p-expr (string . ,strings))))
+ ((initzer (p-expr (string . ,strings)))
(let ((data (string->list (apply string-append strings))))
(if (not size) data
(append data (string->list (make-string (max 0 (- size (length data))) #\nul))))))
+ (((initzer (p-expr (string . ,strings))))
+ (array-init->data type size (car o) info))
+
((initzer (p-expr (fixed ,fixed)))
- (int->bv32 (expr->number info fixed)))
+ (int->bv type (expr->number info fixed)))
(() (string->list (make-string size #\nul)))
(_ (error "array-init->data: not supported: " o))))
(if (.function info) (local->info type name o init info)
(global->info type name o init info))))
;; FIXME: recursion
- (((array-of (array-of (ident ,name) ,count) ,count1) . ,init)
+ (((array-of (array-of (ident ,name) ,count1) ,count) . ,init)
(let* ((strings (init->strings init info))
(info (if (null? strings) info
(clone info #:globals (append (.globals info) strings))))
(count (expr->number info count))
(count1 (expr->number info count1))
- (type (rank++ (make-c-array type (* %pointer-size count count1)))))
+ (type (make-c-array (make-c-array type count1) count)))
(if (.function info) (local->info type name o init info)
(global->info type name o init info))))
(_ (error "init-declr->info: not supported: " o))))
(1+ i)
(append constants (list (ident->constant name i))))))))
-(define (init->data o info)
+(define (init->data type o info)
(pmatch o
- ((p-expr ,expr) (init->data expr info))
- ((fixed ,fixed) (int->bv32 (expr->number info o)))
- ((char ,char) (int->bv32 (char->integer (string-ref char 0))))
+ ((p-expr ,expr) (init->data type expr info))
+ ((fixed ,fixed) (int->bv type (expr->number info o)))
+ ((char ,char) (int->bv type (char->integer (string-ref char 0))))
((string ,string) `((#:string ,string)))
((string . ,strings) `((#:string ,(string-join strings ""))))
((ident ,name) (let ((var (ident->variable info name)))
`((#:address ,var))))
- ((initzer-list . ,initzers) (append-map (cut init->data <> info) initzers))
+ ((initzer-list . ,inits)
+ (cond ((structured-type? type)
+ (map (cut init->data <> <> info) (map cdr (struct->init-fields type)) inits))
+ ((c-array? type)
+ (let ((size (->size type)))
+ (array-init->data type size `(initzer ,o) info)))
+ (else
+ (append-map (cut init->data type <> info) inits))))
(((initzer (initzer-list . ,inits)))
- (init->data `(initzer-list . ,inits) info))
+ (init->data type `(initzer-list . ,inits) info))
((ref-to (p-expr (ident ,name)))
(let ((var (ident->variable info name)))
`((#:address ,var))))
(let* ((type (ast->type struct info))
(offset (field-offset info type field))
(base (cstring->int base)))
- (int->bv32 (+ base offset))))
+ (int->bv type (+ base offset))))
((,char . _) (guard (char? char)) o)
((,number . _) (guard (number? number))
- (append (map int->bv32 o)))
- ((initzer ,init) (init->data init info))
- (((initzer ,init)) (init->data init info))
- ((cast _ ,expr) (init->data expr info))
+ (append (map int->bv type o)))
+ ((initzer ,init) (init->data type init info))
+ (((initzer ,init)) (init->data type init info))
+ ((cast _ ,expr) (init->data type expr info))
+ (() '())
(_ (let ((number (try-expr->number info o)))
- (cond (number (int->bv32 number))
+ (cond (number (int->bv type number))
(else (error "init->data: not supported: " o)))))))
+(define (int->bv type o)
+ (let ((size (->size type)))
+ (case size
+ ((1) (int->bv8 o))
+ ((2) (int->bv16 o))
+ (else (int->bv32 o)))))
+
(define (init->strings o info)
(let ((globals (.globals info)))
(pmatch o