Generic function for unwrapping foreign records

[guile-irrlicht.git] / irrlicht / util.scm

diff --git a/irrlicht/util.scm b/irrlicht/util.scm
index ecd21f65525c76b177a4df0aa8d5cf9b4d7f4155..efa5ba7fbe2c7547fa7f0cf217b459cd73259d5d 100644 (file)
--- a/irrlicht/util.scm
+++ b/irrlicht/util.scm
@@ -20,12 +20,13 @@
 
 (define-module (irrlicht util)
   #:use-module (system foreign)
-  #:use-module (srfi srfi-9)
-  #:use-module (srfi srfi-9 gnu)
+  #:use-module (srfi srfi-1)
+  #:use-module (rnrs bytevectors)
   #:export (bool->integer
             integer->bool
             define-foreign
-            define-foreign-record-type))
+            define-foreign-record-type
+            foreign-record->pointer))
 
 (define (bool->integer var)
   (if var 1 0))
@@ -46,33 +47,6 @@
     (irrlicht-func return-type func-name arg-types)))
 
 ;; foreign struct record type
-(define-record-type standard-foreign-record-type
-  (make-foreign-record-type name types fields)
-  foreign-record-type?
-  (name foreign-record-type-name)
-  (types foreign-record-type-types)
-  (fields foreign-record-type-fields))
-
-(define-record-type foreign-record
-  (make-foreign-record type pointer)
-  foreign-record?
-  (type foreign-record-type)
-  (pointer foreign-record-pointer set-foreign-record-pointer!))
-
-(set-record-type-printer! foreign-record
-  (lambda (record port)
-    (format port "#<~a" (foreign-record-type-name (foreign-record-type record)))
-    (let* ((pointer (foreign-record-pointer record))
-           (record-type (foreign-record-type record))
-           (types (foreign-record-type-types record-type))
-           (fields (foreign-record-type-fields record-type))
-           (values (parse-c-struct pointer types)))
-      (for-each (lambda (field value)
-                  (format port " ~a: ~a" field value))
-                fields
-                values))
-    (format port ">")))
-
 (define-syntax define-foreign-record-type
   (lambda (x)
     (define (field-names field-specs)
@@ -81,32 +55,85 @@
                ((name type getter) #'name)
                ((name type getter setter) #'name)))
            field-specs))
+
     (define (field-types field-specs)
       (map (lambda (field-spec)
              (syntax-case field-spec ()
                ((name type getter) #'type)
                ((name type getter setter) #'type)))
            field-specs))
+
+    (define (field-getters field-specs)
+      (map (lambda (field-spec field-id)
+             (syntax-case field-spec ()
+               ((name type getter) (list #'getter field-id))
+               ((name type getter setter) (list #'getter field-id))))
+           field-specs
+           (iota (length field-specs))))
+
+    (define (field-setters field-specs)
+      (filter-map (lambda (field-spec field-id)
+                    (syntax-case field-spec ()
+                      ((name type getter) #f)
+                      ((name type getter setter) (list #'setter field-id))))
+                  field-specs
+                  (iota (length field-specs))))
+
     (syntax-case x ()
       ((_ name (make-name make-arg ...) predicate? field-spec ...)
        (with-syntax (((type-id ...) (field-types #'(field-spec ...)))
-                     ((field-name ...) (field-names #'(field-spec ...))))
+                     ((field-name ...) (field-names #'(field-spec ...)))
+                     (((getter getter-id) ...) (field-getters #'(field-spec ...)))
+                     (((setter setter-id) ...) (field-setters #'(field-spec ...))))
          #'(begin
-             (define name
-               (make-foreign-record-type
-                'name
-                (list type-id ...)
-                (list 'field-name ...)))
+             (define-wrapped-pointer-type name
+               predicate?
+               wrap-record unwrap-record
+               (lambda (record port)
+                 (format port "#<~a" 'name)
+                 (let ((values (parse-c-struct (unwrap-record record) (list type-id ...))))
+                   (for-each (lambda (field value)
+                               (format port " ~a: ~a" field value))
+                             '(field-name ...)
+                             values))
+                 (format port ">")))
+
              (define (make-name make-arg ...)
-               (let* ((types (foreign-record-type-types name))
-                      (c-struct-pointer (make-c-struct types (list make-arg ...))))
-                 (make-foreign-record name c-struct-pointer)))
-             (define (predicate? record)
-               (and
-                (foreign-record? record)
-                (let* ((record-type (foreign-record-type record))
-                       (type-name (foreign-record-type-name record-type)))
-                  (equal? type-name (foreign-record-type-name name)))))
-             (export name)
-             (export make-name)
-             (export predicate?)))))))
+               (wrap-record (make-c-struct (list type-id ...) (list make-arg ...))))
+
+             (define (getter record)
+               (let ((values (parse-c-struct (unwrap-record record) (list type-id ...))))
+                 (list-ref values getter-id)))
+             ...
+
+             (define (setter record new-value)
+               (let* ((types (list type-id ...))
+                      (type (list-ref types setter-id))
+                      (len (sizeof type))
+                      (offset (if (> setter-id 0)
+                                  (sizeof (list-head types setter-id))
+                                  0))
+                      (bv (pointer->bytevector (unwrap-record record) len offset 'u32)))
+                 (bytevector-set! bv new-value type)
+                 new-value))
+             ...))))))
+
+(define (bytevector-set! bv value type)
+  (let ((procedure
+         (cond
+           ((= type int8) bytevector-s8-set!)
+           ((= type int16) bytevector-s16-native-set!)
+           ((= type int32) bytevector-s32-native-set!)
+           ((= type int64) bytevector-s64-native-set!)
+           ((= type uint8) bytevector-u8-set!)
+           ((= type uint16) bytevector-u16-native-set!)
+           ((= type uint32) bytevector-u32-native-set!)
+           ((= type uint64) bytevector-u64-native-set!)
+           ((= type float) bytevector-ieee-single-native-set!)
+           ((= type double) bytevector-ieee-double-native-set!)
+           (else #f))))
+    (if procedure
+        (apply procedure bv 0 value '()))))
+
+(define (foreign-record->pointer record)
+  (struct-ref record 0))