Bytestructures, FFI

[taylanbayirli@gmail.com (Taylan Ulrich Bayırlı/Kammer)]

Hi there,

I had announced this project a while ago, here:

  https://lists.gnu.org/archive/html/guile-user/2015-08/msg00034.html

I just added support for converting a bytestructure descriptor into a
type descriptor as per Guile's FFI module.

E.g. the uint8 descriptor in (bytestructures guile numeric) converts to
the value of the uint8 variable in the (system foreign) module, and a
struct descriptor such as (bs:struct `((x ,uint8) (y ,uint16))) converts
to what one would get from evaluating (list uint8 uint16) after
importing (system foreign).  (Such lists are accepted by Guile's FFI to
denote structs; it's yet undocumented in the manual.)

For convenience, a bs:pointer->proc procedure is offered, that wraps
pointer->procedure and adds bytestructure related functionality.  Here's
a minimal example of how to use it:


--- start transcript ---

taylan@T420:~/src/scheme/bytestructures$ cat test.c
typedef struct {
  struct {
    int x;
    float y;
  } s;
  int z;
  float t[3];
} foo_t;

foo_t testfunc(foo_t arg)
{
  ++arg.s.x;
  ++arg.s.y;
  ++arg.z;
  ++arg.t[0];
  ++arg.t[1];
  ++arg.t[2];
  return arg;
}
taylan@T420:~/src/scheme/bytestructures$ gcc -shared -o libtest.so test.c
taylan@T420:~/src/scheme/bytestructures$ sudo mv libtest.so /usr/lib/
taylan@T420:~/src/scheme/bytestructures$ guile
GNU Guile 2.0.11
Copyright (C) 1995-2014 Free Software Foundation, Inc.

Guile comes with ABSOLUTELY NO WARRANTY; for details type `,show w'.
This program is free software, and you are welcome to redistribute it
under certain conditions; type `,show c' for details.

Enter `,help' for help.
scheme@(guile-user)> (import (bytestructures guile))
scheme@(guile-user)> (import (bytestructures guile ffi))
scheme@(guile-user)> (define foo_t (bs:struct `((s ,(bs:struct `((x ,int)
                                                                 (y ,float32))))
                                                (z ,int)
                                                (t ,(bs:vector 3 float32)))))
scheme@(guile-user)> (define foo (bytestructure foo_t '((s ((x 1)
                                                            (y 2.2)))
                                                        (z 3)
                                                        (t #(0 1 2)))))
scheme@(guile-user)> (bytestructure-ref foo 's 'x)
$1 = 1
scheme@(guile-user)> (bytestructure-ref foo 't 1)
$2 = 1.0
scheme@(guile-user)> (define testfunc
                       (bs:pointer->proc
                        foo_t  ;return value type
                        (dynamic-func "testfunc" (dynamic-link "libtest"))
                        (list foo_t)))  ;list of argument types
scheme@(guile-user)> (define foo2 (testfunc foo))
scheme@(guile-user)> (bytestructure-ref foo2 's 'x)
$3 = 2
scheme@(guile-user)> (bytestructure-ref foo2 't 1)
$4 = 2.0
scheme@(guile-user)>

--- end transcript ---


To recap:

We have a C file which defines a struct, and a function that
takes such a struct and returns a new one with some of the fields'
values modified.  We make this a shared library.

In Guile, we can express the same struct layout via a bytestructure
descriptor object, which we put in the variable foo_t.  We can also
instantiate such a struct in memory, reified in Scheme as a
bytestructure object, which we put into the variable foo.

We use bs:pointer->proc to create a Scheme procedure that wraps the
function in our shared library; bs:pointer->proc allows us to use the
foo_t descriptor in the return value and argument list declarations.

We can now call this procedure with the struct we had created from
Scheme and put in the variable foo as a bytestructure object.  The new
struct returned by the C function is automatically turned into a
bytestructure object that can be used from Scheme with the
bytestructures API.

Neat, isn't it?


If test.c instead contained:

void testfunc(foo_t *arg)
{
  ++arg->s.x;
  ++arg->s.y;
  ++arg->z;
  ++arg->t[0];
  ++arg->t[1];
  ++arg->t[2];
}

(i.e. testfunc now takes a struct pointer and modifies it in-place)

then we could create our procedure like:

scheme@(guile-user)> (import (prefix (system foreign) ffi:))
scheme@(guile-user)> (define testfunc
                       (bs:pointer->proc
                        ffi:void
                        (dynamic-func "testfunc" (dynamic-link "libtest"))
                        (list '*)))

and things would work like this:

scheme@(guile-user)> (testfunc foo)
scheme@(guile-user)> (bytestructure-ref foo 's 'x)
$3 = 2
scheme@(guile-user)> (bytestructure-ref foo 't 1)
$4 = 2.0

Magic!


Note that while bytestructures supports unions and bit-fields, libffi
and therefore (system foreign) does not, so the above won't work yet for
types in which unions or bitfields are involved.  Unions can possibly be
supported with a little hack, which I'll look into later.

I have not yet made the semantics of bs:pointer->proc concrete, and it's
yet undocumented.  Feel free to ask me questions here or on Freenode
under the nick 'taylan'.  Comments are welcome too!

Taylan