New function expand-to-foreign-dyn-indirect

New function expand-to-foreign-dyn-indirect split out from
expand-to-foreign-dyn, and the latter function returned to its
definition as given in the tip of master, ab10be4fb8.  This function
is used if the optional argument 'indirect to translate-objects is T,
which in turn the case when functions are calling or return structures
by value.

Compiler macro for mem-aptr

Multi-level optimizations depending what arguments are constantp;
the constantp arguments need to be evaled.

Add libffi.so.6, libffi32.so.6 to unix load list

Ubuntu 11.10 ships with libffi6 and not libff5, so these libraries are
now added to the load list.

Change comment to refer to "libffi"

Comment referred to "FSBV" now corrected to "libffi".  Other uses (the
tests and foreign library for tests, the *feature* symbol, and the
variable 'fsbvp resulting from fn-call-by-value-p) genuinely refer to
FSBV and not specifically libffi.  Distinction: "FSBV" refers to all
calls of structures by value, whether accomplished with the help of
libffi or not (some compilers have FSBV built in), "libffi" refers to
the use of the libffi library whether or not for calling foreign
structures by value (there are other functions not yet made use of in
CFFI, but someday might).

Merge branch 'master' into libffi

Conflicts:
tests/GNUmakefile

Define a compiler macro for #'mem-aptr

cffi-abcl: implement callbacks.

Patch courtesy of Mark Evenson.

cffi-abcl: autoload JNA dependency.

Patch courtesy of Mark Evenson.

Add support for Digitool MCL.

Patch courtesy of James Anderson.

Update manual to include mem-aptr

Define mem-aptr; untested

New function mem-aptr will return the pointer to the requested element
of the array, and add documentation.  It is untested.

Fix alloc_pair test return type syntax

Rename system to cffi-libffi, add restart to default *foreign-structures-by-value*

Use hash table for libffi-type-pointer

Use hash table for libffi-type-pointer instead of a class slot, and
simplify #'libffi-type-pointer methods.  Remove obsolete package
definition file.  Tests in cffi-tests not run due to error in load,
but GSLL tests pass.

Moved slots-in-order after foreign-struct-type, clean up libffi-*.lisp

cffi-abcl: fix bitrot. s/calling-convention/convention

Bug reported by Anton Vodonosov.

Fix conditionalization syntax in cffi-fsbv.asd

Add Windows grovel file

Added a Windows grovel file from CRLF0710, modified from the
standalone FSBV unix file.  Minimally modified for CFFI with updated
header and package, not tested at all.

Eliminate package cffi-fsbv, put :sizet in keyword package

cffi-allegro: signal clearer error when [u]llong is unsupported

cffi-tests: fix bug in ullong(); mark expected failure.

DEFCFUN.UNSIGNED-LONG-LONG fails on Allegro: lp#914500.

minor fix for allegrocl's long-long support

New tests: DEFCFUN.UNSIGNED-LONG-LONG and FUNCALL.UNSIGNED-LONG-LONG.

cffi-tests: make compilation of 32-bit libtest optional.

Fixes lp#911557. Reported by Elias Pipping. Solution courtesy of
Daniel Herring.

Use soname with major version for libffi on unix

Use soname with major version for libffi on unix as advocated on
http://lispcaveats.tumblr.com/post/13259176455/ffi-linking-against-shared-libraries.

Argument 'indirect to #'expand-to-foreign-dyn is key instead of optional

Argument 'indirect to #'expand-to-foreign-dyn is key instead of
optional, so that other systems that define a method can just have
&key, and they do not have to add this argument if they don't need to
use it.

Bind (*parse-bare-structs-as-pointers* t) when parsing function definitions

In parse-args-and-types, foreign-funcall-form,
foreign-funcall-varargs-form, bind
(*parse-bare-structs-as-pointers* t)
when parsing function definitions so that if a bare structure is
specified, the expanded form with have :pointer or (:pointer (:struct
foo)) and therefore the type will be correctly recognized.

Fix uffi-compat:octets-to-string.

Initial patch courtesy of François-René Rideau.

Fixed incorrect use of sap-ref-word for longs on 64-bit Windows.

Implemented automatic accessor lookup for integer types, based on
alien type size and CFFI keyword -> alien type mapping.

Additional methods for translate-into-foreign-memory and expand-to-foreign-dyn

In order that structures called by value work correctly (in
cffi-fsbv), add methods:
translate-into-foreign-memory
  foreign-built-in-type
  enhanced-typedef
expand-to-foreign-dyn
  foreign-built-in-type
  foreign-pointer-type

Indirecting foreign objects for libffi

The generic function translate-into-foreign-memory has been slightly
repurposed and expanded to provide indirection of enums and pointers.
The function translate-objects and generic function
expand-to-foreign-dyn have a new argument, 'indirect, that when set,
expand to with-foreign-object and translate-into-foreign-memory
instead of translate-to-foreign, unwind-protect, and
free-translated-object.  This insures that all arguments to functions
passed to libffi are indirected one level, as is required.

Added stdcall callback support for SBCL back-end

grovel: dispatch on size of :POINTER to initialize *CPU-WORD-SIZE-FLAGS*

We were previously using :LONG, but that does not match the machine word
size on some platforms, namely Windows.

Bug reported by Anton Kovalenko.

Use structure specification (:struct foo) in defcstruct expansion

Modify #'generate-struct-accessors so that when generating accessors,
the structure is referred to with the (:struct foo) syntax, rather
than just 'foo.  While such a reference usually generates only a style
warning, if parse-deprecated-struct-type hasn't been called yet, as is
the case for slot defintions in the defcstruct expansion, it results
in an error.  This problem prevented shuffletron from compiling.

Call-by-value with :void return, do not allocate return object

Remove fsbv-standalone

Relocate default type class name in defcfun

Moved the generation of a default type class name (appending '-tclass)
in defcfun so that notice-foreign-struct-definition gets the class
name in 'options.  Use the proper :struct form for structure.

Groveler fixes for new structure syntax

Two fixes related to the change to the new syntax (:struct foo):
1) For size-of-* defconstant generation, emit with :struct.
2) Parse name and size in defcunion, not just leaving that to
notice-foreign-union-definition, because define-parse-method needs a
clean name.

Osicat now compiles cleanly.

Default type class, define-translation-method

Make a default :class argument in defcstruct which is the structure
name and '-tclass concatenated.  New macro define-translation-method
for convenience to define translation methods.  It's a first cut, not
quite how I'd like, and untested.

Fix mem-set: for aggregates, pointer is incremented by offset

Recently added test struct-values.translation.mem-aref.1 that tested
conversion of arrays of structures was failing because mem-set did not
increment the pointer by the offset amount, so it was always writing
into the first position of the array and the rest was garbage.  This
is now fixed.

(with-foreign-object (p '(:struct struct-pair) 2)
      (setf (mem-aref p '(:struct struct-pair) 0) '(1 . 2)
            (mem-aref p '(:struct struct-pair) 1) '(3 . 4))
      (values (mem-aref p '(:struct struct-pair) 0)
              (mem-aref p '(:struct struct-pair) 1)))
(1 . 2)
(3 . 4)

Test conversion of array of structs

Added test struct-values.translation.mem-aref.1 that creates an array
of two struct-pairs, sets their values, then retrieves both pairs.
This test fails: the returned first pair is actually the second, and
the returned second pair is garbage.  Repeating the same test gives
different garbage.

(with-foreign-object (p '(:struct struct-pair) 2)
      (setf (mem-aref p '(:struct struct-pair) 0) '(1 . 2)
            (mem-aref p '(:struct struct-pair) 1) '(3 . 4))
      (values (mem-aref p '(:struct struct-pair) 0)
              (mem-aref p '(:struct struct-pair) 1)))
(3 . 4)
(213829 . 0)

(with-foreign-object (p '(:struct struct-pair) 2)
      (setf (mem-aref p '(:struct struct-pair) 0) '(1 . 2)
            (mem-aref p '(:struct struct-pair) 1) '(3 . 4))
      (values (mem-aref p '(:struct struct-pair) 0)
              (mem-aref p '(:struct struct-pair) 1)))
(3 . 4)
(425347 . 0)

Test foreign function calls with recursive structure by value

Add definition of C functions prodsumpair and doublepairdouble that
take, and for the latter, return, the structure struct-pair+double
(struct_pair_double) that has a structure struct-pair (struct_pair) in
its slot 'pr.  Two tests, fsbv.3 and fsbv.4, have been defined, and
pass.  Fixed argument to libffi-type-pointer call in
libffi-type-pointer :around method so that these will work.

Add struct-pair+double recursive structure translation test

Add struct-pair+double recursive structure translation test, which
passes when run individually in SBCL.

Tests for CFFI-FSBV libffi; fix return value translation in ffcall-body-libffi

Tests fsbv.1 and fsbv.2 added that test foreign structure call and
return by value.  This includes the C file and addition to makefile to
generate the appropriate library, libfsbv.  So that the tests are
properly defined, load cffi-fsbv and then cffi-tests.  Both tests
should pass.  The test returning a structure, fsbv.2, exposed an error
in the form generated by ffcall-body-libffi; because it always
generated a mem-aref on the return value, the subsequent
translate-from-foreign was effectively making a double translation.
Thus, this form generation has been conditionalized so that if
translate-from-foreign will not be applied (e.g., built-in-type) to
call mem-aref, otherwise just return the pointer.

Translate structure to plist; fix to mem-ref function

Define a structure struct-pair-default-translate and test
struct-values-default.translation.mem-ref.1 to test translation from
foreign structure to plist.  In order to make this work, rewrite
mem-ref function to parallel exactly the mem-ref compiler macro,
because conditionals were not correct.

Documentation for structure conversion; push :fsbv onto features

Documentation for structure conversion; push :fsbv onto features,
export macro translation-forms-for-class.

In mem-ref function, call inc-pointer instead of %mem-ref

In mem-ref function, call inc-pointer and not %mem-ref if type is not
a bare struct, which mirrors what the compiler macro does.

Add :argument-precedence-order to defgenerics

Add :argument-precedence-order to defgenerics
translate-into-foreign-memory and translate-to-foreign, and removed
the 'cons specializer in the tests.

First stab at structs-by-value within MEM-REF and MEM-SET.

Make STRUCT-PAIR's translate-into-foreign-memory more specific.

Otherwise the default plist-handling method kicks in.

Improve docstring for condition foreign-function-not-prepared

Fix variadic DEFCFUNs. Moved call-by-value conditionalization to %DEFCFUN.

Simplifies DEFCFUN, but due to the ACL-specific DEFCFUN-HELPER-FORMS hack,
this complicates %DEFCFUN a little bit.

Move *PARSE-BARE-STRUCTS-AS-POINTERS* up.

Add default free-translated-object, remove aggregate slot code, add documentation

The default free-translated-object for foreign structures.  The code
for translating a structure with aggregate slots was wrong, because it
did not recognize an existing translator (e.g. complex), so it has
been removed.  Description in manual for defcfun and foreign-funcall
include structure-by-value call specification and requirements.

Remove unneeded function

New function translation-forms-for-class

New function translation-forms-for-class will generate two
defmethods, one for translate-from-foreign, and the other for
translate-into-foreign-memory, which specialize on the particular
type.  If the CL equivalent is defined to be a class, these methods do
the translation between CL object and foreign struct.

Fix description of file

Aggregate slot type translation, untested

Default plist conversion of foreign structures

Convert foreign structures from/to plists works with simple example
CFFI> (defparameter rc (convert-to-foreign '(r 7.0d0 c #C(2.0d0 3.0d0)) '(:struct real-and-complex)))
RC
CFFI> (convert-from-foreign rc '(:struct real-and-complex))
(C #C(2.0d0 3.0d0) R 7.0d0)

Plist translators for structures

Merge branch 'fsbv' of github.com:cffi/cffi into fsbv

Conflicts:
fsbv/examples.lisp

Structures by value in defcfun

Foreign functions defined through defcfun can have structures by value
arguments and/or return.

Move recursive structure example to fsbv/examples.lisp

Simplified ffcall-body-libffi (was callable-function)

Removed duplicate translations to and from foreign, and changed
function bound to *foreign-structures-by-value* to only return the
body, not the entire lambda. Changed the call in foreign-funcall-form
to not apply to args, as there is already an applied lambda and
cleanup.  Funcation is now called ffcall-body-libffi, was
callable-function.

CFFI-FSBV with foreign-funcall-pointer

Structures by value should work with foreign-funcall-pointer, untested.

Functioning structure calls by value with foreign-funcall

1. Definition of test structure in GSL with (dat :double :count 2),
not two separate doubles.
2. When computing libffi-type-pointer, iterate through slots in
order.
3. When computing libffi-type-pointer, count the multiplicity of the
slot and set each; for aggregate slots, this can be greater than one.
4. The returned value from the callable-function is the result set by
the call to #'call.
5. This works correctly for the example definitions in
fsbv/examples.lisp using GSL.
CFFI(12): (foreign-funcall "gsl_complex_conjugate"
            (:struct complex-double) #C(3.0d0 4.0d0)
            (:struct complex-double))
#C(3.0d0 -4.0d0)
CFFI(13): (foreign-funcall "gsl_complex_abs"
            (:struct complex-double) #C(3.0d0 4.0d0) :double)
5.0d0

Fix and add example, quote args

Fix example gsl_complex_abs so that it has the right return type, add
example for gsl_complex_conjugate.  Error
Unhandled memory fault at #x7FFEFEA1EA10.
   [Condition of type SB-SYS:MEMORY-FAULT-ERROR]

CFFI-FSBV, make the callable function, move example to fsbv

Make the callable function incorrectly in fsbv, try on complex-double
example now in fsbv.

Use a hash table keyed by foreign function name to save CIF

Save the libffi "CIF" (foreign structure with information prepared
about function) in a hash table keyed by the foreign function name; if
a function is in the hash table, it is retrieved on call to
#'prepare-function, otherwise it is generated, saved in the table, and
returned.  Information may be removed from the table with
#'unprepare-function.  Start writing #'callable-function which will
generate a lambda that can be called on Lisp arguments and calls
#'call with the CIF and the arguments.

Better use of prepare-function in foreign-funcall-form, still not correct

cffi-tests: use (:pointer (:struct foo)) in latest struct tests.

Fix misplaced comma in foreign-funcall-form.

Add UNPARSE-TYPE method FOREIGN-STRUCT-TYPE.

Add respective struct tests, one of which fails. Also, missing union
tests.

cffi-fsbv: load trivial-features before DEFSYSTEM form is read.

Switch order of defsystem depends per Luis

Define libffi-type-pointer for enums

FSBV calls in foreign-funcall-form

Check in foreign-funcall-form if arguments or return are foreign
structures by value, if they are, expand with
*foreign-structures-by-value* which will eventually call
prepare-function in CFFI-FSBV.

Fixes to libffi-type-pointer

Implement (:STRUCT foo) and (:UNION foo) type parsing.

:STRUCT and :UNION types live one their own namespaces (as in C) and this
supported by FIND-TYPE-PARSER itself. (Although one has to manually
implement parse methods for each namespace, as we did for :STRUCT and
:UNION.)

Bare FOO references are parsed to (:STRUCT foo) or (:POINTER (:STRUCT foo))
depending on context and signal a style warning about their deprecation.

Note that CANONICALIZE now returns a list like (:STRUCT/:UNION foo) for
struct/union types instead of always returning a keyword denoting a
built-in type.

Unions now have their own FOREIGN-UNION-TYPE, a subclass of
FOREIGN-STRUCT-TYPE.

Define prepare-function

Define #'prepare-function which generates a form to make the
preparation and call into libffi.  The form looks correct but it has
not been tested yet.

grovel: fix CVAR's Lisp-side expansion.

Patch courtesy of pinterface. Fixes LP bug #852192.

Make libffi-type-pointer a slot and method, define for built-in types

1. Idea: Make a slot for libffi-type-pointer and define for all
built-in types, then define methods to make the pointer on demand for
other type classes.
2. Add slot [libffi-type-pointer] with generic function to defclass
foreign-type.
3. New file [built-in-types.lisp] defines all built-in types, and
libffi-type-pointer :around method for typedefs/aliases.
4. New [libffi-type-pointer :around method] for foreign-struct-type.
5. New lists exported from CFFI for possible other uses, and needed
here: *other-builtin-types* *built-in-integer-types*
*built-in-float-types*.

Define *built-in-foreign-types*

Function integer-type-association

Sort out built-in types

Merge branch 'fsbv' of github.com:cffi/cffi into fsbv

New function cstruct-libffi-type-pointer

Created a function cstruct-libffi-type-pointer that generates the
libffi-type structure for any foreign structure type, so that this
structure may be used as an argument or return call by value to a
foreign function.  It replaces the automatic generation of this
structure when defstruct is compiled or loaded (via
*defcstruct-hook*), so that it is only made when needed and cffi-fsbv
need not be loaded when the defcstruct is compiled.  The structure
will only be made once; it is bound to the plist of the type symbol
(as before), and is reused if needed again.  This function compiles
but has not yet been tested.

Added tests for the translation of embedded structures.

Export {convert,translate,expand}-foreign-memory.

Define structure interface to libffi

Generic function translate-into-foreign-memory and funtion
convert-into-foreign-memory definitions now loaded by cffi.  System
cffi-fsbv defined for calling functions with foreign structures by
value using libffi.  Current state of this system is to make
libffi-type-pointer and associate with the structure in defcstruct.
This works on test structure
(macroexpand '(defcstruct (complex :class complex-type) (real :double) (imag :double)))
but nothing further is done with the libffi-type-pointer.

To do: fix lookup-type so that if there is no type defined, it returns
nil.  Do iterate-foreign-structure in advance of macro expansion in
cstruct-libffi-hook, if any arguments lack type translation, then
return nil.  This means that that structure can not be passed/returned
by value.  Then load cif after cstruct.  Secondary bug fix: defsynonym
'unsigned to something, not sure what it's supposed to be; :uint?

Example definitions for complex and real-and-complex

Remove all old example definitions, and replace with new ones
compatible with Luis' recent changes to CFFI.  Examples with complex
and real-and-complex as comments.  For now, macro
define-structure-conversion is commented out.

Test cases for structures by hand

cffi-manual: fix secondary values in examples of CONVERT-{TO,FROM}-FOREIGN.

gitignore *.xfasl

cffi-tests: fix duplicate test name.

Make structures translatable when :class is specified.

Update STRUCT-VALUES.* tests.

Move ENHANCED-FOREIGN-TYPE translatableness to TRANSLATABLE-FOREIGN-TYPE.

bugfix: default EXPAND-TO-FOREIGN expansion was ignoring secondary value.

Said expansion breaks the protocol between TRANSLATE-TO-FOREIGN and
FREE-TRANSLATED-OBJECT.

This wasn't an issue when using EXPAND-TO-FOREIGN-DYN since it discards
the default expansion of EXPAND-TO-FOREIGN. Only CONVERT-OBJECT-FOREIGN
and DEFCALLBACK call EXPAND-TO-FOREIGN directly and the latter has to
discard the second value anyway.

Added new "Structure as Values" tests.

All fail but STRUCT-VALUES.TRANSLATION.1.

cffi-tests: remove bogus const qualifier in my_strfree().