diff --git a/Modules/_operator.c b/Modules/_operator.c
--- a/Modules/_operator.c
+++ b/Modules/_operator.c
@@ -1,6 +1,13 @@
#include "Python.h"
+#include "clinic/_operator.c.h"
+
+/*[clinic input]
+module _operator
+[clinic start generated code]*/
+/*[clinic end generated code: output=da39a3ee5e6b4b0d input=672ecf48487521e7]*/
+
PyDoc_STRVAR(operator_doc,
"Operator interface.\n\
\n\
@@ -10,158 +17,702 @@
used for special methods; variants without leading and trailing\n\
'__' are also provided for convenience.");
-#define spam1(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a1) { \
- return AOP(a1); }
-#define spam2(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
- PyObject *a1, *a2; \
- if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \
- return AOP(a1,a2); }
+/*[clinic input]
+_operator.truth -> bool
-#define spamoi(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
- PyObject *a1; int a2; \
- if(! PyArg_ParseTuple(a,"Oi:" #OP,&a1,&a2)) return NULL; \
- return AOP(a1,a2); }
+ a: object
+ /
-#define spam2n(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
- PyObject *a1, *a2; \
- if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \
- if(-1 == AOP(a1,a2)) return NULL; \
- Py_INCREF(Py_None); \
- return Py_None; }
+Return True if a is true, False otherwise.
+[clinic start generated code]*/
-#define spam3n(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
- PyObject *a1, *a2, *a3; \
- if(! PyArg_UnpackTuple(a,#OP,3,3,&a1,&a2,&a3)) return NULL; \
- if(-1 == AOP(a1,a2,a3)) return NULL; \
- Py_INCREF(Py_None); \
- return Py_None; }
-
-#define spami(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a1) { \
- long r; \
- if(-1 == (r=AOP(a1))) return NULL; \
- return PyBool_FromLong(r); }
-
-#define spami2(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
- PyObject *a1, *a2; long r; \
- if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \
- if(-1 == (r=AOP(a1,a2))) return NULL; \
- return PyLong_FromLong(r); }
-
-#define spamn2(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
- PyObject *a1, *a2; Py_ssize_t r; \
- if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \
- if(-1 == (r=AOP(a1,a2))) return NULL; \
- return PyLong_FromSsize_t(r); }
-
-#define spami2b(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
- PyObject *a1, *a2; long r; \
- if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \
- if(-1 == (r=AOP(a1,a2))) return NULL; \
- return PyBool_FromLong(r); }
-
-#define spamrc(OP,A) static PyObject *OP(PyObject *s, PyObject *a) { \
- PyObject *a1, *a2; \
- if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \
- return PyObject_RichCompare(a1,a2,A); }
-
-spami(truth , PyObject_IsTrue)
-spam2(op_add , PyNumber_Add)
-spam2(op_sub , PyNumber_Subtract)
-spam2(op_mul , PyNumber_Multiply)
-spam2(op_matmul , PyNumber_MatrixMultiply)
-spam2(op_floordiv , PyNumber_FloorDivide)
-spam2(op_truediv , PyNumber_TrueDivide)
-spam2(op_mod , PyNumber_Remainder)
-spam1(op_neg , PyNumber_Negative)
-spam1(op_pos , PyNumber_Positive)
-spam1(op_abs , PyNumber_Absolute)
-spam1(op_inv , PyNumber_Invert)
-spam1(op_invert , PyNumber_Invert)
-spam2(op_lshift , PyNumber_Lshift)
-spam2(op_rshift , PyNumber_Rshift)
-spami(op_not_ , PyObject_Not)
-spam2(op_and_ , PyNumber_And)
-spam2(op_xor , PyNumber_Xor)
-spam2(op_or_ , PyNumber_Or)
-spam2(op_iadd , PyNumber_InPlaceAdd)
-spam2(op_isub , PyNumber_InPlaceSubtract)
-spam2(op_imul , PyNumber_InPlaceMultiply)
-spam2(op_imatmul , PyNumber_InPlaceMatrixMultiply)
-spam2(op_ifloordiv , PyNumber_InPlaceFloorDivide)
-spam2(op_itruediv , PyNumber_InPlaceTrueDivide)
-spam2(op_imod , PyNumber_InPlaceRemainder)
-spam2(op_ilshift , PyNumber_InPlaceLshift)
-spam2(op_irshift , PyNumber_InPlaceRshift)
-spam2(op_iand , PyNumber_InPlaceAnd)
-spam2(op_ixor , PyNumber_InPlaceXor)
-spam2(op_ior , PyNumber_InPlaceOr)
-spam2(op_concat , PySequence_Concat)
-spam2(op_iconcat , PySequence_InPlaceConcat)
-spami2b(op_contains , PySequence_Contains)
-spamn2(indexOf , PySequence_Index)
-spamn2(countOf , PySequence_Count)
-spam2(op_getitem , PyObject_GetItem)
-spam2n(op_delitem , PyObject_DelItem)
-spam3n(op_setitem , PyObject_SetItem)
-spamrc(op_lt , Py_LT)
-spamrc(op_le , Py_LE)
-spamrc(op_eq , Py_EQ)
-spamrc(op_ne , Py_NE)
-spamrc(op_gt , Py_GT)
-spamrc(op_ge , Py_GE)
-
-static PyObject*
-op_pow(PyObject *s, PyObject *a)
+static int
+_operator_truth_impl(PyModuleDef *module, PyObject *a)
+/*[clinic end generated code: output=ea2eaf3ec6b75529 input=bc74a4cd90235875]*/
{
- PyObject *a1, *a2;
- if (PyArg_UnpackTuple(a,"pow", 2, 2, &a1, &a2))
- return PyNumber_Power(a1, a2, Py_None);
- return NULL;
+ return PyObject_IsTrue(a);
}
-static PyObject*
-op_ipow(PyObject *s, PyObject *a)
+/*[clinic input]
+_operator.add
+
+ a: object
+ b: object
+ /
+
+Same as a + b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_add_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=131d93208412e1fa input=5efe3bff856ac215]*/
{
- PyObject *a1, *a2;
- if (PyArg_UnpackTuple(a,"ipow", 2, 2, &a1, &a2))
- return PyNumber_InPlacePower(a1, a2, Py_None);
- return NULL;
+ return PyNumber_Add(a, b);
}
+/*[clinic input]
+_operator.sub = _operator.add
+
+Same as a - b.
+[clinic start generated code]*/
+
static PyObject *
-op_index(PyObject *s, PyObject *a)
+_operator_sub_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=dcb1bb6ed4363f20 input=6494c6b100b8e795]*/
+{
+ return PyNumber_Subtract(a, b);
+}
+
+/*[clinic input]
+_operator.mul = _operator.add
+
+Same as a * b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_mul_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=60066b8a571fddb9 input=2368615b4358b70d]*/
+{
+ return PyNumber_Multiply(a, b);
+}
+
+/*[clinic input]
+_operator.matmul = _operator.add
+
+Same as a @ b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_matmul_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=1a858b9c9f5be5a0 input=9ab304e37fb42dd4]*/
+{
+ return PyNumber_MatrixMultiply(a, b);
+}
+
+/*[clinic input]
+_operator.floordiv = _operator.add
+
+Same as a // b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_floordiv_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=7a572a031549cc71 input=bb2e88ba446c612c]*/
+{
+ return PyNumber_FloorDivide(a, b);
+}
+
+/*[clinic input]
+_operator.truediv = _operator.add
+
+Same as a / b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_truediv_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=abf61b84e27c50a4 input=ecbb947673f4eb1f]*/
+{
+ return PyNumber_TrueDivide(a, b);
+}
+
+/*[clinic input]
+_operator.mod = _operator.add
+
+Same as a % b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_mod_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=b267410e8d458001 input=102e19b422342ac1]*/
+{
+ return PyNumber_Remainder(a, b);
+}
+
+/*[clinic input]
+_operator.neg
+
+ a: object
+ /
+
+Same as -a.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_neg(PyModuleDef *module, PyObject *a)
+/*[clinic end generated code: output=f7ca16815c9e6445 input=84f09bdcf27c96ec]*/
+{
+ return PyNumber_Negative(a);
+}
+
+/*[clinic input]
+_operator.pos = _operator.neg
+
+Same as +a.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_pos(PyModuleDef *module, PyObject *a)
+/*[clinic end generated code: output=bdb3fd23bee66563 input=b6445b63fddb8772]*/
+{
+ return PyNumber_Positive(a);
+}
+
+/*[clinic input]
+_operator.abs = _operator.neg
+
+Same as abs(a).
+[clinic start generated code]*/
+
+static PyObject *
+_operator_abs(PyModuleDef *module, PyObject *a)
+/*[clinic end generated code: output=7b08634e1a01043e input=341d07ba86f58039]*/
+{
+ return PyNumber_Absolute(a);
+}
+
+/*[clinic input]
+_operator.inv = _operator.neg
+
+Same as ~a.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_inv(PyModuleDef *module, PyObject *a)
+/*[clinic end generated code: output=61eaa3117783ff06 input=b01a4677739f6eb2]*/
+{
+ return PyNumber_Invert(a);
+}
+
+/*[clinic input]
+_operator.invert = _operator.neg
+
+Same as ~a.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_invert(PyModuleDef *module, PyObject *a)
+/*[clinic end generated code: output=b4e6450a3a4254e4 input=7f2d607176672e55]*/
+{
+ return PyNumber_Invert(a);
+}
+
+/*[clinic input]
+_operator.lshift = _operator.add
+
+Same as a > b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_rshift_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=0a457efe27c34318 input=d2c85bb5a64504c2]*/
+{
+ return PyNumber_Rshift(a, b);
+}
+
+/*[clinic input]
+_operator.not_ = _operator.truth
+
+Same as not a.
+[clinic start generated code]*/
+
+static int
+_operator_not__impl(PyModuleDef *module, PyObject *a)
+/*[clinic end generated code: output=7b8bc9a6e734de74 input=854156d50804d9b8]*/
+{
+ return PyObject_Not(a);
+}
+
+/*[clinic input]
+_operator.and_ = _operator.add
+
+Same as a & b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_and__impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=17d8e1a3ad2b314a input=4f3057c90ec4c99f]*/
+{
+ return PyNumber_And(a, b);
+}
+
+/*[clinic input]
+_operator.xor = _operator.add
+
+Same as a ^ b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_xor_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=0dff742e6fc7bfc9 input=3c5cfa7253d808dd]*/
+{
+ return PyNumber_Xor(a, b);
+}
+
+/*[clinic input]
+_operator.or_ = _operator.add
+
+Same as a | b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_or__impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=dcd5db98b700f6a3 input=b40c6c44f7c79c09]*/
+{
+ return PyNumber_Or(a, b);
+}
+
+/*[clinic input]
+_operator.iadd = _operator.add
+
+Same as a += b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_iadd_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=741dbb10d9212c42 input=d22a91c07ac69227]*/
+{
+ return PyNumber_InPlaceAdd(a, b);
+}
+
+/*[clinic input]
+_operator.isub = _operator.add
+
+Same as a -= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_isub_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=32a8a184d6ded939 input=4591b00d0a0ccafd]*/
+{
+ return PyNumber_InPlaceSubtract(a, b);
+}
+
+/*[clinic input]
+_operator.imul = _operator.add
+
+Same as a *= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_imul_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=7e5b1cc3beebc38f input=0e01fb8631e1b76f]*/
+{
+ return PyNumber_InPlaceMultiply(a, b);
+}
+
+/*[clinic input]
+_operator.imatmul = _operator.add
+
+Same as a @= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_imatmul_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=20d8250f253515ef input=bb614026372cd542]*/
+{
+ return PyNumber_InPlaceMatrixMultiply(a, b);
+}
+
+/*[clinic input]
+_operator.ifloordiv = _operator.add
+
+Same as a //= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_ifloordiv_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=ce07c3b04ea70ff8 input=9df3b5021cff4ca1]*/
+{
+ return PyNumber_InPlaceFloorDivide(a, b);
+}
+
+/*[clinic input]
+_operator.itruediv = _operator.add
+
+Same as a /= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_itruediv_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=08e09a074330a18a input=9a1ee01608f5f590]*/
+{
+ return PyNumber_InPlaceTrueDivide(a, b);
+}
+
+/*[clinic input]
+_operator.imod = _operator.add
+
+Same as a %= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_imod_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=001b49272debf2dc input=d0c384a3ce38e1dd]*/
+{
+ return PyNumber_InPlaceRemainder(a, b);
+}
+
+/*[clinic input]
+_operator.ilshift = _operator.add
+
+Same as a = b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_irshift_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=41204a5a3db1a0ea input=6778dbd0f6e1ec16]*/
+{
+ return PyNumber_InPlaceRshift(a, b);
+}
+
+/*[clinic input]
+_operator.iand = _operator.add
+
+Same as a &= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_iand_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=f661e67c792052c6 input=71dfd8e70c156a7b]*/
+{
+ return PyNumber_InPlaceAnd(a, b);
+}
+
+/*[clinic input]
+_operator.ixor = _operator.add
+
+Same as a ^= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_ixor_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=0afbd9c14c8dc8e4 input=695c32bec0604d86]*/
+{
+ return PyNumber_InPlaceXor(a, b);
+}
+
+/*[clinic input]
+_operator.ior = _operator.add
+
+Same as a |= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_ior_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=d7fc88b85ea88cb4 input=8f01d03eda9920cf]*/
+{
+ return PyNumber_InPlaceOr(a, b);
+}
+
+/*[clinic input]
+_operator.concat = _operator.add
+
+Same as a + b, for a and b sequences.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_concat_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=682ada2e2c97e6f7 input=8544ccd5341a3658]*/
+{
+ return PySequence_Concat(a, b);
+}
+
+/*[clinic input]
+_operator.iconcat = _operator.add
+
+Same as a += b, for a and b sequences.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_iconcat_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=dcecb7a23aec8103 input=8f5fe5722fcd837e]*/
+{
+ return PySequence_InPlaceConcat(a, b);
+}
+
+/*[clinic input]
+_operator.contains -> bool
+
+ a: object
+ b: object
+ /
+
+Same as b in a (note reversed operands).
+[clinic start generated code]*/
+
+static int
+_operator_contains_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=03ff662c89ca87a9 input=9122a69b505fde13]*/
+{
+ return PySequence_Contains(a, b);
+}
+
+/*[clinic input]
+_operator.indexOf -> Py_ssize_t
+
+ a: object
+ b: object
+ /
+
+Return the first index of b in a.
+[clinic start generated code]*/
+
+static Py_ssize_t
+_operator_indexOf_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=26d42f4977f49af9 input=8be2e43b6a6fffe3]*/
+{
+ return PySequence_Index(a, b);
+}
+
+/*[clinic input]
+_operator.countOf = _operator.indexOf
+
+Return the number of times b occurs in a.
+[clinic start generated code]*/
+
+static Py_ssize_t
+_operator_countOf_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=f5299ebb9551469d input=0c3a2656add252db]*/
+{
+ return PySequence_Count(a, b);
+}
+
+/*[clinic input]
+_operator.getitem
+
+ a: object
+ b: object
+ /
+
+Same as a[b].
+[clinic start generated code]*/
+
+static PyObject *
+_operator_getitem_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=21b544623d2705ba input=6682797320e48845]*/
+{
+ return PyObject_GetItem(a, b);
+}
+
+/*[clinic input]
+_operator.setitem
+
+ a: object
+ b: object
+ c: object
+ /
+
+Same as a[b] = c.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_setitem_impl(PyModuleDef *module, PyObject *a, PyObject *b,
+ PyObject *c)
+/*[clinic end generated code: output=76ff744d3a51fe1d input=ceaf453c4d3a58df]*/
+{
+ if (-1 == PyObject_SetItem(a, b, c))
+ return NULL;
+ Py_RETURN_NONE;
+}
+
+/*[clinic input]
+_operator.delitem = _operator.getitem
+
+Same as del a[b].
+[clinic start generated code]*/
+
+static PyObject *
+_operator_delitem_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=3a7f147fe13aa4a7 input=991bec56a0d3ec7f]*/
+{
+ if (-1 == PyObject_DelItem(a, b))
+ return NULL;
+ Py_RETURN_NONE;
+}
+
+/*[clinic input]
+_operator.eq
+
+ a: object
+ b: object
+ /
+
+Same as a == b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_eq_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=45bc057fc8895ca9 input=586fca687a95a83f]*/
+{
+ return PyObject_RichCompare(a, b, Py_EQ);
+}
+
+/*[clinic input]
+_operator.ne = _operator.eq
+
+Same as a != b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_ne_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=3fa2e90e0594d5de input=5d88f23d35e9abac]*/
+{
+ return PyObject_RichCompare(a, b, Py_NE);
+}
+
+/*[clinic input]
+_operator.lt = _operator.eq
+
+Same as a < b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_lt_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=a2bfb71355379293 input=34a59ad6d39d3a2b]*/
+{
+ return PyObject_RichCompare(a, b, Py_LT);
+}
+
+/*[clinic input]
+_operator.le = _operator.eq
+
+Same as a b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_gt_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=dbfaaa3de757eddb input=9bdb45b995ada35b]*/
+{
+ return PyObject_RichCompare(a, b, Py_GT);
+}
+
+/*[clinic input]
+_operator.ge = _operator.eq
+
+Same as a >= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_ge_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=b47508997593279d input=cf1dc4a5ca9c35f5]*/
+{
+ return PyObject_RichCompare(a, b, Py_GE);
+}
+
+/*[clinic input]
+_operator.pow = _operator.add
+
+Same as a ** b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_pow_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=2836618206ae8736 input=690b40f097ab1637]*/
+{
+ return PyNumber_Power(a, b, Py_None);
+}
+
+/*[clinic input]
+_operator.ipow = _operator.add
+
+Same as a **= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_ipow_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=39c9792796907801 input=f00623899d07499a]*/
+{
+ return PyNumber_InPlacePower(a, b, Py_None);
+}
+
+/*[clinic input]
+_operator.index
+
+ a: object
+ /
+
+Same as a.__index__()
+[clinic start generated code]*/
+
+static PyObject *
+_operator_index(PyModuleDef *module, PyObject *a)
+/*[clinic end generated code: output=8b194c72aa287c74 input=6f54d50ea64a579c]*/
{
return PyNumber_Index(a);
}
-static PyObject*
-is_(PyObject *s, PyObject *a)
+/*[clinic input]
+_operator.is_ = _operator.add
+
+Same as a is b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_is__impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=bc1fd7357f64ff22 input=5fa9b97df03c427f]*/
{
- PyObject *a1, *a2, *result = NULL;
- if (PyArg_UnpackTuple(a,"is_", 2, 2, &a1, &a2)) {
- result = (a1 == a2) ? Py_True : Py_False;
- Py_INCREF(result);
- }
+ PyObject *result;
+ result = (a == b) ? Py_True : Py_False;
+ Py_INCREF(result);
return result;
}
-static PyObject*
-is_not(PyObject *s, PyObject *a)
+/*[clinic input]
+_operator.is_not = _operator.add
+
+Same as a is not b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_is_not_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=a350951577b7fb7d input=5a93f7e1a93535f1]*/
{
- PyObject *a1, *a2, *result = NULL;
- if (PyArg_UnpackTuple(a,"is_not", 2, 2, &a1, &a2)) {
- result = (a1 != a2) ? Py_True : Py_False;
- Py_INCREF(result);
- }
+ PyObject *result;
+ result = (a != b) ? Py_True : Py_False;
+ Py_INCREF(result);
return result;
}
-#undef spam1
-#undef spam2
-#undef spam1o
-#undef spam1o
-
/* compare_digest **********************************************************/
/*
@@ -210,53 +761,58 @@
return (result == 0);
}
-PyDoc_STRVAR(length_hint__doc__,
-"length_hint(obj, default=0) -> int\n"
-"Return an estimate of the number of items in obj.\n"
-"This is useful for presizing containers when building from an\n"
-"iterable.\n"
-"\n"
-"If the object supports len(), the result will be\n"
-"exact. Otherwise, it may over- or under-estimate by an\n"
-"arbitrary amount. The result will be an integer >= 0.");
+/*[clinic input]
+_operator.length_hint
-static PyObject *length_hint(PyObject *self, PyObject *args)
+ obj: object
+ default: Py_ssize_t = 0
+ /
+
+Return an estimate of the number of items in obj.
+
+This is useful for presizing containers when building from an iterable.
+
+If the object supports len(), the result will be exact.
+Otherwise, it may over- or under-estimate by an arbitrary amount.
+The result will be an integer >= 0.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_length_hint_impl(PyModuleDef *module, PyObject *obj,
+ Py_ssize_t default_value)
+/*[clinic end generated code: output=48f2cb65f3cc0a2e input=6aaa31a9077ae3a8]*/
{
- PyObject *obj;
- Py_ssize_t defaultvalue = 0, res;
- if (!PyArg_ParseTuple(args, "O|n:length_hint", &obj, &defaultvalue)) {
- return NULL;
- }
- res = PyObject_LengthHint(obj, defaultvalue);
+ Py_ssize_t res;
+
+ res = PyObject_LengthHint(obj, default_value);
if (res == -1 && PyErr_Occurred()) {
return NULL;
}
return PyLong_FromSsize_t(res);
}
+/*[clinic input]
+_operator._compare_digest = _operator.eq
-PyDoc_STRVAR(compare_digest__doc__,
-"compare_digest(a, b) -> bool\n"
-"\n"
-"Return 'a == b'. This function uses an approach designed to prevent\n"
-"timing analysis, making it appropriate for cryptography.\n"
-"a and b must both be of the same type: either str (ASCII only),\n"
-"or any bytes-like object.\n"
-"\n"
-"Note: If a and b are of different lengths, or if an error occurs,\n"
-"a timing attack could theoretically reveal information about the\n"
-"types and lengths of a and b--but not their values.\n");
+Return 'a == b'.
-static PyObject*
-compare_digest(PyObject *self, PyObject *args)
+This function uses an approach designed to prevent
+timing analysis, making it appropriate for cryptography.
+
+a and b must both be of the same type: either str (ASCII only),
+or any bytes-like object.
+
+Note: If a and b are of different lengths, or if an error occurs,
+a timing attack could theoretically reveal information about the
+types and lengths of a and b--but not their values.
+[clinic start generated code]*/
+
+static PyObject *
+_operator__compare_digest_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=41eec2edbbec3ed5 input=9ac7e2c4e30bc356]*/
{
- PyObject *a, *b;
int rc;
- if (!PyArg_ParseTuple(args, "OO:compare_digest", &a, &b)) {
- return NULL;
- }
-
/* ASCII unicode string */
if(PyUnicode_Check(a) && PyUnicode_Check(b)) {
if (PyUnicode_READY(a) == -1 || PyUnicode_READY(b) == -1) {
@@ -323,78 +879,60 @@
/* operator methods **********************************************************/
-#define spam1(OP,DOC) {#OP, OP, METH_VARARGS, PyDoc_STR(DOC)},
-#define spam2(OP,DOC) {#OP, op_##OP, METH_VARARGS, PyDoc_STR(DOC)},
-#define spam1o(OP,DOC) {#OP, OP, METH_O, PyDoc_STR(DOC)},
-#define spam2o(OP,DOC) {#OP, op_##OP, METH_O, PyDoc_STR(DOC)},
-
static struct PyMethodDef operator_methods[] = {
-spam1o(truth,
- "truth(a) -- Return True if a is true, False otherwise.")
-spam2(contains,
- "contains(a, b) -- Same as b in a (note reversed operands).")
-spam1(indexOf,
- "indexOf(a, b) -- Return the first index of b in a.")
-spam1(countOf,
- "countOf(a, b) -- Return the number of times b occurs in a.")
-
-spam1(is_, "is_(a, b) -- Same as a is b.")
-spam1(is_not, "is_not(a, b) -- Same as a is not b.")
-spam2o(index, "index(a) -- Same as a.__index__()")
-spam2(add, "add(a, b) -- Same as a + b.")
-spam2(sub, "sub(a, b) -- Same as a - b.")
-spam2(mul, "mul(a, b) -- Same as a * b.")
-spam2(matmul, "matmul(a, b) -- Same as a @ b.")
-spam2(floordiv, "floordiv(a, b) -- Same as a // b.")
-spam2(truediv, "truediv(a, b) -- Same as a / b.")
-spam2(mod, "mod(a, b) -- Same as a % b.")
-spam2o(neg, "neg(a) -- Same as -a.")
-spam2o(pos, "pos(a) -- Same as +a.")
-spam2o(abs, "abs(a) -- Same as abs(a).")
-spam2o(inv, "inv(a) -- Same as ~a.")
-spam2o(invert, "invert(a) -- Same as ~a.")
-spam2(lshift, "lshift(a, b) -- Same as a > b.")
-spam2o(not_, "not_(a) -- Same as not a.")
-spam2(and_, "and_(a, b) -- Same as a & b.")
-spam2(xor, "xor(a, b) -- Same as a ^ b.")
-spam2(or_, "or_(a, b) -- Same as a | b.")
-spam2(iadd, "a = iadd(a, b) -- Same as a += b.")
-spam2(isub, "a = isub(a, b) -- Same as a -= b.")
-spam2(imul, "a = imul(a, b) -- Same as a *= b.")
-spam2(imatmul, "a = imatmul(a, b) -- Same as a @= b.")
-spam2(ifloordiv, "a = ifloordiv(a, b) -- Same as a //= b.")
-spam2(itruediv, "a = itruediv(a, b) -- Same as a /= b")
-spam2(imod, "a = imod(a, b) -- Same as a %= b.")
-spam2(ilshift, "a = ilshift(a, b) -- Same as a = b.")
-spam2(iand, "a = iand(a, b) -- Same as a &= b.")
-spam2(ixor, "a = ixor(a, b) -- Same as a ^= b.")
-spam2(ior, "a = ior(a, b) -- Same as a |= b.")
-spam2(concat,
- "concat(a, b) -- Same as a + b, for a and b sequences.")
-spam2(iconcat,
- "a = iconcat(a, b) -- Same as a += b, for a and b sequences.")
-spam2(getitem,
- "getitem(a, b) -- Same as a[b].")
-spam2(setitem,
- "setitem(a, b, c) -- Same as a[b] = c.")
-spam2(delitem,
- "delitem(a, b) -- Same as del a[b].")
-spam2(pow, "pow(a, b) -- Same as a ** b.")
-spam2(ipow, "a = ipow(a, b) -- Same as a **= b.")
-spam2(lt, "lt(a, b) -- Same as a=b.")
-
- {"_compare_digest", (PyCFunction)compare_digest, METH_VARARGS,
- compare_digest__doc__},
- {"length_hint", (PyCFunction)length_hint, METH_VARARGS,
- length_hint__doc__},
+ _OPERATOR_TRUTH_METHODDEF
+ _OPERATOR_CONTAINS_METHODDEF
+ _OPERATOR_INDEXOF_METHODDEF
+ _OPERATOR_COUNTOF_METHODDEF
+ _OPERATOR_IS__METHODDEF
+ _OPERATOR_IS_NOT_METHODDEF
+ _OPERATOR_INDEX_METHODDEF
+ _OPERATOR_ADD_METHODDEF
+ _OPERATOR_SUB_METHODDEF
+ _OPERATOR_MUL_METHODDEF
+ _OPERATOR_MATMUL_METHODDEF
+ _OPERATOR_FLOORDIV_METHODDEF
+ _OPERATOR_TRUEDIV_METHODDEF
+ _OPERATOR_MOD_METHODDEF
+ _OPERATOR_NEG_METHODDEF
+ _OPERATOR_POS_METHODDEF
+ _OPERATOR_ABS_METHODDEF
+ _OPERATOR_INV_METHODDEF
+ _OPERATOR_INVERT_METHODDEF
+ _OPERATOR_LSHIFT_METHODDEF
+ _OPERATOR_RSHIFT_METHODDEF
+ _OPERATOR_NOT__METHODDEF
+ _OPERATOR_AND__METHODDEF
+ _OPERATOR_XOR_METHODDEF
+ _OPERATOR_OR__METHODDEF
+ _OPERATOR_IADD_METHODDEF
+ _OPERATOR_ISUB_METHODDEF
+ _OPERATOR_IMUL_METHODDEF
+ _OPERATOR_IMATMUL_METHODDEF
+ _OPERATOR_IFLOORDIV_METHODDEF
+ _OPERATOR_ITRUEDIV_METHODDEF
+ _OPERATOR_IMOD_METHODDEF
+ _OPERATOR_ILSHIFT_METHODDEF
+ _OPERATOR_IRSHIFT_METHODDEF
+ _OPERATOR_IAND_METHODDEF
+ _OPERATOR_IXOR_METHODDEF
+ _OPERATOR_IOR_METHODDEF
+ _OPERATOR_CONCAT_METHODDEF
+ _OPERATOR_ICONCAT_METHODDEF
+ _OPERATOR_GETITEM_METHODDEF
+ _OPERATOR_SETITEM_METHODDEF
+ _OPERATOR_DELITEM_METHODDEF
+ _OPERATOR_POW_METHODDEF
+ _OPERATOR_IPOW_METHODDEF
+ _OPERATOR_EQ_METHODDEF
+ _OPERATOR_NE_METHODDEF
+ _OPERATOR_LT_METHODDEF
+ _OPERATOR_LE_METHODDEF
+ _OPERATOR_GT_METHODDEF
+ _OPERATOR_GE_METHODDEF
+ _OPERATOR__COMPARE_DIGEST_METHODDEF
+ _OPERATOR_LENGTH_HINT_METHODDEF
{NULL, NULL} /* sentinel */
};
@@ -409,6 +947,7 @@
static PyTypeObject itemgetter_type;
+/* AC 3.5: treats first argument as an iterable, otherwise uses *args */
static PyObject *
itemgetter_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
@@ -581,6 +1120,7 @@
static PyTypeObject attrgetter_type;
+/* AC 3.5: treats first argument as an iterable, otherwise uses *args */
static PyObject *
attrgetter_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
@@ -923,6 +1463,7 @@
static PyTypeObject methodcaller_type;
+/* AC 3.5: variable number of arguments, not currently support by AC */
static PyObject *
methodcaller_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
diff --git a/Modules/clinic/_operator.c.h b/Modules/clinic/_operator.c.h
new file mode 100644
--- /dev/null
+++ b/Modules/clinic/_operator.c.h
@@ -0,0 +1,1418 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_operator_truth__doc__,
+"truth($module, a, /)\n"
+"--\n"
+"\n"
+"Return True if a is true, False otherwise.");
+
+#define _OPERATOR_TRUTH_METHODDEF \
+ {"truth", (PyCFunction)_operator_truth, METH_O, _operator_truth__doc__},
+
+static int
+_operator_truth_impl(PyModuleDef *module, PyObject *a);
+
+static PyObject *
+_operator_truth(PyModuleDef *module, PyObject *a)
+{
+ PyObject *return_value = NULL;
+ int _return_value;
+
+ _return_value = _operator_truth_impl(module, a);
+ if ((_return_value == -1) && PyErr_Occurred())
+ goto exit;
+ return_value = PyBool_FromLong((long)_return_value);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_add__doc__,
+"add($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a + b.");
+
+#define _OPERATOR_ADD_METHODDEF \
+ {"add", (PyCFunction)_operator_add, METH_VARARGS, _operator_add__doc__},
+
+static PyObject *
+_operator_add_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_add(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "add",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_add_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_sub__doc__,
+"sub($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a - b.");
+
+#define _OPERATOR_SUB_METHODDEF \
+ {"sub", (PyCFunction)_operator_sub, METH_VARARGS, _operator_sub__doc__},
+
+static PyObject *
+_operator_sub_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_sub(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "sub",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_sub_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_mul__doc__,
+"mul($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a * b.");
+
+#define _OPERATOR_MUL_METHODDEF \
+ {"mul", (PyCFunction)_operator_mul, METH_VARARGS, _operator_mul__doc__},
+
+static PyObject *
+_operator_mul_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_mul(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "mul",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_mul_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_matmul__doc__,
+"matmul($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a @ b.");
+
+#define _OPERATOR_MATMUL_METHODDEF \
+ {"matmul", (PyCFunction)_operator_matmul, METH_VARARGS, _operator_matmul__doc__},
+
+static PyObject *
+_operator_matmul_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_matmul(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "matmul",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_matmul_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_floordiv__doc__,
+"floordiv($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a // b.");
+
+#define _OPERATOR_FLOORDIV_METHODDEF \
+ {"floordiv", (PyCFunction)_operator_floordiv, METH_VARARGS, _operator_floordiv__doc__},
+
+static PyObject *
+_operator_floordiv_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_floordiv(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "floordiv",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_floordiv_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_truediv__doc__,
+"truediv($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a / b.");
+
+#define _OPERATOR_TRUEDIV_METHODDEF \
+ {"truediv", (PyCFunction)_operator_truediv, METH_VARARGS, _operator_truediv__doc__},
+
+static PyObject *
+_operator_truediv_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_truediv(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "truediv",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_truediv_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_mod__doc__,
+"mod($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a % b.");
+
+#define _OPERATOR_MOD_METHODDEF \
+ {"mod", (PyCFunction)_operator_mod, METH_VARARGS, _operator_mod__doc__},
+
+static PyObject *
+_operator_mod_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_mod(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "mod",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_mod_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_neg__doc__,
+"neg($module, a, /)\n"
+"--\n"
+"\n"
+"Same as -a.");
+
+#define _OPERATOR_NEG_METHODDEF \
+ {"neg", (PyCFunction)_operator_neg, METH_O, _operator_neg__doc__},
+
+PyDoc_STRVAR(_operator_pos__doc__,
+"pos($module, a, /)\n"
+"--\n"
+"\n"
+"Same as +a.");
+
+#define _OPERATOR_POS_METHODDEF \
+ {"pos", (PyCFunction)_operator_pos, METH_O, _operator_pos__doc__},
+
+PyDoc_STRVAR(_operator_abs__doc__,
+"abs($module, a, /)\n"
+"--\n"
+"\n"
+"Same as abs(a).");
+
+#define _OPERATOR_ABS_METHODDEF \
+ {"abs", (PyCFunction)_operator_abs, METH_O, _operator_abs__doc__},
+
+PyDoc_STRVAR(_operator_inv__doc__,
+"inv($module, a, /)\n"
+"--\n"
+"\n"
+"Same as ~a.");
+
+#define _OPERATOR_INV_METHODDEF \
+ {"inv", (PyCFunction)_operator_inv, METH_O, _operator_inv__doc__},
+
+PyDoc_STRVAR(_operator_invert__doc__,
+"invert($module, a, /)\n"
+"--\n"
+"\n"
+"Same as ~a.");
+
+#define _OPERATOR_INVERT_METHODDEF \
+ {"invert", (PyCFunction)_operator_invert, METH_O, _operator_invert__doc__},
+
+PyDoc_STRVAR(_operator_lshift__doc__,
+"lshift($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a > b.");
+
+#define _OPERATOR_RSHIFT_METHODDEF \
+ {"rshift", (PyCFunction)_operator_rshift, METH_VARARGS, _operator_rshift__doc__},
+
+static PyObject *
+_operator_rshift_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_rshift(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "rshift",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_rshift_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_not___doc__,
+"not_($module, a, /)\n"
+"--\n"
+"\n"
+"Same as not a.");
+
+#define _OPERATOR_NOT__METHODDEF \
+ {"not_", (PyCFunction)_operator_not_, METH_O, _operator_not___doc__},
+
+static int
+_operator_not__impl(PyModuleDef *module, PyObject *a);
+
+static PyObject *
+_operator_not_(PyModuleDef *module, PyObject *a)
+{
+ PyObject *return_value = NULL;
+ int _return_value;
+
+ _return_value = _operator_not__impl(module, a);
+ if ((_return_value == -1) && PyErr_Occurred())
+ goto exit;
+ return_value = PyBool_FromLong((long)_return_value);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_and___doc__,
+"and_($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a & b.");
+
+#define _OPERATOR_AND__METHODDEF \
+ {"and_", (PyCFunction)_operator_and_, METH_VARARGS, _operator_and___doc__},
+
+static PyObject *
+_operator_and__impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_and_(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "and_",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_and__impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_xor__doc__,
+"xor($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a ^ b.");
+
+#define _OPERATOR_XOR_METHODDEF \
+ {"xor", (PyCFunction)_operator_xor, METH_VARARGS, _operator_xor__doc__},
+
+static PyObject *
+_operator_xor_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_xor(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "xor",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_xor_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_or___doc__,
+"or_($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a | b.");
+
+#define _OPERATOR_OR__METHODDEF \
+ {"or_", (PyCFunction)_operator_or_, METH_VARARGS, _operator_or___doc__},
+
+static PyObject *
+_operator_or__impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_or_(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "or_",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_or__impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_iadd__doc__,
+"iadd($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a += b.");
+
+#define _OPERATOR_IADD_METHODDEF \
+ {"iadd", (PyCFunction)_operator_iadd, METH_VARARGS, _operator_iadd__doc__},
+
+static PyObject *
+_operator_iadd_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_iadd(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "iadd",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_iadd_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_isub__doc__,
+"isub($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a -= b.");
+
+#define _OPERATOR_ISUB_METHODDEF \
+ {"isub", (PyCFunction)_operator_isub, METH_VARARGS, _operator_isub__doc__},
+
+static PyObject *
+_operator_isub_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_isub(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "isub",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_isub_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_imul__doc__,
+"imul($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a *= b.");
+
+#define _OPERATOR_IMUL_METHODDEF \
+ {"imul", (PyCFunction)_operator_imul, METH_VARARGS, _operator_imul__doc__},
+
+static PyObject *
+_operator_imul_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_imul(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "imul",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_imul_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_imatmul__doc__,
+"imatmul($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a @= b.");
+
+#define _OPERATOR_IMATMUL_METHODDEF \
+ {"imatmul", (PyCFunction)_operator_imatmul, METH_VARARGS, _operator_imatmul__doc__},
+
+static PyObject *
+_operator_imatmul_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_imatmul(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "imatmul",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_imatmul_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_ifloordiv__doc__,
+"ifloordiv($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a //= b.");
+
+#define _OPERATOR_IFLOORDIV_METHODDEF \
+ {"ifloordiv", (PyCFunction)_operator_ifloordiv, METH_VARARGS, _operator_ifloordiv__doc__},
+
+static PyObject *
+_operator_ifloordiv_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_ifloordiv(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "ifloordiv",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_ifloordiv_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_itruediv__doc__,
+"itruediv($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a /= b.");
+
+#define _OPERATOR_ITRUEDIV_METHODDEF \
+ {"itruediv", (PyCFunction)_operator_itruediv, METH_VARARGS, _operator_itruediv__doc__},
+
+static PyObject *
+_operator_itruediv_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_itruediv(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "itruediv",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_itruediv_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_imod__doc__,
+"imod($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a %= b.");
+
+#define _OPERATOR_IMOD_METHODDEF \
+ {"imod", (PyCFunction)_operator_imod, METH_VARARGS, _operator_imod__doc__},
+
+static PyObject *
+_operator_imod_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_imod(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "imod",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_imod_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_ilshift__doc__,
+"ilshift($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a = b.");
+
+#define _OPERATOR_IRSHIFT_METHODDEF \
+ {"irshift", (PyCFunction)_operator_irshift, METH_VARARGS, _operator_irshift__doc__},
+
+static PyObject *
+_operator_irshift_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_irshift(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "irshift",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_irshift_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_iand__doc__,
+"iand($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a &= b.");
+
+#define _OPERATOR_IAND_METHODDEF \
+ {"iand", (PyCFunction)_operator_iand, METH_VARARGS, _operator_iand__doc__},
+
+static PyObject *
+_operator_iand_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_iand(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "iand",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_iand_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_ixor__doc__,
+"ixor($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a ^= b.");
+
+#define _OPERATOR_IXOR_METHODDEF \
+ {"ixor", (PyCFunction)_operator_ixor, METH_VARARGS, _operator_ixor__doc__},
+
+static PyObject *
+_operator_ixor_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_ixor(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "ixor",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_ixor_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_ior__doc__,
+"ior($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a |= b.");
+
+#define _OPERATOR_IOR_METHODDEF \
+ {"ior", (PyCFunction)_operator_ior, METH_VARARGS, _operator_ior__doc__},
+
+static PyObject *
+_operator_ior_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_ior(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "ior",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_ior_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_concat__doc__,
+"concat($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a + b, for a and b sequences.");
+
+#define _OPERATOR_CONCAT_METHODDEF \
+ {"concat", (PyCFunction)_operator_concat, METH_VARARGS, _operator_concat__doc__},
+
+static PyObject *
+_operator_concat_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_concat(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "concat",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_concat_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_iconcat__doc__,
+"iconcat($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a += b, for a and b sequences.");
+
+#define _OPERATOR_ICONCAT_METHODDEF \
+ {"iconcat", (PyCFunction)_operator_iconcat, METH_VARARGS, _operator_iconcat__doc__},
+
+static PyObject *
+_operator_iconcat_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_iconcat(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "iconcat",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_iconcat_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_contains__doc__,
+"contains($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as b in a (note reversed operands).");
+
+#define _OPERATOR_CONTAINS_METHODDEF \
+ {"contains", (PyCFunction)_operator_contains, METH_VARARGS, _operator_contains__doc__},
+
+static int
+_operator_contains_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_contains(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+ int _return_value;
+
+ if (!PyArg_UnpackTuple(args, "contains",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ _return_value = _operator_contains_impl(module, a, b);
+ if ((_return_value == -1) && PyErr_Occurred())
+ goto exit;
+ return_value = PyBool_FromLong((long)_return_value);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_indexOf__doc__,
+"indexOf($module, a, b, /)\n"
+"--\n"
+"\n"
+"Return the first index of b in a.");
+
+#define _OPERATOR_INDEXOF_METHODDEF \
+ {"indexOf", (PyCFunction)_operator_indexOf, METH_VARARGS, _operator_indexOf__doc__},
+
+static Py_ssize_t
+_operator_indexOf_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_indexOf(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+ Py_ssize_t _return_value;
+
+ if (!PyArg_UnpackTuple(args, "indexOf",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ _return_value = _operator_indexOf_impl(module, a, b);
+ if ((_return_value == -1) && PyErr_Occurred())
+ goto exit;
+ return_value = PyLong_FromSsize_t(_return_value);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_countOf__doc__,
+"countOf($module, a, b, /)\n"
+"--\n"
+"\n"
+"Return the number of times b occurs in a.");
+
+#define _OPERATOR_COUNTOF_METHODDEF \
+ {"countOf", (PyCFunction)_operator_countOf, METH_VARARGS, _operator_countOf__doc__},
+
+static Py_ssize_t
+_operator_countOf_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_countOf(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+ Py_ssize_t _return_value;
+
+ if (!PyArg_UnpackTuple(args, "countOf",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ _return_value = _operator_countOf_impl(module, a, b);
+ if ((_return_value == -1) && PyErr_Occurred())
+ goto exit;
+ return_value = PyLong_FromSsize_t(_return_value);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_getitem__doc__,
+"getitem($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a[b].");
+
+#define _OPERATOR_GETITEM_METHODDEF \
+ {"getitem", (PyCFunction)_operator_getitem, METH_VARARGS, _operator_getitem__doc__},
+
+static PyObject *
+_operator_getitem_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_getitem(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "getitem",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_getitem_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_setitem__doc__,
+"setitem($module, a, b, c, /)\n"
+"--\n"
+"\n"
+"Same as a[b] = c.");
+
+#define _OPERATOR_SETITEM_METHODDEF \
+ {"setitem", (PyCFunction)_operator_setitem, METH_VARARGS, _operator_setitem__doc__},
+
+static PyObject *
+_operator_setitem_impl(PyModuleDef *module, PyObject *a, PyObject *b,
+ PyObject *c);
+
+static PyObject *
+_operator_setitem(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+ PyObject *c;
+
+ if (!PyArg_UnpackTuple(args, "setitem",
+ 3, 3,
+ &a, &b, &c))
+ goto exit;
+ return_value = _operator_setitem_impl(module, a, b, c);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_delitem__doc__,
+"delitem($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as del a[b].");
+
+#define _OPERATOR_DELITEM_METHODDEF \
+ {"delitem", (PyCFunction)_operator_delitem, METH_VARARGS, _operator_delitem__doc__},
+
+static PyObject *
+_operator_delitem_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_delitem(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "delitem",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_delitem_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_eq__doc__,
+"eq($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a == b.");
+
+#define _OPERATOR_EQ_METHODDEF \
+ {"eq", (PyCFunction)_operator_eq, METH_VARARGS, _operator_eq__doc__},
+
+static PyObject *
+_operator_eq_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_eq(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "eq",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_eq_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_ne__doc__,
+"ne($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a != b.");
+
+#define _OPERATOR_NE_METHODDEF \
+ {"ne", (PyCFunction)_operator_ne, METH_VARARGS, _operator_ne__doc__},
+
+static PyObject *
+_operator_ne_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_ne(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "ne",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_ne_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_lt__doc__,
+"lt($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a < b.");
+
+#define _OPERATOR_LT_METHODDEF \
+ {"lt", (PyCFunction)_operator_lt, METH_VARARGS, _operator_lt__doc__},
+
+static PyObject *
+_operator_lt_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_lt(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "lt",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_lt_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_le__doc__,
+"le($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a b.");
+
+#define _OPERATOR_GT_METHODDEF \
+ {"gt", (PyCFunction)_operator_gt, METH_VARARGS, _operator_gt__doc__},
+
+static PyObject *
+_operator_gt_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_gt(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "gt",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_gt_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_ge__doc__,
+"ge($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a >= b.");
+
+#define _OPERATOR_GE_METHODDEF \
+ {"ge", (PyCFunction)_operator_ge, METH_VARARGS, _operator_ge__doc__},
+
+static PyObject *
+_operator_ge_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_ge(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "ge",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_ge_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_pow__doc__,
+"pow($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a ** b.");
+
+#define _OPERATOR_POW_METHODDEF \
+ {"pow", (PyCFunction)_operator_pow, METH_VARARGS, _operator_pow__doc__},
+
+static PyObject *
+_operator_pow_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_pow(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "pow",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_pow_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_ipow__doc__,
+"ipow($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a **= b.");
+
+#define _OPERATOR_IPOW_METHODDEF \
+ {"ipow", (PyCFunction)_operator_ipow, METH_VARARGS, _operator_ipow__doc__},
+
+static PyObject *
+_operator_ipow_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_ipow(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "ipow",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_ipow_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_index__doc__,
+"index($module, a, /)\n"
+"--\n"
+"\n"
+"Same as a.__index__()");
+
+#define _OPERATOR_INDEX_METHODDEF \
+ {"index", (PyCFunction)_operator_index, METH_O, _operator_index__doc__},
+
+PyDoc_STRVAR(_operator_is___doc__,
+"is_($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a is b.");
+
+#define _OPERATOR_IS__METHODDEF \
+ {"is_", (PyCFunction)_operator_is_, METH_VARARGS, _operator_is___doc__},
+
+static PyObject *
+_operator_is__impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_is_(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "is_",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_is__impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_is_not__doc__,
+"is_not($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a is not b.");
+
+#define _OPERATOR_IS_NOT_METHODDEF \
+ {"is_not", (PyCFunction)_operator_is_not, METH_VARARGS, _operator_is_not__doc__},
+
+static PyObject *
+_operator_is_not_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_is_not(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "is_not",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator_is_not_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_length_hint__doc__,
+"length_hint($module, obj, default=0, /)\n"
+"--\n"
+"\n"
+"Return an estimate of the number of items in obj.\n"
+"\n"
+"This is useful for presizing containers when building from an iterable.\n"
+"\n"
+"If the object supports len(), the result will be exact.\n"
+"Otherwise, it may over- or under-estimate by an arbitrary amount.\n"
+"The result will be an integer >= 0.");
+
+#define _OPERATOR_LENGTH_HINT_METHODDEF \
+ {"length_hint", (PyCFunction)_operator_length_hint, METH_VARARGS, _operator_length_hint__doc__},
+
+static PyObject *
+_operator_length_hint_impl(PyModuleDef *module, PyObject *obj,
+ Py_ssize_t default_value);
+
+static PyObject *
+_operator_length_hint(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *obj;
+ Py_ssize_t default_value = 0;
+
+ if (!PyArg_ParseTuple(args, "O|n:length_hint",
+ &obj, &default_value))
+ goto exit;
+ return_value = _operator_length_hint_impl(module, obj, default_value);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator__compare_digest__doc__,
+"_compare_digest($module, a, b, /)\n"
+"--\n"
+"\n"
+"Return \'a == b\'.\n"
+"\n"
+"This function uses an approach designed to prevent\n"
+"timing analysis, making it appropriate for cryptography.\n"
+"\n"
+"a and b must both be of the same type: either str (ASCII only),\n"
+"or any bytes-like object.\n"
+"\n"
+"Note: If a and b are of different lengths, or if an error occurs,\n"
+"a timing attack could theoretically reveal information about the\n"
+"types and lengths of a and b--but not their values.");
+
+#define _OPERATOR__COMPARE_DIGEST_METHODDEF \
+ {"_compare_digest", (PyCFunction)_operator__compare_digest, METH_VARARGS, _operator__compare_digest__doc__},
+
+static PyObject *
+_operator__compare_digest_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator__compare_digest(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!PyArg_UnpackTuple(args, "_compare_digest",
+ 2, 2,
+ &a, &b))
+ goto exit;
+ return_value = _operator__compare_digest_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+/*[clinic end generated code: output=c2481782818065a4 input=a9049054013a1b77]*/