[plt-scheme] FFI Problem

I have a "can't see the tree for the forest"-problem.

The function dgemv ought to accept 11 arguments, but will
only accept 3.

 > (require blas)
. procedure ffi-wrapper:dgemv: expects 3 arguments,
given 12: 0 0 4 4 1.0 #<struct:f64vector> 4 #<struct:f64vector>
1 0.0 #<struct:f64vector> 1

Where is my mistake?



(module blas mzscheme
  (provide (all-defined))
 
  (require (lib "foreign.ss"))
  (unsafe!)
 
  (define blas-lib
    (ffi-lib "c:/libgoto_katmai-r0.99-3.dll"))
 
  ; void dgemv(const char *trans, int *m, int *n, double *alpha,
  ;                    void *a, int *lda, void *x, int *incx,
  ;                  double *beta, void *y, int *incy);
 
  (define blas:dgemv
    (get-ffi-obj "dgemv" blas-lib
                 (_fun (_ptr o  _byte)   ; char *trans
                       (_ptr o  _int)    ; int *m
                       (_ptr o  _int)    ; int *n
                       (_ptr o  _double) ; double *alpha
                       _f64vector        ; void *a         the input matrix
                       (_ptr o  _int)    ; int *lda
                       _f64vector         ; void *x         input vector 
of doubles
                       (_ptr o  _int)    ; int *incx
                       (_ptr o  _double) ; double *beta
                       (_ptr io _void)   ; void *y
                       (_ptr o  _int)    ; int *incy
                       ->
                       _void)
                 (lambda ()
                   (lambda (x)
                     (error 'foolib
                            "your installed foolib version does not 
provide \"foo\"")))))
 
  ; void dgemv(const char *trans, int *m, int *n, double *alpha,
  ;                    void *a, int *lda, void *x, int *incx,
  ;                  double *beta, void *y, int *incy);
  ;
  ; The parameters are as follows:
  ;
  ; trans
  ;   is a single character indicating the form of the input matrix a, 
where:
  ;      * 'N' or 'n' indicates that a is to be used in the computation
  ;      * 'T' or 't' indicates that the transpose of a is to be used in 
the computation
  ;
  ; m
  ;    represents:
  ;
  ;        * the number of rows in input matrix a
  ;        * the length of vector y, if 'N' or 'n' is used for the trans 
parameter
  ;        * the length of vector x, if 'T' or 't' is used for the trans 
parameter
  ;
  ;    The number of rows must be greater than or equal to zero, and 
less than the leading
  ;    dimension of the matrix a (specified in lda)
  ; n
  ;    represents:
  ;
  ;        * the number of columns in input matrix a
  ;        * the length of vector x, if 'N' or 'n' is used for the trans 
parameter
  ;        * the length of vector y, if 'T' or 't' is used for the trans 
parameter
  ;
  ;    The number of columns must be greater than or equal to zero.
  ; alpha
  ;    is the scaling constant for matrix a
  ; a
  ;    is the input matrix of float (for sgemv) or double (for dgemv) 
values
  ; lda
  ;    is the leading dimension of the array specified by a. The leading 
dimension
  ;    must be greater than zero. The leading dimension must be greater 
than or
  ;    equal to 1 and greater than or equal to the value specified in m.
  ; x
  ;    is the input vector of float (for sgemv) or double (for dgemv) 
values.
  ; incx
  ;    is the stride for vector x. It can have any value.
  ; beta
  ;    is the scaling constant for vector y
  ; y
  ;    is the output vector of float (for sgemv) or double (for dgemv) 
values.
  ; incy
  ;    is the stride for vector y. It must not be zero.
  ;
  ; Note:
  ;  Vector y must have no common elements with matrix a or vector x; 
otherwise, the results are unpredictable.
 
  ; (error)
 
  ;(define order blas:ColMajor)
  ;(define transa blas:NoTrans)
 
  (define order 0)
  (define transa 0)
 
  (define m 4); /* Size of Column ( the number of rows ) */
  (define n 4); /* Size of Row ( the number of columns ) */
  (define lda 4); /* Leading dimension of 5 * 4 matrix is 5 */
  (define incx 1)
  (define incy 1)
  (define alpha 1.0)
  (define beta 0.0)
 
  (define a                ; column-major order!
    (list->f64vector
     '(1.0 2.0 3.0 4.0
           1.0 1.0 1.0 1.0
           3.0 4.0 5.0 6.0
           5.0 6.0 7.0 8.0) ))
 
  (define x (list->f64vector '(1.0 2.0 1.0 1.0)))
  (define y (list->f64vector '(0.0 0.0 0.0 0.0)))
 
  (blas:dgemv  order transa m n alpha a lda x incx beta y incy)
  )