Fix the last regression shown by cvs2svn

Modules/cPickle.c

 #include "Python.h"
 #include "structmember.h"
 #include "cPickle.h"
 
 PyDoc_STRVAR(cPickle_module_documentation,
 "C implementation and optimization of the Python pickle module.");
 
 #ifndef Py_eval_input
 #include <graminit.h>
 #define Py_eval_input eval_input
@@ skipping 333 matching lines @@
                 return NULL;
         }
         memset(memo->mt_table, 0, MT_MINSIZE * sizeof(PyMemoEntry));
 
         return memo;
 }
 
 STATIC_MEMOTABLE PyMemoTable *
 PyMemoTable_Copy(PyMemoTable *self)
 {
+        Py_ssize_t i;
         PyMemoTable *new = PyMemoTable_New();
         if (new == NULL)
                 return NULL;
 
         new->mt_used = self->mt_used;
         new->mt_allocated = self->mt_allocated;
         new->mt_mask = self->mt_mask;
         /* The table we get from _New() is probably smaller than we wanted.
            Free it and allocate one that's the right size. */
         PyMem_FREE(new->mt_table);
         new->mt_table = PyMem_NEW(PyMemoEntry, self->mt_allocated);
         if (new->mt_table == NULL) {
                 PyMem_FREE(new);
                 return NULL;
+        }
+        for (i = 0; i < self->mt_allocated; i++) {
+                Py_XINCREF(self->mt_table[i].me_key);
         }
         memcpy(new->mt_table, self->mt_table,
                sizeof(PyMemoEntry) * self->mt_allocated);
 
         return new;
 }
 
 STATIC_MEMOTABLE void
 PyMemoTable_Del(PyMemoTable *self)
 {
+        Py_ssize_t i;

[Jeffrey Yasskin, 2009/07/03 01:32:59]

Just call PyMemoTable_Clear()? The extra memset shouldn't cost that much since
everything was just decref'ed, and it might even be optimized away.

+        for (i = 0; i < self->mt_allocated; i++) {
+                Py_XDECREF(self->mt_table[i].me_key);
+        }
+
         PyMem_FREE(self->mt_table);
         PyMem_FREE(self);
 }
 
 STATIC_MEMOTABLE Py_ssize_t
 PyMemoTable_Size(PyMemoTable *self)
 {
         return self->mt_used;
 }
 
 STATIC_MEMOTABLE int
 PyMemoTable_Clear(PyMemoTable *self)
 {
+        Py_ssize_t i;
+        for (i = 0; i < self->mt_allocated; i++) {
+                Py_XDECREF(self->mt_table[i].me_key);
+        }
+
         self->mt_used = 0;
         memset(self->mt_table, 0, self->mt_allocated * sizeof(PyMemoEntry));
         return 0;
 }
 
 /* Since entries cannot be deleted from this hashtable, _PyMemoTable_Lookup()
    can be considerably simpler than dictobject.c's lookdict(). */
 static PyMemoEntry *
-_PyMemoTable_Lookup(PyMemoTable *self, void *key)
+_PyMemoTable_Lookup(PyMemoTable *self, PyObject *key)
 {
         size_t i;
         size_t perturb;
         size_t mask = (size_t)self->mt_mask;
         PyMemoEntry *table = self->mt_table;
         PyMemoEntry *entry;
         long hash = (long)key >> 3;
 
         i = hash & mask;
         entry = &table[i];
@@ skipping 60 matching lines @@
                 }
         }
 
         /* Deallocate the old table. */
         PyMem_FREE(oldtable);
         return 0;
 }
 
 /* Returns NULL on failure, a pointer to the value otherwise. */
 STATIC_MEMOTABLE long *
-PyMemoTable_Get(PyMemoTable *self, void *key)
+PyMemoTable_Get(PyMemoTable *self, PyObject *key)
 {
         PyMemoEntry *entry = _PyMemoTable_Lookup(self, key);
         if (entry->me_key == NULL)
                 return NULL;
         return &entry->me_value;
 }
 
 /* Returns -1 on failure, 0 on success. */
 STATIC_MEMOTABLE int
-PyMemoTable_Set(PyMemoTable *self, void *key, long value)
+PyMemoTable_Set(PyMemoTable *self, PyObject *key, long value)
 {
         PyMemoEntry *entry;
 
         assert(key != NULL);
 
         entry = _PyMemoTable_Lookup(self, key);
         if (entry->me_key != NULL) {
                 entry->me_value = value;
                 return 0;
         }
+        Py_INCREF(key);
         entry->me_key = key;
         entry->me_value = value;
         self->mt_used++;
 
         /* If we added a key, we can safely resize. Otherwise just return!
          * If used >= 2/3 size, adjust size. Normally, this quaduples the size.
          *
          * Quadrupling the size improves average table sparseness
          * (reducing collisions) at the cost of some memory. It also halves
          * the number of expensive resize operations in a growing memo table.
@@ skipping 548 matching lines @@
         char *r = PyMem_NEW(char, n+1);
         if (r == NULL)
                 return (char*)PyErr_NoMemory();
         memcpy(r, s, n);
         r[n] = 0;
         return r;
 }
 
 
 static int
-get(Picklerobject *self, void *id)
+get(Picklerobject *self, PyObject *id)
 {
         long *value;
         char s[30];
         size_t len;
 
         value = PyMemoTable_Get(self->memo, id);
         if (value == NULL)  {
-                PyErr_SetObject(PyExc_KeyError, PyLong_FromVoidPtr(id));
+                PyErr_SetObject(PyExc_KeyError, PyLong_FromVoidPtr((void *)id));
                 return -1;
         }
 
         self->uses_gets = 1;
         if (!self->bin) {
                 s[0] = GET;
                 PyOS_snprintf(s + 1, sizeof(s) - 1, "%ld\n", *value);
                 len = strlen(s);
         }
         else {
@@ skipping 34 matching lines @@
 {
         char c_str[30];
         int p;
         size_t len;
 
         if (self->fast)
                 return 0;
 
         /* PyMemoTable_{Get,Set} doesn't accept null pointers as keys. */
         p = PyMemoTable_Size(self->memo) + 1;
-        if (PyMemoTable_Set(self->memo, (void *)ob, p) < 0)
+        if (PyMemoTable_Set(self->memo, ob, p) < 0)
                 return -1;
 
         if (!self->bin) {
                 c_str[0] = PUT;
                 PyOS_snprintf(c_str + 1, sizeof(c_str) - 1, "%d\n", p);
                 len = strlen(c_str);
         }
         else {
                 if (p >= 256) {
                         c_str[0] = LONG_BINPUT;
@@ skipping 2344 matching lines @@
         }
         else if (PyDict_Check(pymemo)) {
                 PyObject *pykey, *pyval;
                 Py_ssize_t i = 0;
 
                 if (p->memo != NULL)
                         PyMemoTable_Del(p->memo);
                 p->memo = PyMemoTable_New();
 
                 while (PyDict_Next(pymemo, &i, &pykey, &pyval)) {
-                        long val;
-                        void *key = (void *)PyLong_AsLong(pykey);
-                        val = PyLong_AsLong(pyval);
-                        if (PyMemoTable_Set(p->memo, key, val) < 0)
+                        long val = PyLong_AsLong(pyval);
+                        if (PyMemoTable_Set(p->memo, pykey, val) < 0)
                                 return -1;
                 }
 
                 return 0;
         }
         else {
                 PyErr_Format(PyExc_TypeError,
                              "'memo' attribute must be a PicklerMemoProxy "
                              "object or dict, not %.200s",
                              Py_TYPE(pymemo)->tp_name);
@@ skipping 3032 matching lines @@
                 "1.0",  /* Original protocol 0 */
                 "1.1",  /* Protocol 0 + INST */
                 "1.2",  /* Original protocol 1 */
                 "1.3",  /* Protocol 1 + BINFLOAT */
                 "2.0"); /* Original protocol 2 */
         PyDict_SetItemString(d, "format_version", format_version);
         PyDict_SetItemString(d, "compatible_formats", compatible_formats);
         Py_XDECREF(format_version);
         Py_XDECREF(compatible_formats);
 }