diff options
author | recht <recht> | 2003-12-23 17:24:42 +0000 |
---|---|---|
committer | recht <recht> | 2003-12-23 17:24:42 +0000 |
commit | 8c83c011c8904fbc50a30d4e064e9b90fcf9bc4a (patch) | |
tree | 4c92347ad3099dfb4feb17a70da59ac41d8b6913 /lang/python23 | |
parent | 28dc61a45d6ca0b2eafc8b180994b4713268f93b (diff) | |
download | pkgsrc-8c83c011c8904fbc50a30d4e064e9b90fcf9bc4a.tar.gz |
update to 2.3.3
This is a bug-fix release for Python 2.3 that fixes a number of bugs,
including a couple of serious errors with weakrefs and the cyclic garbage
collector. There are also a number of fixes to the standard library
- see the release notes ( http://www.python.org/2.3.3/NEWS.html )for details.
Diffstat (limited to 'lang/python23')
-rw-r--r-- | lang/python23/Makefile | 8 | ||||
-rw-r--r-- | lang/python23/distinfo | 15 | ||||
-rw-r--r-- | lang/python23/patches/patch-ac | 13 | ||||
-rw-r--r-- | lang/python23/patches/patch-ag | 216 | ||||
-rw-r--r-- | lang/python23/patches/patch-ai | 21 | ||||
-rw-r--r-- | lang/python23/patches/patch-aj | 198 | ||||
-rw-r--r-- | lang/python23/patches/patch-ak | 68 | ||||
-rw-r--r-- | lang/python23/patches/patch-al | 12 | ||||
-rw-r--r-- | lang/python23/patches/patch-am | 10 |
9 files changed, 20 insertions, 541 deletions
diff --git a/lang/python23/Makefile b/lang/python23/Makefile index 79de7d23e09..f5a079e2a91 100644 --- a/lang/python23/Makefile +++ b/lang/python23/Makefile @@ -1,10 +1,10 @@ -# $NetBSD: Makefile,v 1.11 2003/12/08 21:13:56 recht Exp $ +# $NetBSD: Makefile,v 1.12 2003/12/23 17:24:42 recht Exp $ # -DISTNAME= Python-2.3.2 -PKGNAME= python23-2.3.2 +DISTNAME= Python-2.3.3 +PKGNAME= python23-2.3.3 CATEGORIES= lang -MASTER_SITES= ftp://ftp.python.org/pub/python/2.3.2/ +MASTER_SITES= ftp://ftp.python.org/pub/python/2.3.3/ EXTRACT_SUFX= .tgz MAINTAINER= recht@NetBSD.org diff --git a/lang/python23/distinfo b/lang/python23/distinfo index c75a3566e01..b2de11aef99 100644 --- a/lang/python23/distinfo +++ b/lang/python23/distinfo @@ -1,16 +1,11 @@ -$NetBSD: distinfo,v 1.8 2003/12/08 21:13:56 recht Exp $ +$NetBSD: distinfo,v 1.9 2003/12/23 17:24:42 recht Exp $ -SHA1 (Python-2.3.2.tgz) = 2176d1c42802ea2f9d430f23f1d578e00336c6aa -Size (Python-2.3.2.tgz) = 8459427 bytes +SHA1 (Python-2.3.3.tgz) = 034d2e3ed011ea753d4fee7efab16e31029b1e5e +Size (Python-2.3.3.tgz) = 8491380 bytes SHA1 (patch-ab) = 111d7fa8adbb7001bacad36e3bdbe23ae6ce8b9b -SHA1 (patch-ac) = 30c16b3770fed3324a38c18426d9d7758e8db889 SHA1 (patch-ad) = c8f6ea08e68dae3bd9ad639c38e74cf654c0b41e SHA1 (patch-ae) = 544af90b9b7c5eb5cbad0ba0cefa3d9496b5efe3 SHA1 (patch-af) = 2989a1975c8ea435903eafc9add57cb7c4d7de14 -SHA1 (patch-ag) = e2bf14e5858b4273148f1feaf46d5fbb325640a9 SHA1 (patch-ah) = 6e44407c89edcee59b1f674783544884e96cf101 -SHA1 (patch-ai) = 6299b36119927e87a9a1ea7ef1859ec5f833d0b1 -SHA1 (patch-aj) = 91c1679f8109922c30e4d25fe6f99c856dc6e3d5 -SHA1 (patch-ak) = cabeb3d84102bd8be8c109986f7afb8fc147cd5a -SHA1 (patch-al) = b0fd18aca1949c65a342ae67c7d3ba012f40398b -SHA1 (patch-am) = 78b10cd547aa929f397abe9d4b554efda851667b +SHA1 (patch-al) = 3678af129442eb5602f2c8ccec7dc7030b554775 +SHA1 (patch-am) = 8580ec64d2d369f4426e30368e10d350aac82c03 diff --git a/lang/python23/patches/patch-ac b/lang/python23/patches/patch-ac deleted file mode 100644 index d062928ce91..00000000000 --- a/lang/python23/patches/patch-ac +++ /dev/null @@ -1,13 +0,0 @@ -$NetBSD: patch-ac,v 1.1 2003/12/08 21:13:56 recht Exp $ - ---- Include/weakrefobject.h.orig 2002-08-12 09:21:58.000000000 +0200 -+++ Include/weakrefobject.h -@@ -39,6 +39,8 @@ PyAPI_FUNC(PyObject *) PyWeakref_GetObje - - PyAPI_FUNC(long) _PyWeakref_GetWeakrefCount(PyWeakReference *head); - -+PyAPI_FUNC(void) _PyWeakref_ClearRef(PyWeakReference *self); -+ - #define PyWeakref_GET_OBJECT(ref) (((PyWeakReference *)(ref))->wr_object) - - diff --git a/lang/python23/patches/patch-ag b/lang/python23/patches/patch-ag deleted file mode 100644 index a1cbd0406a6..00000000000 --- a/lang/python23/patches/patch-ag +++ /dev/null @@ -1,216 +0,0 @@ -$NetBSD: patch-ag,v 1.1 2003/12/08 21:13:56 recht Exp $ - ---- Lib/test/test_weakref.py.orig 2003-07-14 23:37:17.000000000 +0200 -+++ Lib/test/test_weakref.py -@@ -299,6 +299,211 @@ class ReferencesTestCase(TestBase): - self.fail("exception not properly restored") - - -+ def test_callback_in_cycle_1(self): -+ import gc -+ -+ class J(object): -+ pass -+ -+ class II(object): -+ def acallback(self, ignore): -+ self.J -+ -+ I = II() -+ I.J = J -+ I.wr = weakref.ref(J, I.acallback) -+ -+ # Now J and II are each in a self-cycle (as all new-style class -+ # objects are, since their __mro__ points back to them). I holds -+ # both a weak reference (I.wr) and a strong reference (I.J) to class -+ # J. I is also in a cycle (I.wr points to a weakref that references -+ # I.acallback). When we del these three, they all become trash, but -+ # the cycles prevent any of them from getting cleaned up immediately. -+ # Instead they have to wait for cyclic gc to deduce that they're -+ # trash. -+ # -+ # gc used to call tp_clear on all of them, and the order in which -+ # it does that is pretty accidental. The exact order in which we -+ # built up these things manages to provoke gc into running tp_clear -+ # in just the right order (I last). Calling tp_clear on II leaves -+ # behind an insane class object (its __mro__ becomes NULL). Calling -+ # tp_clear on J breaks its self-cycle, but J doesn't get deleted -+ # just then because of the strong reference from I.J. Calling -+ # tp_clear on I starts to clear I's __dict__, and just happens to -+ # clear I.J first -- I.wr is still intact. That removes the last -+ # reference to J, which triggers the weakref callback. The callback -+ # tries to do "self.J", and instances of new-style classes look up -+ # attributes ("J") in the class dict first. The class (II) wants to -+ # search II.__mro__, but that's NULL. The result was a segfault in -+ # a release build, and an assert failure in a debug build. -+ del I, J, II -+ gc.collect() -+ -+ def test_callback_in_cycle_2(self): -+ import gc -+ -+ # This is just like test_callback_in_cycle_1, except that II is an -+ # old-style class. The symptom is different then: an instance of an -+ # old-style class looks in its own __dict__ first. 'J' happens to -+ # get cleared from I.__dict__ before 'wr', and 'J' was never in II's -+ # __dict__, so the attribute isn't found. The difference is that -+ # the old-style II doesn't have a NULL __mro__ (it doesn't have any -+ # __mro__), so no segfault occurs. Instead it got: -+ # test_callback_in_cycle_2 (__main__.ReferencesTestCase) ... -+ # Exception exceptions.AttributeError: -+ # "II instance has no attribute 'J'" in <bound method II.acallback -+ # of <?.II instance at 0x00B9B4B8>> ignored -+ -+ class J(object): -+ pass -+ -+ class II: -+ def acallback(self, ignore): -+ self.J -+ -+ I = II() -+ I.J = J -+ I.wr = weakref.ref(J, I.acallback) -+ -+ del I, J, II -+ gc.collect() -+ -+ def test_callback_in_cycle_3(self): -+ import gc -+ -+ # This one broke the first patch that fixed the last two. In this -+ # case, the objects reachable from the callback aren't also reachable -+ # from the object (c1) *triggering* the callback: you can get to -+ # c1 from c2, but not vice-versa. The result was that c2's __dict__ -+ # got tp_clear'ed by the time the c2.cb callback got invoked. -+ -+ class C: -+ def cb(self, ignore): -+ self.me -+ self.c1 -+ self.wr -+ -+ c1, c2 = C(), C() -+ -+ c2.me = c2 -+ c2.c1 = c1 -+ c2.wr = weakref.ref(c1, c2.cb) -+ -+ del c1, c2 -+ gc.collect() -+ -+ def test_callback_in_cycle_4(self): -+ import gc -+ -+ # Like test_callback_in_cycle_3, except c2 and c1 have different -+ # classes. c2's class (C) isn't reachable from c1 then, so protecting -+ # objects reachable from the dying object (c1) isn't enough to stop -+ # c2's class (C) from getting tp_clear'ed before c2.cb is invoked. -+ # The result was a segfault (C.__mro__ was NULL when the callback -+ # tried to look up self.me). -+ -+ class C(object): -+ def cb(self, ignore): -+ self.me -+ self.c1 -+ self.wr -+ -+ class D: -+ pass -+ -+ c1, c2 = D(), C() -+ -+ c2.me = c2 -+ c2.c1 = c1 -+ c2.wr = weakref.ref(c1, c2.cb) -+ -+ del c1, c2, C, D -+ gc.collect() -+ -+ def test_callback_in_cycle_resurrection(self): -+ import gc -+ -+ # Do something nasty in a weakref callback: resurrect objects -+ # from dead cycles. For this to be attempted, the weakref and -+ # its callback must also be part of the cyclic trash (else the -+ # objects reachable via the callback couldn't be in cyclic trash -+ # to begin with -- the callback would act like an external root). -+ # But gc clears trash weakrefs with callbacks early now, which -+ # disables the callbacks, so the callbacks shouldn't get called -+ # at all (and so nothing actually gets resurrected). -+ -+ alist = [] -+ class C(object): -+ def __init__(self, value): -+ self.attribute = value -+ -+ def acallback(self, ignore): -+ alist.append(self.c) -+ -+ c1, c2 = C(1), C(2) -+ c1.c = c2 -+ c2.c = c1 -+ c1.wr = weakref.ref(c2, c1.acallback) -+ c2.wr = weakref.ref(c1, c2.acallback) -+ -+ def C_went_away(ignore): -+ alist.append("C went away") -+ wr = weakref.ref(C, C_went_away) -+ -+ del c1, c2, C # make them all trash -+ self.assertEqual(alist, []) # del isn't enough to reclaim anything -+ -+ gc.collect() -+ # c1.wr and c2.wr were part of the cyclic trash, so should have -+ # been cleared without their callbacks executing. OTOH, the weakref -+ # to C is bound to a function local (wr), and wasn't trash, so that -+ # callback should have been invoked when C went away. -+ self.assertEqual(alist, ["C went away"]) -+ # The remaining weakref should be dead now (its callback ran). -+ self.assertEqual(wr(), None) -+ -+ del alist[:] -+ gc.collect() -+ self.assertEqual(alist, []) -+ -+ def test_callbacks_on_callback(self): -+ import gc -+ -+ # Set up weakref callbacks *on* weakref callbacks. -+ alist = [] -+ def safe_callback(ignore): -+ alist.append("safe_callback called") -+ -+ class C(object): -+ def cb(self, ignore): -+ alist.append("cb called") -+ -+ c, d = C(), C() -+ c.other = d -+ d.other = c -+ callback = c.cb -+ c.wr = weakref.ref(d, callback) # this won't trigger -+ d.wr = weakref.ref(callback, d.cb) # ditto -+ external_wr = weakref.ref(callback, safe_callback) # but this will -+ self.assert_(external_wr() is callback) -+ -+ # The weakrefs attached to c and d should get cleared, so that -+ # C.cb is never called. But external_wr isn't part of the cyclic -+ # trash, and no cyclic trash is reachable from it, so safe_callback -+ # should get invoked when the bound method object callback (c.cb) -+ # -- which is itself a callback, and also part of the cyclic trash -- -+ # gets reclaimed at the end of gc. -+ -+ del callback, c, d, C -+ self.assertEqual(alist, []) # del isn't enough to clean up cycles -+ gc.collect() -+ self.assertEqual(alist, ["safe_callback called"]) -+ self.assertEqual(external_wr(), None) -+ -+ del alist[:] -+ gc.collect() -+ self.assertEqual(alist, []) -+ - class Object: - def __init__(self, arg): - self.arg = arg diff --git a/lang/python23/patches/patch-ai b/lang/python23/patches/patch-ai deleted file mode 100644 index 3a38ba3400b..00000000000 --- a/lang/python23/patches/patch-ai +++ /dev/null @@ -1,21 +0,0 @@ -$NetBSD: patch-ai,v 1.3 2003/12/08 21:13:56 recht Exp $ - ---- Modules/_sre.c.orig 2003-06-26 16:41:08.000000000 +0200 -+++ Modules/_sre.c -@@ -71,9 +71,14 @@ static char copyright[] = - Win64 (MS_WIN64), Linux64 (__LP64__), Monterey (64-bit AIX) (_LP64) */ - /* FIXME: maybe the limit should be 40000 / sizeof(void*) ? */ - #define USE_RECURSION_LIMIT 7500 --#else - --#if defined(__GNUC__) && defined(WITH_THREAD) && defined(__FreeBSD__) -+#elif defined(__FreeBSD__) -+/* FreeBSD/amd64 and /sparc64 requires even smaller limit */ -+#if defined(__amd64__) -+#define USE_RECURSION_LIMIT 6000 -+#elif defined(__sparc64__) -+#define USE_RECURSION_LIMIT 3000 -+#elif defined(__GNUC__) && defined(WITH_THREAD) - /* the pthreads library on FreeBSD has a fixed 1MB stack size for the - * initial (or "primary") thread, which is insufficient for the default - * recursion limit. gcc 3.x at the default optimisation diff --git a/lang/python23/patches/patch-aj b/lang/python23/patches/patch-aj deleted file mode 100644 index 19948262988..00000000000 --- a/lang/python23/patches/patch-aj +++ /dev/null @@ -1,198 +0,0 @@ -$NetBSD: patch-aj,v 1.2 2003/12/08 21:13:56 recht Exp $ - ---- Modules/gcmodule.c.orig 2003-04-17 19:29:21.000000000 +0200 -+++ Modules/gcmodule.c -@@ -377,13 +377,17 @@ has_finalizer(PyObject *op) - return 0; - } - --/* Move the objects in unreachable with __del__ methods into finalizers. -- * The objects remaining in unreachable do not have __del__ methods, and -- * gc_refs remains GC_TENTATIVELY_UNREACHABLE for them. The objects -- * moved into finalizers have gc_refs changed to GC_REACHABLE. -+/* Move the objects in unreachable with __del__ methods into finalizers, -+ * and weakrefs with callbacks into wr_callbacks. -+ * The objects remaining in unreachable do not have __del__ methods, and are -+ * not weakrefs with callbacks. -+ * The objects moved have gc_refs changed to GC_REACHABLE; the objects -+ * remaining in unreachable are left at GC_TENTATIVELY_UNREACHABLE. - */ - static void --move_finalizers(PyGC_Head *unreachable, PyGC_Head *finalizers) -+move_troublemakers(PyGC_Head *unreachable, -+ PyGC_Head *finalizers, -+ PyGC_Head *wr_callbacks) - { - PyGC_Head *gc = unreachable->gc.gc_next; - -@@ -398,6 +402,12 @@ move_finalizers(PyGC_Head *unreachable, - gc_list_append(gc, finalizers); - gc->gc.gc_refs = GC_REACHABLE; - } -+ else if (PyWeakref_Check(op) && -+ ((PyWeakReference *)op)->wr_callback) { -+ gc_list_remove(gc); -+ gc_list_append(gc, wr_callbacks); -+ gc->gc.gc_refs = GC_REACHABLE; -+ } - gc = next; - } - } -@@ -434,6 +444,93 @@ move_finalizer_reachable(PyGC_Head *fina - } - } - -+/* Clear all trash weakrefs with callbacks. This clears weakrefs first, -+ * which has the happy result of disabling the callbacks without executing -+ * them. A nasty technical complication: a weakref callback can itself be -+ * the target of a weakref, in which case decrefing the callback can cause -+ * another callback to trigger. But we can't allow arbitrary Python code to -+ * get executed at this point (the callback on the callback may try to muck -+ * with other cyclic trash we're trying to collect, even resurrecting it -+ * while we're in the middle of doing tp_clear() on the trash). -+ * -+ * The private _PyWeakref_ClearRef() function exists so that we can clear -+ * the reference in a weakref without triggering a callback on the callback. -+ * -+ * We have to save the callback objects and decref them later. But we can't -+ * allocate new memory to save them (if we can't get new memory, we're dead). -+ * So we grab a new reference on the clear'ed weakref, which prevents the -+ * rest of gc from reclaiming it. _PyWeakref_ClearRef() leaves the -+ * weakref's wr_callback member intact. -+ * -+ * In the end, then, wr_callbacks consists of cleared weakrefs that are -+ * immune from collection. Near the end of gc, after collecting all the -+ * cyclic trash, we call release_weakrefs(). That releases our references -+ * to the cleared weakrefs, which in turn may trigger callbacks on their -+ * callbacks. -+ */ -+static void -+clear_weakrefs(PyGC_Head *wr_callbacks) -+{ -+ PyGC_Head *gc = wr_callbacks->gc.gc_next; -+ -+ for (; gc != wr_callbacks; gc = gc->gc.gc_next) { -+ PyObject *op = FROM_GC(gc); -+ PyWeakReference *wr; -+ -+ assert(IS_REACHABLE(op)); -+ assert(PyWeakref_Check(op)); -+ wr = (PyWeakReference *)op; -+ assert(wr->wr_callback != NULL); -+ Py_INCREF(op); -+ _PyWeakref_ClearRef(wr); -+ } -+} -+ -+/* Called near the end of gc. This gives up the references we own to -+ * cleared weakrefs, allowing them to get collected, and in turn decref'ing -+ * their callbacks. -+ * -+ * If a callback object is itself the target of a weakref callback, -+ * decref'ing the callback object may trigger that other callback. If -+ * that other callback was part of the cyclic trash in this generation, -+ * that won't happen, since we cleared *all* trash-weakref callbacks near -+ * the start of gc. If that other callback was not part of the cyclic trash -+ * in this generation, then it acted like an external root to this round -+ * of gc, so all the objects reachable from that callback are still alive. -+ * -+ * Giving up the references to the weakref objects will probably make -+ * them go away too. However, if a weakref is reachable from finalizers, -+ * it won't go away. We move it to the old generation then. Since a -+ * weakref object doesn't have a finalizer, that's the right thing to do (it -+ * doesn't belong in gc.garbage). -+ * -+ * We return the number of weakref objects freed (those not appended to old). -+ */ -+static int -+release_weakrefs(PyGC_Head *wr_callbacks, PyGC_Head *old) -+{ -+ int num_freed = 0; -+ -+ while (! gc_list_is_empty(wr_callbacks)) { -+ PyGC_Head *gc = wr_callbacks->gc.gc_next; -+ PyObject *op = FROM_GC(gc); -+ PyWeakReference *wr = (PyWeakReference *)op; -+ -+ assert(IS_REACHABLE(op)); -+ assert(PyWeakref_Check(op)); -+ assert(wr->wr_callback != NULL); -+ Py_DECREF(op); -+ if (wr_callbacks->gc.gc_next == gc) { -+ /* object is still alive -- move it */ -+ gc_list_remove(gc); -+ gc_list_append(gc, old); -+ } -+ else -+ ++num_freed; -+ } -+ return num_freed; -+} -+ - static void - debug_instance(char *msg, PyInstanceObject *inst) - { -@@ -535,8 +632,9 @@ collect(int generation) - long n = 0; /* # unreachable objects that couldn't be collected */ - PyGC_Head *young; /* the generation we are examining */ - PyGC_Head *old; /* next older generation */ -- PyGC_Head unreachable; -- PyGC_Head finalizers; -+ PyGC_Head unreachable; /* non-problematic unreachable trash */ -+ PyGC_Head finalizers; /* objects with, & reachable from, __del__ */ -+ PyGC_Head wr_callbacks; /* weakrefs with callbacks */ - PyGC_Head *gc; - - if (delstr == NULL) { -@@ -597,20 +695,33 @@ collect(int generation) - /* All objects in unreachable are trash, but objects reachable from - * finalizers can't safely be deleted. Python programmers should take - * care not to create such things. For Python, finalizers means -- * instance objects with __del__ methods. -+ * instance objects with __del__ methods. Weakrefs with callbacks -+ * can call arbitrary Python code, so those are special-cased too. - * -- * Move unreachable objects with finalizers into a different list. -+ * Move unreachable objects with finalizers, and weakrefs with -+ * callbacks, into different lists. - */ - gc_list_init(&finalizers); -- move_finalizers(&unreachable, &finalizers); -+ gc_list_init(&wr_callbacks); -+ move_troublemakers(&unreachable, &finalizers, &wr_callbacks); -+ /* Clear the trash weakrefs with callbacks. This prevents their -+ * callbacks from getting invoked (when a weakref goes away, so does -+ * its callback). -+ * We do this even if the weakrefs are reachable from finalizers. -+ * If we didn't, breaking cycles in unreachable later could trigger -+ * deallocation of objects in finalizers, which could in turn -+ * cause callbacks to trigger. This may not be ideal behavior. -+ */ -+ clear_weakrefs(&wr_callbacks); - /* finalizers contains the unreachable objects with a finalizer; -- * unreachable objects reachable only *from* those are also -- * uncollectable, and we move those into the finalizers list too. -+ * unreachable objects reachable *from* those are also uncollectable, -+ * and we move those into the finalizers list too. - */ - move_finalizer_reachable(&finalizers); - - /* Collect statistics on collectable objects found and print -- * debugging information. */ -+ * debugging information. -+ */ - for (gc = unreachable.gc.gc_next; gc != &unreachable; - gc = gc->gc.gc_next) { - m++; -@@ -624,6 +735,11 @@ collect(int generation) - */ - delete_garbage(&unreachable, old); - -+ /* Now that we're done analyzing stuff and breaking cycles, let -+ * delayed weakref callbacks run. -+ */ -+ m += release_weakrefs(&wr_callbacks, old); -+ - /* Collect statistics on uncollectable objects found and print - * debugging information. */ - for (gc = finalizers.gc.gc_next; diff --git a/lang/python23/patches/patch-ak b/lang/python23/patches/patch-ak deleted file mode 100644 index 57c98d35816..00000000000 --- a/lang/python23/patches/patch-ak +++ /dev/null @@ -1,68 +0,0 @@ -$NetBSD: patch-ak,v 1.1 2003/12/08 21:13:56 recht Exp $ - ---- Objects/weakrefobject.c.orig 2003-07-14 23:46:23.000000000 +0200 -+++ Objects/weakrefobject.c -@@ -53,17 +53,43 @@ clear_weakref(PyWeakReference *self) - if (*list == self) - *list = self->wr_next; - self->wr_object = Py_None; -- self->wr_callback = NULL; - if (self->wr_prev != NULL) - self->wr_prev->wr_next = self->wr_next; - if (self->wr_next != NULL) - self->wr_next->wr_prev = self->wr_prev; - self->wr_prev = NULL; - self->wr_next = NULL; -- Py_XDECREF(callback); -+ } -+ if (callback != NULL) { -+ Py_DECREF(callback); -+ self->wr_callback = NULL; - } - } - -+/* Cyclic gc uses this to *just* clear the passed-in reference, leaving -+ * the callback intact and uncalled. It must be possible to call self's -+ * tp_dealloc() after calling this, so self has to be left in a sane enough -+ * state for that to work. We expect tp_dealloc to decref the callback -+ * then. The reason for not letting clear_weakref() decref the callback -+ * right now is that if the callback goes away, that may in turn trigger -+ * another callback (if a weak reference to the callback exists) -- running -+ * arbitrary Python code in the middle of gc is a disaster. The convolution -+ * here allows gc to delay triggering such callbacks until the world is in -+ * a sane state again. -+ */ -+void -+_PyWeakref_ClearRef(PyWeakReference *self) -+{ -+ PyObject *callback; -+ -+ assert(self != NULL); -+ assert(PyWeakref_Check(self)); -+ /* Preserve and restore the callback around clear_weakref. */ -+ callback = self->wr_callback; -+ self->wr_callback = NULL; -+ clear_weakref(self); -+ self->wr_callback = callback; -+} - - static void - weakref_dealloc(PyWeakReference *self) -@@ -117,7 +143,7 @@ weakref_hash(PyWeakReference *self) - self->hash = PyObject_Hash(PyWeakref_GET_OBJECT(self)); - return self->hash; - } -- -+ - - static PyObject * - weakref_repr(PyWeakReference *self) -@@ -324,7 +350,7 @@ WRAP_BINARY(proxy_iand, PyNumber_InPlace - WRAP_BINARY(proxy_ixor, PyNumber_InPlaceXor) - WRAP_BINARY(proxy_ior, PyNumber_InPlaceOr) - --static int -+static int - proxy_nonzero(PyWeakReference *proxy) - { - PyObject *o = PyWeakref_GET_OBJECT(proxy); diff --git a/lang/python23/patches/patch-al b/lang/python23/patches/patch-al index d7533b5b752..2a8a5a170cd 100644 --- a/lang/python23/patches/patch-al +++ b/lang/python23/patches/patch-al @@ -1,17 +1,17 @@ -$NetBSD: patch-al,v 1.4 2003/12/08 21:13:56 recht Exp $ +$NetBSD: patch-al,v 1.5 2003/12/23 17:24:42 recht Exp $ ---- configure.orig 2003-09-27 10:58:55.000000000 +0200 -+++ configure 2003-12-08 21:34:21.000000000 +0100 +--- configure.orig 2003-11-18 20:59:36.000000000 +0100 ++++ configure 2003-12-23 12:29:27.000000000 +0100 @@ -1440,6 +1440,8 @@ - # Reconfirmed for OpenBSD 3.3 by Zachary Hamm. - OpenBSD/2.* | OpenBSD/3.[0123]) + # Reconfirmed for OpenBSD 3.3 by Zachary Hamm, for 3.4 by Jason Ish. + OpenBSD/2.* | OpenBSD/3.[01234]) define_xopen_source=no;; + NetBSD/1.5 | NetBSD/1.5.* | NetBSD/1.6 | NetBSD/1.6.* | NetBSD/1.6[A-S]) + define_xopen_source=no;; # On Solaris 2.6, sys/wait.h is inconsistent in the usage # of union __?sigval. Reported by Stuart Bishop. SunOS/5.6) -@@ -13837,6 +13839,7 @@ +@@ -13854,6 +13856,7 @@ /* end confdefs.h. */ #include "confdefs.h" diff --git a/lang/python23/patches/patch-am b/lang/python23/patches/patch-am index 2accab796b4..24bcc341afa 100644 --- a/lang/python23/patches/patch-am +++ b/lang/python23/patches/patch-am @@ -1,7 +1,7 @@ -$NetBSD: patch-am,v 1.2 2003/12/08 21:13:56 recht Exp $ +$NetBSD: patch-am,v 1.3 2003/12/23 17:24:42 recht Exp $ ---- setup.py.orig 2003-09-22 03:19:45.000000000 +0200 -+++ setup.py 2003-12-08 21:33:30.000000000 +0100 +--- setup.py.orig 2003-10-21 22:01:21.000000000 +0200 ++++ setup.py 2003-12-23 12:43:32.000000000 +0100 @@ -15,7 +15,7 @@ from distutils.command.install_lib import install_lib @@ -101,7 +101,7 @@ $NetBSD: patch-am,v 1.2 2003/12/08 21:13:56 recht Exp $ # The standard Unix dbm module: if platform not in ['cygwin']: -@@ -765,7 +778,7 @@ +@@ -770,7 +783,7 @@ # Linux-specific modules exts.append( Extension('linuxaudiodev', ['linuxaudiodev.c']) ) @@ -110,7 +110,7 @@ $NetBSD: patch-am,v 1.2 2003/12/08 21:13:56 recht Exp $ exts.append( Extension('ossaudiodev', ['ossaudiodev.c']) ) if platform == 'sunos5': -@@ -1135,7 +1148,7 @@ +@@ -1140,7 +1153,7 @@ ext_modules=[Extension('struct', ['structmodule.c'])], # Scripts to install |