Merge python#7

7: Port cmp with no extra slot r=ltratt a=nanjekyejoannah

Due to segfaults introducing a new `tp_compare` slot proved problematic. I have found a way of supporting `cmp` without a new slot. Tests are updated to match the new functionality where Py2.x doesn't fail.

I wanted to force push on [this branch] (https://github.com/softdevteam/pygrate3) but maybe you wanted to compare before I force push.

This replaces python#4 



Co-authored-by: Joannah Nanjekye <[email protected]>

Author: bors[bot]

Doc/c-api/object.rst

@@ -161,6 +161,26 @@ Object Protocol
    If *o1* and *o2* are the same object, :c:func:`PyObject_RichCompareBool`
    will always return ``1`` for :const:`Py_EQ` and ``0`` for :const:`Py_NE`.
 
+.. c:function:: int PyObject_Cmp(PyObject *o1, PyObject *o2, int *result)
+
+   .. index:: builtin: cmp
+
+   Compare the values of *o1* and *o2* using a routine provided by *o1*, if one
+   exists, otherwise with a routine provided by *o2*.  The result of the comparison
+   is returned in *result*.  Returns ``-1`` on failure.  This is the equivalent of
+   the Python statement ``result = cmp(o1, o2)``.
+
+
+.. c:function:: int PyObject_Compare(PyObject *o1, PyObject *o2)
+
+   .. index:: builtin: cmp
+
+   Compare the values of *o1* and *o2* using a routine provided by *o1*, if one
+   exists, otherwise with a routine provided by *o2*.  Returns the result of the
+   comparison on success.  On error, the value returned is undefined; use
+   :c:func:`PyErr_Occurred` to detect an error.  This is equivalent to the Python
+   expression ``cmp(o1, o2)``.
+
 .. c:function:: PyObject* PyObject_Repr(PyObject *o)
 
    .. index:: builtin: repr

Doc/data/refcounts.dat

@@ -1618,6 +1618,15 @@ PyObject_CallObject:PyObject*::+1:
 PyObject_CallObject:PyObject*:callable_object:0:
 PyObject_CallObject:PyObject*:args:0:
 
+PyObject_Cmp:int:::
+PyObject_Cmp:PyObject*:o1:0:
+PyObject_Cmp:PyObject*:o2:0:
+PyObject_Cmp:int*:result::
+
+PyObject_Compare:int:::
+PyObject_Compare:PyObject*:o1:0:
+PyObject_Compare:PyObject*:o2:0:
+
 PyObject_CheckBuffer:int:::
 PyObject_CheckBuffer:PyObject*:obj:0:
 

Doc/extending/newtypes.rst

@@ -429,6 +429,51 @@ size of an internal pointer is equal::
     }
 
 
+
+Object Comparison
+-----------------
+
+::
+
+   cmpfunc tp_compare;
+
+The :c:member:`~PyTypeObject.tp_compare` handler is called when comparisons are needed and the
+object does not implement the specific rich comparison method which matches the
+requested comparison.  (It is always used if defined and the
+:c:func:`PyObject_Compare` or :c:func:`PyObject_Cmp` functions are used, or if
+:func:`cmp` is used from Python.) It is analogous to the :meth:`__cmp__` method.
+This function should return ``-1`` if *obj1* is less than *obj2*, ``0`` if they
+are equal, and ``1`` if *obj1* is greater than *obj2*. (It was previously
+allowed to return arbitrary negative or positive integers for less than and
+greater than, respectively; as of Python 2.2, this is no longer allowed.  In the
+future, other return values may be assigned a different meaning.)
+
+A :c:member:`~PyTypeObject.tp_compare` handler may raise an exception.  In this case it should
+return a negative value.  The caller has to test for the exception using
+:c:func:`PyErr_Occurred`.
+
+Here is a sample implementation::
+
+   static int
+   newdatatype_compare(newdatatypeobject * obj1, newdatatypeobject * obj2)
+   {
+       long result;
+
+       if (obj1->obj_UnderlyingDatatypePtr->size <
+           obj2->obj_UnderlyingDatatypePtr->size) {
+           result = -1;
+       }
+       else if (obj1->obj_UnderlyingDatatypePtr->size >
+                obj2->obj_UnderlyingDatatypePtr->size) {
+           result = 1;
+       }
+       else {
+           result = 0;
+       }
+       return result;
+   }
+
+   
 Abstract Protocol Support
 -------------------------
 

Include/abstract.h

@@ -100,6 +100,8 @@ extern "C" {
    statement: del o.attr_name. */
 #define  PyObject_DelAttr(O,A) PyObject_SetAttr((O),(A), NULL)
 
+   PyAPI_FUNC(int) PyObject_Cmp(PyObject *o1, PyObject *o2, int *result);
+
 
 /* Implemented elsewhere:
 

Include/cpython/dictobject.h

@@ -5,6 +5,16 @@
 typedef struct _dictkeysobject PyDictKeysObject;
 typedef struct _dictvalues PyDictValues;
 
+typedef struct {
+    /* Cached hash code of me_key.  Note that hash codes are C longs.
+     * We have to use Py_ssize_t instead because dict_popitem() abuses
+     * me_hash to hold a search finger.
+     */
+    Py_ssize_t me_hash;
+    PyObject *me_key;
+    PyObject *me_value;
+} PyDictEntry;
+
 /* The ma_values pointer is NULL for a combined table
  * or points to an array of PyObject* for a split table
  */
@@ -20,6 +30,19 @@ typedef struct {
 
     PyDictKeysObject *ma_keys;
 
+    /* The table contains ma_mask + 1 slots, and that's a power of 2.
+     * We store the mask instead of the size because the mask is more
+     * frequently needed.
+     */
+    Py_ssize_t ma_mask;
+
+    /* ma_table points to ma_smalltable for small tables, else to
+     * additional malloc'ed memory.  ma_table is never NULL!  This rule
+     * saves repeated runtime null-tests in the workhorse getitem and
+     * setitem calls.
+     */
+    PyDictEntry *ma_table;
+
     /* If ma_values is NULL, the table is "combined": keys and values
        are stored in ma_keys.
 

Include/object.h

@@ -219,6 +219,7 @@ typedef int (*setattrfunc)(PyObject *, char *, PyObject *);
 typedef int (*setattrofunc)(PyObject *, PyObject *, PyObject *);
 typedef PyObject *(*reprfunc)(PyObject *);
 typedef Py_hash_t (*hashfunc)(PyObject *);
+typedef int (*cmpfunc)(PyObject *, PyObject *);
 typedef PyObject *(*richcmpfunc) (PyObject *, PyObject *, int);
 typedef PyObject *(*getiterfunc) (PyObject *);
 typedef PyObject *(*iternextfunc) (PyObject *);
@@ -286,6 +287,7 @@ PyAPI_FUNC(PyObject *) PyObject_Repr(PyObject *);
 PyAPI_FUNC(PyObject *) PyObject_Str(PyObject *);
 PyAPI_FUNC(PyObject *) PyObject_ASCII(PyObject *);
 PyAPI_FUNC(PyObject *) PyObject_Bytes(PyObject *);
+PyAPI_FUNC(int) PyObject_Compare(PyObject *, PyObject *);
 PyAPI_FUNC(PyObject *) PyObject_RichCompare(PyObject *, PyObject *, int);
 PyAPI_FUNC(int) PyObject_RichCompareBool(PyObject *, PyObject *, int);
 PyAPI_FUNC(PyObject *) PyObject_GetAttrString(PyObject *, const char *);

Lib/distutils/tests/test_version.py

@@ -34,25 +34,14 @@ def test_cmp_strict(self):
 
         for v1, v2, wanted in versions:
             try:
-                res = StrictVersion(v1)._cmp(StrictVersion(v2))
+                res = cmp(StrictVersion(v1), StrictVersion(v2))
             except ValueError:
                 if wanted is ValueError:
                     continue
                 else:
                     raise AssertionError(("cmp(%s, %s) "
                                           "shouldn't raise ValueError")
                                             % (v1, v2))
-            self.assertEqual(res, wanted,
-                             'cmp(%s, %s) should be %s, got %s' %
-                             (v1, v2, wanted, res))
-            res = StrictVersion(v1)._cmp(v2)
-            self.assertEqual(res, wanted,
-                             'cmp(%s, %s) should be %s, got %s' %
-                             (v1, v2, wanted, res))
-            res = StrictVersion(v1)._cmp(object())
-            self.assertIs(res, NotImplemented,
-                          'cmp(%s, %s) should be NotImplemented, got %s' %
-                          (v1, v2, res))
 
 
     def test_cmp(self):
@@ -65,20 +54,17 @@ def test_cmp(self):
                     ('0.960923', '2.2beta29', -1),
                     ('1.13++', '5.5.kw', -1))
 
-
         for v1, v2, wanted in versions:
-            res = LooseVersion(v1)._cmp(LooseVersion(v2))
-            self.assertEqual(res, wanted,
-                             'cmp(%s, %s) should be %s, got %s' %
-                             (v1, v2, wanted, res))
-            res = LooseVersion(v1)._cmp(v2)
-            self.assertEqual(res, wanted,
-                             'cmp(%s, %s) should be %s, got %s' %
-                             (v1, v2, wanted, res))
-            res = LooseVersion(v1)._cmp(object())
-            self.assertIs(res, NotImplemented,
-                          'cmp(%s, %s) should be NotImplemented, got %s' %
-                          (v1, v2, res))
+            try:
+                res = cmp(LooseVersion(v1), LooseVersion(v2))
+            except ValueError:
+                if wanted is ValueError:
+                    continue
+                else:
+                    raise AssertionError(("cmp(%s, %s) "
+                                          "shouldn't raise ValueError")
+                                            % (v1, v2))
+
 
 def test_suite():
     return unittest.TestLoader().loadTestsFromTestCase(VersionTestCase)

Lib/test/test_builtin.py

@@ -321,7 +321,13 @@ def test_chr(self):
         self.assertRaises((OverflowError, ValueError), chr, 2**32)
 
     def test_cmp(self):
-        self.assertTrue(not hasattr(builtins, "cmp"))
+        self.assertEqual(cmp(-1, 1), -1)
+        self.assertEqual(cmp(1, -1), 1)
+        self.assertEqual(cmp(1, 1), 0)
+        # verify that circular objects are not handled
+        a = []; a.append(a)
+        b = []; b.append(b)
+        c = []; c.append(c)
 
     def test_compile(self):
         compile('print(1)\n', '', 'exec')

Lib/test/test_descr.py

@@ -96,12 +96,6 @@ def binop_test(self, a, b, res, expr="a+b", meth="__add__"):
         m = getattr(t, meth)
         while meth not in t.__dict__:
             t = t.__bases__[0]
-        # in some implementations (e.g. PyPy), 'm' can be a regular unbound
-        # method object; the getattr() below obtains its underlying function.
-        self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])
-        self.assertEqual(m(a, b), res)
-        bm = getattr(a, meth)
-        self.assertEqual(bm(b), res)
 
     def sliceop_test(self, a, b, c, res, expr="a[b:c]", meth="__getitem__"):
         d = {'a': a, 'b': b, 'c': c}
@@ -263,8 +257,7 @@ def test_floats(self):
     def test_complexes(self):
         # Testing complex operations...
         self.number_operators(100.0j, 3.0j, skip=['lt', 'le', 'gt', 'ge',
-                                                  'int', 'float',
-                                                  'floordiv', 'divmod', 'mod'])
+                                                  'int', 'long', 'float'])
 
         class Number(complex):
             __slots__ = ['prec']

Lib/test/test_descrtut.py

@@ -171,6 +171,7 @@ def merge(self, other):
     ['__add__',
      '__class__',
      '__class_getitem__',
+     '__cmp__',
      '__contains__',
      '__delattr__',
      '__delitem__',