Add interface{} args & results in cffi callbacks

Author: b-long

.github/workflows/ci.yml

@@ -136,10 +136,8 @@ jobs:
     - name: Build
       run: go build -v ./...
 
-    # The skipped tests use features the cffi backend does not support yet:
-    # Python callbacks that take an interface{} or return a value
-    # (TestBindFuncs; see cffi_callback.go for the ones that work), and complex
-    # numbers as a slice element rather than a plain function arg/return
-    # (TestBuiltinSlices; see genFuncComplexCFFI in gen_func.go for the case that works).
+    # The skipped test uses a feature the cffi backend does not support yet:
+    # complex numbers as a slice element rather than a plain function
+    # arg/return (see genFuncComplexCFFI in gen_func.go for the case that works).
     - name: Test
-      run: go test -v -skip '^(TestBindFuncs|TestBuiltinSlices)$' ./...
+      run: go test -v -skip '^TestBuiltinSlices$' ./...

_examples/callbacks/callbacks.go

@@ -9,6 +9,7 @@ package callbacks
 import (
 	"fmt"
 	"sync"
+	"time"
 )
 
 // Each calls fun for i in 0..n-1, with a label made from i.
@@ -30,6 +31,49 @@ func Twice(fun func()) {
 	fun()
 }
 
+// Describe calls fun with a string and a fmt.Stringer, as interface{} values.
+// They arrive as strings, made by fmt.Sprintf("%s", v).
+func Describe(fun func(v interface{})) {
+	fun("a string")
+	fun(1500 * time.Millisecond)
+}
+
+// Count returns how many of 0..n-1 keep says yes to.
+func Count(n int, keep func(i int) bool) int {
+	total := 0
+	for i := 0; i < n; i++ {
+		if keep(i) {
+			total++
+		}
+	}
+	return total
+}
+
+// Sum adds up what val returns for 0..n-1.
+func Sum(n int, val func(i int) int) int {
+	total := 0
+	for i := 0; i < n; i++ {
+		total += val(i)
+	}
+	return total
+}
+
+// Widest returns the largest of what size returns for 0..n-1.
+func Widest(n int, size func(i int) uint) uint {
+	var widest uint
+	for i := 0; i < n; i++ {
+		if w := size(i); w > widest {
+			widest = w
+		}
+	}
+	return widest
+}
+
+// Apply returns f(x).
+func Apply(x float64, f func(x float64) float64) float64 {
+	return f(x)
+}
+
 // Counter counts how many times it has been visited.
 type Counter struct {
 	N int
@@ -43,6 +87,11 @@ func (c *Counter) Visit(times int, fun func(c *Counter, n int)) {
 	}
 }
 
+// Check calls fun with the counter itself, and reports what it answered.
+func (c *Counter) Check(fun func(c *Counter, n int) bool) bool {
+	return fun(c, c.N)
+}
+
 // InGoroutine calls fun from another goroutine, and waits for it.
 func InGoroutine(fun func(i int)) {
 	var wg sync.WaitGroup

_examples/callbacks/test.py

@@ -31,6 +31,24 @@ def visit(handle, n):
 c.Visit(2, visit)
 print("counter:", c.N)
 
+print("--- Describe: an interface{} arrives as a string")
+callbacks.Describe(lambda v: print("describe:", repr(v)))
+
+print("--- Count: a bool result")
+print("count:", callbacks.Count(10, lambda i: i % 3 == 0))
+
+print("--- Sum: an int result")
+print("sum:", callbacks.Sum(5, lambda i: i * i))
+
+print("--- Widest: a uint result")
+print("widest:", callbacks.Widest(4, lambda i: i * 10))
+
+print("--- Apply: a float result")
+print("apply:", callbacks.Apply(1.5, lambda x: x * 2))
+
+print("--- Counter.Check: a handle argument and a bool result")
+print("check:", c.Check(lambda handle, n: callbacks.Counter(handle=handle).N == n))
+
 print("--- a bound method")
 
 class Box(object):

bind/cffi_build.py

@@ -160,13 +160,16 @@ def wrapper(name, ret, params, exported):
 
 def callback_setup(pname, ctype, argn):
     """Returns the python source that wraps the callable pname in an
-    ffi.callback, for the C signature in ctype ("callback:void(int64_t,char*)",
-    see cffi_callback.go).  The wrapper passes it on to Go as _cb_<pname>,
-    which is kept referenced by this local variable until the Go call
-    returns: cffi frees a callback as soon as nothing refers to it.
+    ffi.callback, for the C signature in ctype
+    ("callback:<result or void>(<parameter types>)", see cffi_callback.go).
+    The wrapper passes it on to Go as _cb_<pname>, which is kept referenced by
+    this local variable until the Go call returns: cffi frees a callback as
+    soon as nothing refers to it.
+
+    If the callable raises, cffi prints the traceback and returns 0 to Go.
     """
-    cargs = ctype[len("callback:void("):-1]
-    ctypes = cargs.split(",") if cargs else []
+    ret, _, rest = ctype[len("callback:"):].partition("(")
+    ctypes = [t for t in rest[:-1].split(",") if t]
     names = ["a%d" % i for i in range(len(ctypes))]
     conv = []
     for n, t in zip(names, ctypes):
@@ -176,12 +179,23 @@ def callback_setup(pname, ctype, argn):
             conv.append("bool(%s)" % n)
         else:
             conv.append(n)
-    cdecl = "void(%s)" % ", ".join("unsigned char" if t == "bool" else t for t in ctypes)
+    call = "%s(%s)" % (pname, ", ".join(conv))
+    if ret == "void":
+        body = call
+    elif ret == "bool":
+        body = "return 1 if %s else 0" % call
+    else:
+        body = "return %s" % call
+
+    def cdecl_type(t):
+        return "unsigned char" if t == "bool" else t
+
+    cdecl = "%s(%s)" % (cdecl_type(ret), ", ".join(cdecl_type(t) for t in ctypes))
     return "\n".join([
         "    if not callable(%s):" % pname,
         "        raise TypeError('argument %d must be callable, not %%s' %% type(%s).__name__)" % (argn, pname),
         "    def _cbfn_%s(%s):" % (pname, ", ".join(names)),
-        "        %s(%s)" % (pname, ", ".join(conv)),
+        "        %s" % body,
         "    _cb_%s = _ffi.callback(%r, _cbfn_%s)" % (pname, cdecl, pname),
     ])