Changeset 27

Timestamp:

07/06/06 03:38:28 (2 years ago)

Author:

KirkMcDonald

Message:

PyCallable? to delegate conversion.

Files:

• trunk/examples/testdll/testdll.d (modified) (2 diffs)
• trunk/infrastructure/pyd/class_wrap.d (modified) (2 diffs)
• trunk/infrastructure/pyd/func_wrap.d (modified) (2 diffs)
• trunk/infrastructure/pyd/generators/callable_wrap.py (added)
• trunk/infrastructure/pyd/generators/callable_wrap.txt (added)
• trunk/infrastructure/pyd/make_object.d (modified) (1 diff)

trunk/examples/testdll/testdll.d

@@ -64 +64 @@
-}
-
+void dg_test(void delegate() dg) {
+    dg();
+}
+
-class Bar {
-    int[] m_a;
@@ -98 +102 @@
-    def!("iter_test", iter_test);
-    def!("func_test", func_test);
+    def!("dg_test", dg_test);
-
-    wrapped_class!("Foo", Foo) f;

trunk/infrastructure/pyd/class_wrap.d

@@ -33 +33 @@
-private import std.string;
-
+bool[TypeInfo] wrapped_classes;
+
+// This is split out in case I ever want to make a subtype of a wrapped class.
-template DPyObject_HEAD(T) {
-    mixin PyObject_HEAD;
@@ -346 +349 @@
-    PyModule_AddObject(DPy_Module_p, name, cast(PyObject*)&type);
-    is_wrapped!(T) = true;
-
+
+

trunk/infrastructure/pyd/func_wrap.d

@@ -44 +44 @@
-            PyType_Ready(&type);
-            is_wrapped!(T) = true;
+            wrapped_classes[typeid(T)] = true;
-        }
-        obj* func = cast(obj*)type.tp_new(&type, null, null);
@@ -412 +413 @@
-}
-
+//-----------------------------------------------------------------------------
+// And now the reverse operation: wrapping a Python callable with a delegate.
+// These rely on a whole collection of nasty templates, but the result is both
+// flexible and pretty fast.
+// (Sadly, wrapping a Python callable with a regular function is not quite
+// possible.)
+//-----------------------------------------------------------------------------
+// The steps involved when calling this function are as follows:
+// 1) An instance of DPyWrappedFunc is made, and the callable placed within.
+// 2) The delegate type Dg is broken into its constituent parts.
+// 3) These parts are used to get the proper overload of DPyWrappedFunc.fn
+// 4) A delegate to DPyWrappedFunc.fn is returned.
+// 5) When fn is called, it attempts to cram the arguments into the callable.
+//    If Python objects to this, an exception is raised. Note that this means
+//    any error in converting the callable to a given delegate can only be
+//    detected at runtime.
+
+Dg DPyCallable_AsDelegate(Dg) (PyObject* c) {
+    auto f = new DPyWrappedFunc(c);
+
+    const uint ARGS = NumberOfArgs!(Dg);
+    alias ReturnType!(Dg) Tr;
+    static if (ARGS == 0)
+        return &f.fn!(Tr);
+    else static if (ARGS == 1)
+        return &f.fn!(Tr, ArgType!(Dg, 1));
+    else static if (ARGS == 2)
+        return &f.fn!(Tr, ArgType!(Dg, 1), ArgType!(Dg, 2));
+    else static if (ARGS == 3)
+        return &f.fn!(Tr, ArgType!(Dg, 1), ArgType!(Dg, 2), ArgType!(Dg, 3));
+    else static if (ARGS == 4)
+        return &f.fn!(Tr, ArgType!(Dg, 1), ArgType!(Dg, 2), ArgType!(Dg, 3), ArgType!(Dg, 4));
+    else static if (ARGS == 5)
+        return &f.fn!(Tr, ArgType!(Dg, 1), ArgType!(Dg, 2), ArgType!(Dg, 3), ArgType!(Dg, 4), ArgType!(Dg, 5));
+    else static if (ARGS == 6)
+        return &f.fn!(Tr, ArgType!(Dg, 1), ArgType!(Dg, 2), ArgType!(Dg, 3), ArgType!(Dg, 4), ArgType!(Dg, 5), ArgType!(Dg, 6));
+    else static if (ARGS == 7)
+        return &f.fn!(Tr, ArgType!(Dg, 1), ArgType!(Dg, 2), ArgType!(Dg, 3), ArgType!(Dg, 4), ArgType!(Dg, 5), ArgType!(Dg, 6), ArgType!(Dg, 7));
+    else static if (ARGS == 8)
+        return &f.fn!(Tr, ArgType!(Dg, 1), ArgType!(Dg, 2), ArgType!(Dg, 3), ArgType!(Dg, 4), ArgType!(Dg, 5), ArgType!(Dg, 6), ArgType!(Dg, 7), ArgType!(Dg, 8));
+    else static if (ARGS == 9)
+        return &f.fn!(Tr, ArgType!(Dg, 1), ArgType!(Dg, 2), ArgType!(Dg, 3), ArgType!(Dg, 4), ArgType!(Dg, 5), ArgType!(Dg, 6), ArgType!(Dg, 7), ArgType!(Dg, 8), ArgType!(Dg, 9));
+    else static if (ARGS == 10)
+        return &f.fn!(Tr, ArgType!(Dg, 1), ArgType!(Dg, 2), ArgType!(Dg, 3), ArgType!(Dg, 4), ArgType!(Dg, 5), ArgType!(Dg, 6), ArgType!(Dg, 7), ArgType!(Dg, 8), ArgType!(Dg, 9), ArgType!(Dg, 10));
+    else static assert(false, "Unsupported number of args in delegate type.");
+}
+
+class Dummy { }
+
+private
+class DPyWrappedFunc {
+    PyObject* callable;
+
+    this(PyObject* c) { callable = c; Py_INCREF(c); }
+    ~this() { Py_DECREF(callable); }
+    
+    Tr boilerplate(Tr)(PyObject* ret) {
+        if (ret is null) handle_exception();
+        scope(exit) Py_DECREF(ret);
+        return d_type!(Tr)(ret);
+    }
+    
+    Tr fn(Tr)() {
+        return boilerplate!(Tr)(call());
+    }
+    
+    Tr fn(Tr, T1)(T1 t1) {
+        return boilerplate!(Tr)(call(t1));
+    }
+
+    Tr fn(Tr, T1, T2)(T1 t1, T2 t2) {
+        return boilerplate!(Tr)(call(t1, t2));
+    }
+
+    Tr fn(Tr, T1, T2, T3)(T1 t1, T2 t2, T3 t3) {
+        return boilerplate!(Tr)(call(t1, t2, t3));
+    }
+
+    Tr fn(Tr, T1, T2, T3, T4)(T1 t1, T2 t2, T3 t3, T4 t4) {
+        return boilerplate!(Tr)(call(t1, t2, t3, t4));
+    }
+
+    Tr fn(Tr, T1, T2, T3, T4, T5)(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) {
+        return boilerplate!(Tr)(call(t1, t2, t3, t4, t5));
+    }
+
+    Tr fn(Tr, T1, T2, T3, T4, T5, T6)(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) {
+        return boilerplate!(Tr)(call(t1, t2, t3, t4, t5, t6));
+    }
+
+    Tr fn(Tr, T1, T2, T3, T4, T5, T6, T7)(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7) {
+        return boilerplate!(Tr)(call(t1, t2, t3, t4, t5, t6, t7));
+    }
+
+    Tr fn(Tr, T1, T2, T3, T4, T5, T6, T7, T8)(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8) {
+        return boilerplate!(Tr)(call(t1, t2, t3, t4, t5, t6, t7, t8));
+    }
+
+    Tr fn(Tr, T1, T2, T3, T4, T5, T6, T7, T8, T9)(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9) {
+        return boilerplate!(Tr)(call(t1, t2, t3, t4, t5, t6, t7, t8, t9));
+    }
+
+    Tr fn(Tr, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10) {
+        return boilerplate!(Tr)(call(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10));
+    }
+    
+    template call(T1=Dummy, T2=Dummy, T3=Dummy, T4=Dummy, T5=Dummy, T6=Dummy, T7=Dummy, T8=Dummy, T9=Dummy, T10=Dummy) {
+        PyObject* call (T1 t1=null, T2 t2=null, T3 t3=null, T4 t4=null, T5 t5=null, T6 t6=null, T7 t7=null, T8 t8=null, T9 t9=null, T10 t10=null) {
+            static if (!is(T10 == Dummy))
+                const uint ARGS = 10;
+            else static if (!is(T9 == Dummy))
+                const uint ARGS = 9;
+            else static if (!is(T8 == Dummy))
+                const uint ARGS = 8;
+            else static if (!is(T7 == Dummy))
+                const uint ARGS = 7;
+            else static if (!is(T6 == Dummy))
+                const uint ARGS = 6;
+            else static if (!is(T5 == Dummy))
+                const uint ARGS = 5;
+            else static if (!is(T4 == Dummy))
+                const uint ARGS = 4;
+            else static if (!is(T3 == Dummy))
+                const uint ARGS = 3;
+            else static if (!is(T2 == Dummy))
+                const uint ARGS = 2;
+            else static if (!is(T1 == Dummy))
+                const uint ARGS = 1;
+            else
+                const uint ARGS = 0;
+            PyObject* t = PyTuple_New(ARGS);
+            if (t is null) return null;
+            scope(exit) Py_DECREF(t);
+            static if (!is(T10 == Dummy))
+                PyTuple_SetItem(t, 9, _py(t10));
+            static if (!is(T9 == Dummy))
+                PyTuple_SetItem(t, 8, _py(t9));
+            static if (!is(T8 == Dummy))
+                PyTuple_SetItem(t, 7, _py(t8));
+            static if (!is(T7 == Dummy))
+                PyTuple_SetItem(t, 6, _py(t7));
+            static if (!is(T6 == Dummy))
+                PyTuple_SetItem(t, 5, _py(t6));
+            static if (!is(T5 == Dummy))
+                PyTuple_SetItem(t, 4, _py(t5));
+            static if (!is(T4 == Dummy))
+                PyTuple_SetItem(t, 3, _py(t4));
+            static if (!is(T3 == Dummy))
+                PyTuple_SetItem(t, 2, _py(t3));
+            static if (!is(T2 == Dummy))
+                PyTuple_SetItem(t, 1, _py(t2));
+            static if (!is(T1 == Dummy))
+                PyTuple_SetItem(t, 0, _py(t1));
+            return PyObject_CallObject(callable, t);
+        }
+    }
+}

trunk/infrastructure/pyd/make_object.d

@@ -232 +232 @@
-    } else static if (is(DPyObject : T)) {
-        return new DPyObject(o);
+    } else static if (is(T == void)) {
+        if (o != Py_None) could_not_convert!(T)(o);
+        Py_INCREF(Py_None);
+        return Py_None;
-    } else static if (is(T == class)) {
-        // We can only convert to a class if it has been wrapped, and of course
-        // we can only convert the object if it is the wrapped type.
-        if (is_wrapped!(T) && PyObject_TypeCheck(o, &wrapped_class_type!(T))) {
-    
+
-        }
-        // Otherwise, throw up an exception.
-        could_not_convert!(T)(o);
+    } else static if (is(T == delegate)) {
+        if (PyCallable_Check(o)) {
+            return DPyCallable_AsDelegate!(T)(o);
+        } else could_not_convert!(T)(o);
-    /+
-    } else static if (is(wchar[] : T)) {