Merge lp:~jelmer/brz/python3-patiencediff into lp:brz

[Jelmer Vernooij]

 Port patiencediff C extensions to python 3.

 Port patiencediff C extensions to python 3.

[Martin Packman (gz)]

Thanks! I'm not certain about the fancy PatienceSequenceMatcherType initialisation, but does seem to work despite GCC complaining.

review: Approve

[Martin Packman (gz)]

Hm, actually, shouldn't this change use Py_NE or something?

- || PyObject_Compare(a->data, b->data));
+ || PyObject_RichCompareBool(a->data, b->data, Py_LT));

=== modified file 'breezy/_patiencediff_c.c'
--- breezy/_patiencediff_c.c	2017-06-13 02:58:21 +0000
+++ breezy/_patiencediff_c.c	2018-07-12 18:28:33 +0000
@@ -46,12 +46,6 @@
 #define SENTINEL -1
 
 
-/* malloc returns NULL on some platforms if you try to allocate nothing,
- * causing <https://bugs.launchpad.net/bzr/+bug/511267> and
- * <https://bugs.launchpad.net/bzr/+bug/331095>.  On glibc it passes, but
- * let's make it fail to aid testing. */
-#define guarded_malloc(x) ( (x) ? malloc(x) : NULL )
-
 enum {
     OP_EQUAL = 0,
     OP_INSERT,
@@ -151,7 +145,7 @@
 compare_lines(struct line *a, struct line *b)
 {
     return ((a->hash != b->hash)
-            || PyObject_Compare(a->data, b->data));
+            || PyObject_RichCompareBool(a->data, b->data, Py_EQ) == 0);
 }
 
 
@@ -190,7 +184,7 @@
         hsize *= 2;
 
     /* can't be 0 */
-    hashtable = (struct bucket *) guarded_malloc(sizeof(struct bucket) * hsize);
+    hashtable = (struct bucket *)malloc(sizeof(struct bucket) * hsize);
     if (hashtable == NULL) {
         PyErr_NoMemory();
         return 0;
@@ -467,7 +461,7 @@
     last_a_pos = alo - 1;
     last_b_pos = blo - 1;
 
-    lcs = (struct matching_line *)guarded_malloc(sizeof(struct matching_line) * (bhi - blo));
+    lcs = (struct matching_line *)malloc(sizeof(struct matching_line) * (bhi - blo));
     if (lcs == NULL)
         return 0;
 
@@ -628,11 +622,11 @@
         goto error;
 
     if (bsize > 0) {
-        matches = (struct matching_line *)guarded_malloc(sizeof(struct matching_line) * bsize);
+        matches = (struct matching_line *)malloc(sizeof(struct matching_line) * bsize);
         if (matches == NULL)
             goto error;
 
-        backpointers = (Py_ssize_t *)guarded_malloc(sizeof(Py_ssize_t) * bsize * 4);
+        backpointers = (Py_ssize_t *)malloc(sizeof(Py_ssize_t) * bsize * 4);
         if (backpointers == NULL)
             goto error;
     }
@@ -694,11 +688,11 @@
     matches.count = 0;
 
     if (bsize > 0) {
-        matches.matches = (struct matching_block *)guarded_malloc(sizeof(struct matching_block) * bsize);
+        matches.matches = (struct matching_block *)malloc(sizeof(struct matching_block) * bsize);
         if (matches.matches == NULL)
             goto error;
 
-        backpointers = (Py_ssize_t *)guarded_malloc(sizeof(Py_ssize_t) * bsize * 4);
+        backpointers = (Py_ssize_t *)malloc(sizeof(Py_ssize_t) * bsize * 4);
         if (backpointers == NULL)
             goto error;
     } else {
@@ -767,7 +761,7 @@
         }
 
         if (self->bsize > 0) {
-            self->backpointers = (Py_ssize_t *)guarded_malloc(sizeof(Py_ssize_t) * self->bsize * 4);
+            self->backpointers = (Py_ssize_t *)malloc(sizeof(Py_ssize_t) * self->bsize * 4);
             if (self->backpointers == NULL) {
                 Py_DECREF(self);
                 PyErr_NoMemory();
@@ -790,7 +784,7 @@
     free(self->hashtable.table);
     delete_lines(self->b, self->bsize);
     delete_lines(self->a, self->asize);
-    self->ob_type->tp_free((PyObject *)self);
+    ((PyObject *)self)->ob_type->tp_free((PyObject *)self);
 }
 
 
@@ -819,7 +813,7 @@
     matches.count = 0;
     if (self->bsize > 0) {
         matches.matches = (struct matching_block *)
-            guarded_malloc(sizeof(struct matching_block) * self->bsize);
+            malloc(sizeof(struct matching_block) * self->bsize);
         if (matches.matches == NULL)
             return PyErr_NoMemory();
     } else
@@ -900,7 +894,7 @@
     struct matching_blocks matches;
 
     matches.count = 0;
-    matches.matches = (struct matching_block *)guarded_malloc(sizeof(struct matching_block) * (self->bsize + 1));
+    matches.matches = (struct matching_block *)malloc(sizeof(struct matching_block) * (self->bsize + 1));
     if (matches.matches == NULL)
         return PyErr_NoMemory();
 
@@ -1005,7 +999,7 @@
         return NULL;
 
     matches.count = 0;
-    matches.matches = (struct matching_block *)guarded_malloc(sizeof(struct matching_block) * (self->bsize + 1));
+    matches.matches = (struct matching_block *)malloc(sizeof(struct matching_block) * (self->bsize + 1));
     if (matches.matches == NULL)
         return PyErr_NoMemory();
 
@@ -1023,7 +1017,7 @@
     matches.count++;
 
     ncodes = 0;
-    codes = (struct opcode *)guarded_malloc(sizeof(struct opcode) * matches.count * 2);
+    codes = (struct opcode *)malloc(sizeof(struct opcode) * matches.count * 2);
     if (codes == NULL) {
         free(matches.matches);
         return PyErr_NoMemory();
@@ -1170,44 +1164,13 @@
 
 static PyTypeObject PatienceSequenceMatcherType = {
     PyObject_HEAD_INIT(NULL)
-    0,                                           /* ob_size */
-    "PatienceSequenceMatcher",                   /* tp_name */
-    sizeof(PatienceSequenceMatcher),             /* tp_basicsize */
-    0,                                           /* tp_itemsize */
-    (destructor)PatienceSequenceMatcher_dealloc, /* tp_dealloc */
-    0,                                           /* tp_print */
-    0,                                           /* tp_getattr */
-    0,                                           /* tp_setattr */
-    0,                                           /* tp_compare */
-    0,                                           /* tp_repr */
-    0,                                           /* tp_as_number */
-    0,                                           /* tp_as_sequence */
-    0,                                           /* tp_as_mapping */
-    0,                                           /* tp_hash */
-    0,                                           /* tp_call */
-    0,                                           /* tp_str */
-    0,                                           /* tp_getattro */
-    0,                                           /* tp_setattro */
-    0,                                           /* tp_as_buffer */
-    Py_TPFLAGS_DEFAULT,                          /* tp_flags*/
-    PatienceSequenceMatcher_doc,                 /* tp_doc */
-    0,                                           /* tp_traverse */
-    0,                                           /* tp_clear */
-    0,                                           /* tp_richcompare */
-    0,                                           /* tp_weaklistoffset */
-    0,                                           /* tp_iter */
-    0,                                           /* tp_iternext */
-    PatienceSequenceMatcher_methods,             /* tp_methods */
-    0,                                           /* tp_members */
-    0,                                           /* tp_getset */
-    0,                                           /* tp_base */
-    0,                                           /* tp_dict */
-    0,                                           /* tp_descr_get */
-    0,                                           /* tp_descr_set */
-    0,                                           /* tp_dictoffset */
-    0,                                           /* tp_init */
-    0,                                           /* tp_alloc */
-    PatienceSequenceMatcher_new,                 /* tp_new */
+    .tp_name = "PatienceSequenceMatcher",
+    .tp_basicsize = sizeof(PatienceSequenceMatcher),
+    .tp_dealloc = (destructor)PatienceSequenceMatcher_dealloc,
+    .tp_flags = Py_TPFLAGS_DEFAULT,
+    .tp_doc = PatienceSequenceMatcher_doc,
+    .tp_methods = PatienceSequenceMatcher_methods,
+    .tp_new = PatienceSequenceMatcher_new,
 };
 
 
@@ -1217,23 +1180,23 @@
     {NULL, NULL}
 };
 
-
-PyMODINIT_FUNC
-init_patiencediff_c(void)
+PYMOD_INIT_FUNC(_patiencediff_c)
 {
     PyObject* m;
 
     if (PyType_Ready(&PatienceSequenceMatcherType) < 0)
-        return;
-
-    m = Py_InitModule3("_patiencediff_c", cpatiencediff_methods,
-                       "C implementation of PatienceSequenceMatcher");
-    if (m == NULL)
-      return;
-
+        return PYMOD_ERROR;
+
+    PYMOD_CREATE(m, "_patiencediff_c",
+                 "C implementation of PatienceSequenceMatcher",
+                 cpatiencediff_methods);
+    if (m == NULL) {
+        return PYMOD_ERROR;
+    }
     Py_INCREF(&PatienceSequenceMatcherType);
     PyModule_AddObject(m, "PatienceSequenceMatcher_c",
                        (PyObject *)&PatienceSequenceMatcherType);
+    return PYMOD_SUCCESS(m);
 }