Re: ffi helper

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

Matt Wette <matt.wette@gmail.com> writes:

>> On Mar 13, 2017, at 5:53 PM, Matt Wette <matt.wette@gmail.com> wrote:
>> 
>> 
>>> On Mar 8, 2017, at 6:06 PM, Matt Wette <matt.wette@gmail.com> wrote:
>>> 
>>> I’m now working on a FFI helper based on the nyacc C99 parser.   
>> 
>
> I am making some progress with some ragged prototype code.
>
> Here is a top-level program, just pulling out three declarations to start:
>
> (let* ((file "/opt/local/include/cairo/cairo-svg.h")
>        (defs '())
>        (incs '("/opt/local/include" "/opt/local/include/cairo" "/usr/include"))
>        (tree (my-parse defs incs file))
>        (file-decls (reverse (c99-trans-unit->udict tree #:filter cairo-filter)))
>        (udecl-dict (c99-trans-unit->udict/deep tree)))
>
>   (fold
>    (lambda (pair type-list)
>      (udecl->ffi-decl (cdr pair) type-list))
>    fixed-width-int-names
>    (filter
>     (lambda (e)
>       (member (car e)
> 	      '("cairo_matrix_t" "cairo_surface_t" "cairo_svg_surface_create")))
>     file-decls)))
>
> And here is the autogenerated output for the declarations:
>
> (define-std-pointer-wrapper cairo_surface_t*)
>
> (define cairo_matrix_t
>   (bs:struct
>     `(,(string->symbol "xx") ,double)
>     `(,(string->symbol "yx") ,double)
>     `(,(string->symbol "xy") ,double)
>     `(,(string->symbol "yy") ,double)
>     `(,(string->symbol "x0") ,double)
>     `(,(string->symbol "y0") ,double)))
>
> (define cairo_svg_surface_create
>   (let ((f (pointer->procedure
>              '*
>              (libcairo-func "cairo_svg_surface_create")
>              (list '* double double))))
>     (lambda (filename width_in_points height_in_points)
>       (let ((~filename (string->pointer filename))
>             (~width_in_points width_in_points)
>             (~height_in_points height_in_points)
>             (~result
>               (f ~filename ~width_in_points ~height_in_points)))
>         (wrap-cairo_surface_t* ~result)))))

Neat!

> I was not able to come up with a procedure that would take arguments
> “xx” and “double” and generate the bs:struct pattern `(xx ,double).
> Help is welcome.

You mean you get "xx" and "double" as strings?  For xx, string->symbol
as you already do is OK.  As for double, that's a bit tricky.  I see a
few possibilities:

- Turn the string into a symbol and eval it:

    (eval (string->symbol str)
          (resolve-module '(bytestructures guile numeric)))

- Use the reflective module API:

    (module-ref (resolve-module '(bytestructures guile numeric))
                (string->symbol str))

- Create an explicit mapping from name (string or symbol) to object:

    (import (bytestructures guile numeric))

    (define descriptor-mapping
      `(("double" . ,double)
        ("float" . ,float)
        ...))

(The so-far undocumented module (bytestructures guile numeric-metadata)
contains a mapping similar to this, but it only contains name with
explicit bit width so e.g. 'double' isn't in it, so I guess it's not the
right thing here.)

While 'eval' is normally discouraged, I think it's fine in this case,
since we use string->symbol.  I don't see anything bad resulting from
evaluating an arbitrary symbol.

However, the second option could be said to be a tad bit more "correct"
than using eval, so I'd go with that and only use the eval method if I
had to write standards-compliant code where eval is available but not
something like module-ref.

The third option gives you full control but it shouldn't be necessary.

Hope that helps,
Taylan