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.

10 files changed, 32 insertions, 553 deletions

diff --git a/lang/python23-pth/Makefile b/lang/python23-pth/Makefile
index 1f5a15fb0db..1f6208b86b4 100644
--- a/lang/python23-pth/Makefile
+++ b/lang/python23-pth/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-pth-2.3.2
+DISTNAME=	Python-2.3.3
+PKGNAME=	python23-pth-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-pth/distinfo b/lang/python23-pth/distinfo
index 8f6321cb868..61e7a8b568c 100644
--- a/lang/python23-pth/distinfo
+++ b/lang/python23-pth/distinfo
@@ -1,17 +1,12 @@
-$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 (patch-aa) = 7c27e64068185a767bd1371851c33952711de854
+SHA1 (Python-2.3.3.tgz) = 034d2e3ed011ea753d4fee7efab16e31029b1e5e
+Size (Python-2.3.3.tgz) = 8491380 bytes
+SHA1 (patch-aa) = c4aad8fae46d55df93741a0378f5b930de0a5328
 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) = 1f4353aa56de3bf426c8424bf7b24bbe35e388d4
-SHA1 (patch-am) = 066fc423e4d75ad0d62759b4af2a40f798dfaebf
+SHA1 (patch-al) = af6df0437cdc31dbc66b4590210c72023432cc2f
+SHA1 (patch-am) = 669721695a3983638218267ac59f228cd2a8e93d
diff --git a/lang/python23-pth/patches/patch-aa b/lang/python23-pth/patches/patch-aa
index 0acbec09d4c..ce4ac9e65e2 100644
--- a/lang/python23-pth/patches/patch-aa
+++ b/lang/python23-pth/patches/patch-aa
@@ -1,4 +1,4 @@
-$NetBSD: patch-aa,v 1.3 2003/12/08 21:13:56 recht Exp $
+$NetBSD: patch-aa,v 1.4 2003/12/23 17:24:42 recht Exp $
 
 --- Include/patchlevel.h.orig	2003-10-01 08:47:48.000000000 +0200
 +++ Include/patchlevel.h
@@ -6,8 +6,8 @@ $NetBSD: patch-aa,v 1.3 2003/12/08 21:13:56 recht Exp $
  #define PY_RELEASE_SERIAL	0
  
  /* Version as a string */
--#define PY_VERSION		"2.3.2"
-+#define PY_VERSION		"2p3.2"
+-#define PY_VERSION		"2.3.3"
++#define PY_VERSION		"2p3.3"
  
  /* Version as a single 4-byte hex number, e.g. 0x010502B2 == 1.5.2b2.
     Use this for numeric comparisons, e.g. #if PY_VERSION_HEX >= ... */
diff --git a/lang/python23-pth/patches/patch-ac b/lang/python23-pth/patches/patch-ac
deleted file mode 100644
index d062928ce91..00000000000
--- a/lang/python23-pth/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-pth/patches/patch-ag b/lang/python23-pth/patches/patch-ag
deleted file mode 100644
index 6bca9ddf6d1..00000000000
--- a/lang/python23-pth/patches/patch-ag
+++ /dev/null
@@ -1,216 +0,0 @@
-$NetBSD: patch-ag,v 1.2 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-pth/patches/patch-ai b/lang/python23-pth/patches/patch-ai
deleted file mode 100644
index 3a38ba3400b..00000000000
--- a/lang/python23-pth/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-pth/patches/patch-aj b/lang/python23-pth/patches/patch-aj
deleted file mode 100644
index 19948262988..00000000000
--- a/lang/python23-pth/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-pth/patches/patch-ak b/lang/python23-pth/patches/patch-ak
deleted file mode 100644
index f1bbd32e9fc..00000000000
--- a/lang/python23-pth/patches/patch-ak
+++ /dev/null
@@ -1,68 +0,0 @@
-$NetBSD: patch-ak,v 1.2 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-pth/patches/patch-al b/lang/python23-pth/patches/patch-al
index e398096195a..eeeb4a5a37f 100644
--- a/lang/python23-pth/patches/patch-al
+++ b/lang/python23-pth/patches/patch-al
@@ -1,8 +1,8 @@
-$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
-@@ -1318,7 +1318,7 @@ rm confdefs.h
+--- configure.orig	2003-11-18 20:59:36.000000000 +0100
++++ configure	2003-12-23 12:47:01.000000000 +0100
+@@ -1318,7 +1318,7 @@
  mv confdefs.h.new confdefs.h
  
  
@@ -11,16 +11,16 @@ $NetBSD: patch-al,v 1.4 2003/12/08 21:13:56 recht Exp $
  
  
  SOVERSION=1.0
-@@ -1440,6 +1440,8 @@ case $ac_sys_system/$ac_sys_release in
-   # Reconfirmed for OpenBSD 3.3 by Zachary Hamm.
-   OpenBSD/2.* | OpenBSD/3.[0123])
+@@ -1440,6 +1440,8 @@
+   # 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 @@ cat >>conftest.$ac_ext <<_ACEOF
+@@ -13854,6 +13856,7 @@
  /* end confdefs.h.  */
  
  #include "confdefs.h"
diff --git a/lang/python23-pth/patches/patch-am b/lang/python23-pth/patches/patch-am
index 7b1d469da24..54f2ab2b079 100644
--- a/lang/python23-pth/patches/patch-am
+++ b/lang/python23-pth/patches/patch-am
@@ -1,8 +1,8 @@
-$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
-@@ -15,7 +15,7 @@ from distutils.command.install import in
+--- setup.py.orig	2003-10-21 22:01:21.000000000 +0200
++++ setup.py	2003-12-23 12:46:26.000000000 +0100
+@@ -15,7 +15,7 @@
  from distutils.command.install_lib import install_lib
  
  # This global variable is used to hold the list of modules to be disabled.
@@ -11,7 +11,7 @@ $NetBSD: patch-am,v 1.2 2003/12/08 21:13:56 recht Exp $
  
  def add_dir_to_list(dirlist, dir):
      """Add the directory 'dir' to the list 'dirlist' (at the front) if
-@@ -240,9 +240,15 @@ class PyBuildExt(build_ext):
+@@ -240,9 +240,15 @@
          return sys.platform
  
      def detect_modules(self):
@@ -30,7 +30,7 @@ $NetBSD: patch-am,v 1.2 2003/12/08 21:13:56 recht Exp $
  
          # fink installs lots of goodies in /sw/... - make sure we
          # check there
-@@ -436,9 +442,7 @@ class PyBuildExt(build_ext):
+@@ -436,9 +442,7 @@
                                 depends = ['socketmodule.h']) )
          # Detect SSL support for the socket module (via _ssl)
          ssl_incs = find_file('openssl/ssl.h', inc_dirs,
@@ -41,7 +41,7 @@ $NetBSD: patch-am,v 1.2 2003/12/08 21:13:56 recht Exp $
                               )
          if ssl_incs is not None:
              krb5_h = find_file('krb5.h', inc_dirs,
-@@ -446,9 +450,7 @@ class PyBuildExt(build_ext):
+@@ -446,9 +450,7 @@
              if krb5_h:
                  ssl_incs += krb5_h
          ssl_libs = find_library_file(self.compiler, 'ssl',lib_dirs,
@@ -52,7 +52,7 @@ $NetBSD: patch-am,v 1.2 2003/12/08 21:13:56 recht Exp $
  
          if (ssl_incs is not None and
              ssl_libs is not None):
-@@ -562,9 +564,11 @@ class PyBuildExt(build_ext):
+@@ -562,9 +564,11 @@
                                    include_dirs=db_incs,
                                    libraries=dblibs))
          else:
@@ -67,7 +67,7 @@ $NetBSD: patch-am,v 1.2 2003/12/08 21:13:56 recht Exp $
  
  
          # Look for Berkeley db 1.85.   Note that it is built as a different
-@@ -573,21 +577,30 @@ class PyBuildExt(build_ext):
+@@ -573,21 +577,30 @@
          # accidentally building this module with a later version of the
          # underlying db library.  May BSD-ish Unixes incorporate db 1.85
          # symbols into libc and place the include file in /usr/include.
@@ -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 @@ class PyBuildExt(build_ext):
+@@ -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 @@ def main():
+@@ -1140,7 +1153,7 @@
            ext_modules=[Extension('struct', ['structmodule.c'])],
  
            # Scripts to install