Some preliminary 'with' support.

cnuernber · cnuernber · commit 8da4fa40546d · 2019-11-16T12:14:27.000-07:00
diff --git a/src/libpython_clj/jna/concrete/err.clj b/src/libpython_clj/jna/concrete/err.clj
@@ -194,6 +194,7 @@
 
    This function is normally only used by code that needs to save and restore the error
    indicator temporarily. Use PyErr_Fetch() to save the current error indicator."
+  nil
   [type ensure-pyobj]
   [value ensure-pyobj]
   [traceback ensure-pyobj])
diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
@@ -3,8 +3,13 @@
             [libpython-clj.python.interop :as pyinterop]
             [libpython-clj.python.interpreter :as pyinterp
              :refer [with-gil with-interpreter]]
-            [libpython-clj.python.bridge])
+            [libpython-clj.python.object :as pyobj]
+            [libpython-clj.python.bridge]
+            [libpython-clj.jna :as pyjna]
+            [tech.jna :as jna]
+            [libpython-clj.jna.concrete.err :as py-err])
   (:import [com.sun.jna Pointer]
+           [com.sun.jna.ptr PointerByReference]
            [java.io Writer]
            [libpython_clj.jna PyObject]))
 
@@ -146,3 +151,59 @@
   global interpreter and reinitialization is unsupported cpython."
   []
   (pyinterp/finalize!))
+
+
+(defmacro with
+  "Support for the 'with' statement in python."
+  [bind-vec & body]
+  (when-not (= 2 (count bind-vec))
+    (throw (Exception. "Bind vector must have 2 items")))
+  (let [varname (first bind-vec)]
+    `(with-gil
+       (let [~@bind-vec]
+         (try
+           (with-bindings
+           {#'libpython-clj.python.interpreter/*python-error-handler*
+            (fn []
+              (let [ptype# (PointerByReference.)
+                    pvalue# (PointerByReference.)
+                    ptraceback# (PointerByReference.)
+                    _# (pyjna/PyErr_Fetch ptype# pvalue# ptraceback#)
+                    ptype# (-> (jna/->ptr-backing-store ptype#)
+                               (pyobj/wrap-pyobject true))
+                    pvalue# (-> (jna/->ptr-backing-store pvalue#)
+                                (pyobj/wrap-pyobject true))
+                    ptraceback# (-> (jna/->ptr-backing-store ptraceback#)
+                                    (pyobj/wrap-pyobject true))]
+                ;;We own the references so they have to be released.
+                (throw (ex-info "python error in flight"
+                                {:ptype ptype#
+                                 :pvalue pvalue#
+                                 :ptraceback ptraceback#}))))}
+             (call-attr ~varname "__enter__")
+             (let [retval#
+                   (do
+                     ~@body)]
+               (call-attr ~varname "__exit__" nil nil nil)
+               retval#))
+           (catch Throwable e#
+             (let [einfo# (ex-data e#)]
+               (if (= #{:ptype :pvalue :ptraceback} (set (keys einfo#)))
+                 (let [{ptype# :ptype
+                        pvalue# :pvalue
+                        ptraceback# :ptraceback} einfo#
+                       suppress-error?# (call-attr ~varname "__exit__"
+                                                   ptype#
+                                                   pvalue#
+                                                   ptraceback#)]
+                   (when (and ptype# pvalue# ptraceback#
+                              (not suppress-error?#))
+                     (do
+                       ;;MAnuall incref here because we cannot detach the object
+                       ;;from our gc decref hook added above.
+                       (pyjna/Py_IncRef ptype#)
+                       (pyjna/Py_IncRef pvalue#)
+                       (pyjna/Py_IncRef ptraceback#)
+                       (pyjna/PyErr_Restore ptype# pvalue# ptraceback#)
+                       (pyinterp/check-error-throw))))
+                 (throw e#)))))))))
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
@@ -8,6 +8,7 @@
             JVMBridge
             PyObject]
            [com.sun.jna Pointer]
+           [com.sun.jna.ptr PointerByReference]
            [java.io StringWriter]))
 
 
@@ -247,21 +248,26 @@
       (construct-main-interpreter! (libpy/PyEval_SaveThread) type-symbols))))
 
 
+(def ^:dynamic *python-error-handler* nil)
+
+
 (defn check-error-str
   "Function assumes python stdout and stderr have been redirected"
   []
   (with-gil
     (when-not (= nil (libpy/PyErr_Occurred))
-      (let [custom-writer (StringWriter.)]
-        (with-bindings {#'*err* custom-writer}
-          (libpy/PyErr_Print))
-        (.toString custom-writer)))))
+      (if-not *python-error-handler*
+        (let [custom-writer (StringWriter.)]
+          (with-bindings {#'*err* custom-writer}
+            (libpy/PyErr_Print))
+          (.toString custom-writer))
+        (*python-error-handler*)))))
 
 
 (defn check-error-throw
   []
   (when-let [error-str (check-error-str)]
-    (throw (ex-info error-str {}))))
+    (throw (Exception. ^String error-str))))
 
 
 (defn check-error-log
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
@@ -102,8 +102,9 @@
   called. Used for new references.  This is some of the meat of the issue, however,
   in that getting the two system's garbage collectors to play nice is kind
   of tough."
-  [pyobj]
-  (check-error-throw)
+  [pyobj & [skip-check-error?]]
+  (when-not skip-check-error?
+    (check-error-throw))
   (when pyobj
     (let [interpreter (ensure-bound-interpreter)
           pyobj-value (Pointer/nativeValue (jna/as-ptr pyobj))
diff --git a/testcode/__init__.py b/testcode/__init__.py
@@ -0,0 +1,12 @@
+class WithObjClass:
+    def __init__(self, suppress):
+        self.suppress = suppress
+    def __enter__(self):
+        print( "Entering test obj")
+    def doit_noerr(self):
+        return 1
+    def doit_err(self):
+        raise Exception("Spam", "Eggs")
+    def __exit__(self, ex_type, ex_val, ex_traceback):
+        print( "Exiting: " + str(ex_type) + str(ex_val) + str(ex_traceback))
+        return self.suppress
