New method #'translate-into-foreign-memory for foreign-string-type

Load cffi-libffi and do FSBV tests in cffi-tests

Create a function named die, use it for error messages

Ignore TYPE in default method of EXPAND-TO-FOREIGN-DYN-INDIRECT

Define BARE-STRUCT-TYPE-P for FOREIGN-TYPEDEFs

Tests for cffi-libffi working

Fix an error in the recursive call in libffi-type-pointer for
foreign-struct-type, now parse the slot-type, which is unparsed.  This
makes FSBV.3 and FSBV.4 succeed.  Removed quote from test FSBV.2; this
makes FSBV.2 succeed.

cffi-tests: make compilation of libtest2_32 and libfsbv_32 optional.

Remove *parse-bare-structs-as-pointers* binding in test

Rewrite backwards-compatibility mode for bare struct types.

* Instead of a special variable, the parsed struct type instance is now
  annotated to let the type system know whether we're dealing with
  deprecated semantics (struct type canonicalizes to :pointer) or not.

  This approach should hopefully be much less error-prone.

* Disabled translations for bare structs.

* Fixed and commented out some bogus tests.

Revert "Bind *PARSE-BARE-STRUCTS-AS-POINTERS* to T in #'MEM-AREF"

This broke other stuff, so revert until we understand what's happening

This reverts commit 944d33183d7b4965d6ea86b37138c6691cd160ca.

Merge branch 'bugfix-v0.10.7.1'

Use new struct spec in DEFINE-C-STRUCT-WRAPPER

Bind *PARSE-BARE-STRUCTS-AS-POINTERS* to T in #'MEM-AREF

Improve documentation of structure reference

Improved the documentation for Foreign Structure Types to more clearly
describe the behavior of mem-aref under the new structure reference
syntax and the compatibility of the bare structure reference with the
old behavior.

Fix compiler macro for mem-aptr (Stas Boukarev)

cffi-ecl: check for long-long support.

cffi-tests: don't attempt to create threads when Lisp doesn't support them.

cffi-tests: exclude encodings requiring BOM in STRING.ENCODINGS.ALL.BASIC.

cffi-tests: replace UTF-16 test with explicit UTF-16{BE,LE} versions.

Fix expand-to-foreign-dyn-indirect

Create a new function #'foreign-expand-runtime-translator-or-binding
which is what the methods
  expand-to-foreign-dyn (value var body (type enhanced-foreign-type))
  expand-to-foreign-dyn-indirect (value var body (type translatable-foreign-type))
both call.  Previously, the body of that function was the body of the
first method, and the second method called that generic function.
This did not work as intended however, the result being that libffi
calls were passed the actual object instead of the pointer.  This
change fixes that problem.

cffi-manual: fix TRANSLATE-NAME-FROM-FOREIGN example.

Apply CANONICALIZE-SYMBOL-NAME-CASE to symbols created via DEFCVAR.

Fix typo: signed 64bit accessor is sb-sys:signed-sap-ref-64

Fix typo: signed 64bit accessor is sb-sys:signed-sap-ref-64

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