keep the old UNWRAP Macro and create a new MACRO UNWRAP_OR to cleam the

resources if old unwrap fails

Author: prakashsellathurai

Objects/weakrefobject.c

@@ -530,39 +530,42 @@ proxy_check_ref(PyObject *obj)
     return true;
 }
 
-/*
- * Unwrap a proxy into a strong reference.
- * - If `o` is a live proxy: replaces `o` with the underlying object
- *   (already Py_INCREF'd by _PyWeakref_GET_REF), sets *did_incref = 1.
- * - If `o` is a dead proxy: sets ReferenceError, sets `o` = NULL,
- *   sets *did_incref = 0.
- * - If `o` is not a proxy: Py_INCREF's it, sets *did_incref = 1.
- * Returns 1 on success, 0 on dead proxy (caller must goto error).
+
+/* If a parameter is a proxy, check that it is still "live" and wrap it,
+ * replacing the original value with the raw object.  Raises ReferenceError
+ * if the param is a dead proxy.
  */
-static inline int
-_proxy_unwrap(PyObject **op, int *did_incref)
-{
-    if (PyWeakref_CheckProxy(*op)) {
-        *op = _PyWeakref_GET_REF(*op);
-        if (!proxy_check_ref(*op)) {
-            *did_incref = 0;
-            return 0;
+#define UNWRAP(o) \
+        if (PyWeakref_CheckProxy(o)) { \
+            o = _PyWeakref_GET_REF(o); \
+            if (!proxy_check_ref(o)) { \
+                return NULL; \
+            } \
+        } \
+        else { \
+            Py_INCREF(o); \
+        }
+
+/* Like UNWRAP, but executes `cleanup` before returning NULL.
+ * Use when a prior UNWRAP has already incremented a refcount that
+ * must be released if this unwrap fails.
+ */
+#define UNWRAP_OR(o, cleanup) \
+        if (PyWeakref_CheckProxy(o)) { \
+            o = _PyWeakref_GET_REF(o); \
+            if (!proxy_check_ref(o)) { \
+                cleanup; \
+                return NULL; \
+            } \
+        } \
+        else { \
+            Py_INCREF(o); \
         }
-        /* _PyWeakref_GET_REF already returned a strong ref */
-    }
-    else {
-        Py_INCREF(*op);
-    }
-    *did_incref = 1;
-    return 1;
-}
 
 #define WRAP_UNARY(method, generic) \
     static PyObject * \
     method(PyObject *proxy) { \
-        int proxy_incref = 0; \
-        if (!_proxy_unwrap(&proxy, &proxy_incref)) \
-            return NULL; \
+        UNWRAP(proxy); \
         PyObject* res = generic(proxy); \
         Py_DECREF(proxy); \
         return res; \
@@ -571,19 +574,12 @@ _proxy_unwrap(PyObject **op, int *did_incref)
 #define WRAP_BINARY(method, generic) \
     static PyObject * \
     method(PyObject *x, PyObject *y) { \
-        int x_incref = 0, y_incref = 0; \
-        if (!_proxy_unwrap(&x, &x_incref)) goto clean_up; \
-        if (!_proxy_unwrap(&y, &y_incref)) goto clean_up; \
-        { \
-            PyObject* res = generic(x, y); \
-            Py_DECREF(x); \
-            Py_DECREF(y); \
-            return res; \
-        } \
-    clean_up: \
-        if (x_incref) Py_DECREF(x); \
-        if (y_incref) Py_DECREF(y); \
-        return NULL; \
+        UNWRAP(x); \
+        UNWRAP_OR(y, Py_DECREF(x)); \
+        PyObject* res = generic(x, y); \
+        Py_DECREF(x); \
+        Py_DECREF(y); \
+        return res; \
     }
 
 /* Note that the third arg needs to be checked for NULL since the tp_call
@@ -592,36 +588,27 @@ _proxy_unwrap(PyObject **op, int *did_incref)
 #define WRAP_TERNARY(method, generic) \
     static PyObject * \
     method(PyObject *proxy, PyObject *v, PyObject *w) { \
-        int proxy_incref = 0, v_incref = 0, w_incref = 0; \
-        if (!_proxy_unwrap(&proxy, &proxy_incref)) goto clean_up; \
-        if (!_proxy_unwrap(&v, &v_incref))         goto clean_up; \
+        UNWRAP(proxy); \
+        UNWRAP_OR(v, Py_DECREF(proxy)); \
         if (w != NULL) { \
-            if (!_proxy_unwrap(&w, &w_incref))     goto clean_up; \
+            UNWRAP_OR(w, Py_DECREF(proxy); Py_DECREF(v)); \
         } \
-        { \
-            PyObject* res = generic(proxy, v, w); \
-            Py_DECREF(proxy); \
-            Py_DECREF(v); \
-            Py_XDECREF(w); \
-            return res; \
-        } \
-    clean_up: \
-        if (proxy_incref) Py_DECREF(proxy); \
-        if (v_incref)     Py_DECREF(v); \
-        if (w_incref)     Py_DECREF(w); \
-        return NULL; \
+        PyObject* res = generic(proxy, v, w); \
+        Py_DECREF(proxy); \
+        Py_DECREF(v); \
+        Py_XDECREF(w); \
+        return res; \
     }
 
 #define WRAP_METHOD(method, SPECIAL) \
     static PyObject * \
     method(PyObject *proxy, PyObject *Py_UNUSED(ignored)) { \
-        int proxy_incref = 0; \
-        if (!_proxy_unwrap(&proxy, &proxy_incref)) \
-            return NULL; \
-        PyObject* res = PyObject_CallMethodNoArgs(proxy, &_Py_ID(SPECIAL)); \
-        Py_DECREF(proxy); \
-        return res; \
-    }
+            UNWRAP(proxy); \
+            PyObject* res = PyObject_CallMethodNoArgs(proxy, &_Py_ID(SPECIAL)); \
+            Py_DECREF(proxy); \
+            return res; \
+        }
+
 
 /* direct slots */
 
@@ -664,19 +651,12 @@ proxy_setattr(PyObject *proxy, PyObject *name, PyObject *value)
 static PyObject *
 proxy_richcompare(PyObject *proxy, PyObject *v, int op)
 {
-    int proxy_incref = 0, v_incref = 0;
-    if (!_proxy_unwrap(&proxy, &proxy_incref)) goto clean_up;
-    if (!_proxy_unwrap(&v, &v_incref))         goto clean_up;
-    {
-        PyObject* res = PyObject_RichCompare(proxy, v, op);
-        Py_DECREF(proxy);
-        Py_DECREF(v);
-        return res;
-    }
-clean_up:
-    if (proxy_incref) Py_DECREF(proxy);
-    if (v_incref)     Py_DECREF(v);
-    return NULL;
+    UNWRAP(proxy);
+    UNWRAP_OR(v, Py_DECREF(proxy));
+    PyObject* res = PyObject_RichCompare(proxy, v, op);
+    Py_DECREF(proxy);
+    Py_DECREF(v);
+    return res;
 }
 
 /* number slots */