[Python-checkins] cpython: Issue #20186: Converted the _operator module to Argument Clinic.
serhiy.storchaka
python-checkins at python.org
Thu Jan 19 10:52:41 EST 2017
https://hg.python.org/cpython/rev/3713f7de576d
changeset: 106232:3713f7de576d
user: Serhiy Storchaka <storchaka at gmail.com>
date: Thu Jan 19 17:44:13 2017 +0200
summary:
Issue #20186: Converted the _operator module to Argument Clinic.
Patch by Tal Einat.
files:
Modules/_operator.c | 1009 ++++++++++---
Modules/clinic/_operator.c.h | 1648 ++++++++++++++++++++++
2 files changed, 2420 insertions(+), 237 deletions(-)
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(PyObject *module, PyObject *a)
+/*[clinic end generated code: output=eaf87767234fa5d7 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=8292984204f45164 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=4adfc3b888c1ee2e 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=d24d66f55a01944c 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=a20d917eb35d0101 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=df26b71a60589f99 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=0e6a959944d77719 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=9519822f0bbec166 input=102e19b422342ac1]*/
+{
+ return PyNumber_Remainder(a, b);
+}
+
+/*[clinic input]
+_operator.neg
+
+ a: object
+ /
+
+Same as -a.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_neg(PyObject *module, PyObject *a)
+/*[clinic end generated code: output=36e08ecfc6a1c08c input=84f09bdcf27c96ec]*/
+{
+ return PyNumber_Negative(a);
+}
+
+/*[clinic input]
+_operator.pos = _operator.neg
+
+Same as +a.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_pos(PyObject *module, PyObject *a)
+/*[clinic end generated code: output=dad7a126221dd091 input=b6445b63fddb8772]*/
+{
+ return PyNumber_Positive(a);
+}
+
+/*[clinic input]
+_operator.abs = _operator.neg
+
+Same as abs(a).
+[clinic start generated code]*/
+
+static PyObject *
+_operator_abs(PyObject *module, PyObject *a)
+/*[clinic end generated code: output=1389a93ba053ea3e input=341d07ba86f58039]*/
+{
+ return PyNumber_Absolute(a);
+}
+
+/*[clinic input]
+_operator.inv = _operator.neg
+
+Same as ~a.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_inv(PyObject *module, PyObject *a)
+/*[clinic end generated code: output=a56875ba075ee06d input=b01a4677739f6eb2]*/
+{
+ return PyNumber_Invert(a);
+}
+
+/*[clinic input]
+_operator.invert = _operator.neg
+
+Same as ~a.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_invert(PyObject *module, PyObject *a)
+/*[clinic end generated code: output=406b5aa030545fcc input=7f2d607176672e55]*/
+{
+ return PyNumber_Invert(a);
+}
+
+/*[clinic input]
+_operator.lshift = _operator.add
+
+Same as a << b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_lshift_impl(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=37f7e52c41435bd8 input=746e8a160cbbc9eb]*/
+{
+ return PyNumber_Lshift(a, b);
+}
+
+/*[clinic input]
+_operator.rshift = _operator.add
+
+Same as a >> b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_rshift_impl(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=4593c7ef30ec2ee3 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(PyObject *module, PyObject *a)
+/*[clinic end generated code: output=743f9c24a09759ef 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=93c4fe88f7b76d9e 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=b24cd8b79fde0004 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=58024867b8d90461 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=07dc627832526eb5 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=4513467d23b5e0b1 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=5e87dacd19a71eab 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=d603cbdf716ce519 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=535336048c681794 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=28017fbd3563952f 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=f7c540ae0fc70904 input=d0c384a3ce38e1dd]*/
+{
+ return PyNumber_InPlaceRemainder(a, b);
+}
+
+/*[clinic input]
+_operator.ilshift = _operator.add
+
+Same as a <<= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_ilshift_impl(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=e73a8fee1ac18749 input=e21b6b310f54572e]*/
+{
+ return PyNumber_InPlaceLshift(a, b);
+}
+
+/*[clinic input]
+_operator.irshift = _operator.add
+
+Same as a >>= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_irshift_impl(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=97f2af6b5ff2ed81 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=4599e9d40cbf7d00 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=5ff881766872be03 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=48aac319445bf759 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=80028390942c5f11 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=3ea0a162ebb2e26d 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=413b4dbe82b6ffc1 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=c6226d8e0fb60fa6 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=9e1623197daf3382 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=6c8d8101a676e594 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(PyObject *module, PyObject *a, PyObject *b,
+ PyObject *c)
+/*[clinic end generated code: output=1324f9061ae99e25 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=db18f61506295799 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=8d7d46ed4135677c 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=c99bd0c3a4c01297 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=082d7c45c440e535 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_le_impl(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=00970a2923d0ae17 input=b812a7860a0bef44]*/
+{
+ return PyObject_RichCompare(a, b, Py_LE);
+}
+
+/*[clinic input]
+_operator.gt = _operator.eq
+
+Same as a > b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_gt_impl(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=8d373349ecf25641 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=7ce3882256d4b137 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=09e668ad50036120 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=7189ff4d4367c808 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(PyObject *module, PyObject *a)
+/*[clinic end generated code: output=d972b0764ac305fc 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=bcd47a402e482e1d 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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=491a1f2f81f6c7f9 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,52 @@
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 -> Py_ssize_t
-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 Py_ssize_t
+_operator_length_hint_impl(PyObject *module, PyObject *obj,
+ Py_ssize_t default_value)
+/*[clinic end generated code: output=01d469edc1d612ad input=65ed29f04401e96a]*/
{
- 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);
- if (res == -1 && PyErr_Occurred()) {
- return NULL;
- }
- return PyLong_FromSsize_t(res);
+ return PyObject_LengthHint(obj, default_value);
}
+/*[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(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=11d452bdd3a23cbc 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 +873,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.")
-spam2(rshift, "rshift(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(irshift, "a = irshift(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.")
-spam2(le, "le(a, b) -- Same as a<=b.")
-spam2(eq, "eq(a, b) -- Same as a==b.")
-spam2(ne, "ne(a, b) -- Same as a!=b.")
-spam2(gt, "gt(a, b) -- Same as a>b.")
-spam2(ge, "ge(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 +941,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)
{
@@ -583,6 +1116,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)
{
@@ -927,6 +1461,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,1648 @@
+/*[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(PyObject *module, PyObject *a);
+
+static PyObject *
+_operator_truth(PyObject *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_FASTCALL, _operator_add__doc__},
+
+static PyObject *
+_operator_add_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_add(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "add",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("add", kwnames)) {
+ 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_FASTCALL, _operator_sub__doc__},
+
+static PyObject *
+_operator_sub_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_sub(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "sub",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("sub", kwnames)) {
+ 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_FASTCALL, _operator_mul__doc__},
+
+static PyObject *
+_operator_mul_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_mul(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "mul",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("mul", kwnames)) {
+ 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_FASTCALL, _operator_matmul__doc__},
+
+static PyObject *
+_operator_matmul_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_matmul(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "matmul",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("matmul", kwnames)) {
+ 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_FASTCALL, _operator_floordiv__doc__},
+
+static PyObject *
+_operator_floordiv_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_floordiv(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "floordiv",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("floordiv", kwnames)) {
+ 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_FASTCALL, _operator_truediv__doc__},
+
+static PyObject *
+_operator_truediv_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_truediv(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "truediv",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("truediv", kwnames)) {
+ 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_FASTCALL, _operator_mod__doc__},
+
+static PyObject *
+_operator_mod_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_mod(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "mod",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("mod", kwnames)) {
+ 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_LSHIFT_METHODDEF \
+ {"lshift", (PyCFunction)_operator_lshift, METH_FASTCALL, _operator_lshift__doc__},
+
+static PyObject *
+_operator_lshift_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_lshift(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "lshift",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("lshift", kwnames)) {
+ goto exit;
+ }
+ return_value = _operator_lshift_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_rshift__doc__,
+"rshift($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a >> b.");
+
+#define _OPERATOR_RSHIFT_METHODDEF \
+ {"rshift", (PyCFunction)_operator_rshift, METH_FASTCALL, _operator_rshift__doc__},
+
+static PyObject *
+_operator_rshift_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_rshift(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "rshift",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("rshift", kwnames)) {
+ 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(PyObject *module, PyObject *a);
+
+static PyObject *
+_operator_not_(PyObject *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_FASTCALL, _operator_and___doc__},
+
+static PyObject *
+_operator_and__impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_and_(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "and_",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("and_", kwnames)) {
+ 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_FASTCALL, _operator_xor__doc__},
+
+static PyObject *
+_operator_xor_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_xor(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "xor",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("xor", kwnames)) {
+ 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_FASTCALL, _operator_or___doc__},
+
+static PyObject *
+_operator_or__impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_or_(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "or_",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("or_", kwnames)) {
+ 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_FASTCALL, _operator_iadd__doc__},
+
+static PyObject *
+_operator_iadd_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_iadd(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "iadd",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("iadd", kwnames)) {
+ 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_FASTCALL, _operator_isub__doc__},
+
+static PyObject *
+_operator_isub_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_isub(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "isub",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("isub", kwnames)) {
+ 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_FASTCALL, _operator_imul__doc__},
+
+static PyObject *
+_operator_imul_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_imul(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "imul",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("imul", kwnames)) {
+ 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_FASTCALL, _operator_imatmul__doc__},
+
+static PyObject *
+_operator_imatmul_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_imatmul(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "imatmul",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("imatmul", kwnames)) {
+ 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_FASTCALL, _operator_ifloordiv__doc__},
+
+static PyObject *
+_operator_ifloordiv_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_ifloordiv(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "ifloordiv",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("ifloordiv", kwnames)) {
+ 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_FASTCALL, _operator_itruediv__doc__},
+
+static PyObject *
+_operator_itruediv_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_itruediv(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "itruediv",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("itruediv", kwnames)) {
+ 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_FASTCALL, _operator_imod__doc__},
+
+static PyObject *
+_operator_imod_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_imod(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "imod",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("imod", kwnames)) {
+ 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_ILSHIFT_METHODDEF \
+ {"ilshift", (PyCFunction)_operator_ilshift, METH_FASTCALL, _operator_ilshift__doc__},
+
+static PyObject *
+_operator_ilshift_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_ilshift(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "ilshift",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("ilshift", kwnames)) {
+ goto exit;
+ }
+ return_value = _operator_ilshift_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_irshift__doc__,
+"irshift($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a >>= b.");
+
+#define _OPERATOR_IRSHIFT_METHODDEF \
+ {"irshift", (PyCFunction)_operator_irshift, METH_FASTCALL, _operator_irshift__doc__},
+
+static PyObject *
+_operator_irshift_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_irshift(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "irshift",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("irshift", kwnames)) {
+ 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_FASTCALL, _operator_iand__doc__},
+
+static PyObject *
+_operator_iand_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_iand(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "iand",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("iand", kwnames)) {
+ 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_FASTCALL, _operator_ixor__doc__},
+
+static PyObject *
+_operator_ixor_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_ixor(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "ixor",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("ixor", kwnames)) {
+ 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_FASTCALL, _operator_ior__doc__},
+
+static PyObject *
+_operator_ior_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_ior(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "ior",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("ior", kwnames)) {
+ 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_FASTCALL, _operator_concat__doc__},
+
+static PyObject *
+_operator_concat_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_concat(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "concat",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("concat", kwnames)) {
+ 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_FASTCALL, _operator_iconcat__doc__},
+
+static PyObject *
+_operator_iconcat_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_iconcat(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "iconcat",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("iconcat", kwnames)) {
+ 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_FASTCALL, _operator_contains__doc__},
+
+static int
+_operator_contains_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_contains(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+ int _return_value;
+
+ if (!_PyArg_UnpackStack(args, nargs, "contains",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("contains", kwnames)) {
+ 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_FASTCALL, _operator_indexOf__doc__},
+
+static Py_ssize_t
+_operator_indexOf_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_indexOf(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+ Py_ssize_t _return_value;
+
+ if (!_PyArg_UnpackStack(args, nargs, "indexOf",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("indexOf", kwnames)) {
+ 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_FASTCALL, _operator_countOf__doc__},
+
+static Py_ssize_t
+_operator_countOf_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_countOf(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+ Py_ssize_t _return_value;
+
+ if (!_PyArg_UnpackStack(args, nargs, "countOf",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("countOf", kwnames)) {
+ 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_FASTCALL, _operator_getitem__doc__},
+
+static PyObject *
+_operator_getitem_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_getitem(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "getitem",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("getitem", kwnames)) {
+ 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_FASTCALL, _operator_setitem__doc__},
+
+static PyObject *
+_operator_setitem_impl(PyObject *module, PyObject *a, PyObject *b,
+ PyObject *c);
+
+static PyObject *
+_operator_setitem(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+ PyObject *c;
+
+ if (!_PyArg_UnpackStack(args, nargs, "setitem",
+ 3, 3,
+ &a, &b, &c)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("setitem", kwnames)) {
+ 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_FASTCALL, _operator_delitem__doc__},
+
+static PyObject *
+_operator_delitem_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_delitem(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "delitem",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("delitem", kwnames)) {
+ 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_FASTCALL, _operator_eq__doc__},
+
+static PyObject *
+_operator_eq_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_eq(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "eq",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("eq", kwnames)) {
+ 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_FASTCALL, _operator_ne__doc__},
+
+static PyObject *
+_operator_ne_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_ne(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "ne",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("ne", kwnames)) {
+ 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_FASTCALL, _operator_lt__doc__},
+
+static PyObject *
+_operator_lt_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_lt(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "lt",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("lt", kwnames)) {
+ 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_LE_METHODDEF \
+ {"le", (PyCFunction)_operator_le, METH_FASTCALL, _operator_le__doc__},
+
+static PyObject *
+_operator_le_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_le(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "le",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("le", kwnames)) {
+ goto exit;
+ }
+ return_value = _operator_le_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(_operator_gt__doc__,
+"gt($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a > b.");
+
+#define _OPERATOR_GT_METHODDEF \
+ {"gt", (PyCFunction)_operator_gt, METH_FASTCALL, _operator_gt__doc__},
+
+static PyObject *
+_operator_gt_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_gt(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "gt",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("gt", kwnames)) {
+ 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_FASTCALL, _operator_ge__doc__},
+
+static PyObject *
+_operator_ge_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_ge(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "ge",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("ge", kwnames)) {
+ 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_FASTCALL, _operator_pow__doc__},
+
+static PyObject *
+_operator_pow_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_pow(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "pow",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("pow", kwnames)) {
+ 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_FASTCALL, _operator_ipow__doc__},
+
+static PyObject *
+_operator_ipow_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_ipow(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "ipow",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("ipow", kwnames)) {
+ 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_FASTCALL, _operator_is___doc__},
+
+static PyObject *
+_operator_is__impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_is_(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "is_",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("is_", kwnames)) {
+ 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_FASTCALL, _operator_is_not__doc__},
+
+static PyObject *
+_operator_is_not_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_is_not(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "is_not",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("is_not", kwnames)) {
+ 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_FASTCALL, _operator_length_hint__doc__},
+
+static Py_ssize_t
+_operator_length_hint_impl(PyObject *module, PyObject *obj,
+ Py_ssize_t default_value);
+
+static PyObject *
+_operator_length_hint(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *obj;
+ Py_ssize_t default_value = 0;
+ Py_ssize_t _return_value;
+
+ if (!_PyArg_ParseStack(args, nargs, "O|n:length_hint",
+ &obj, &default_value)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("length_hint", kwnames)) {
+ goto exit;
+ }
+ _return_value = _operator_length_hint_impl(module, obj, default_value);
+ if ((_return_value == -1) && PyErr_Occurred()) {
+ goto exit;
+ }
+ return_value = PyLong_FromSsize_t(_return_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_FASTCALL, _operator__compare_digest__doc__},
+
+static PyObject *
+_operator__compare_digest_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator__compare_digest(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b;
+
+ if (!_PyArg_UnpackStack(args, nargs, "_compare_digest",
+ 2, 2,
+ &a, &b)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("_compare_digest", kwnames)) {
+ goto exit;
+ }
+ return_value = _operator__compare_digest_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+/*[clinic end generated code: output=c030b6747fddd9c6 input=a9049054013a1b77]*/
--
Repository URL: https://hg.python.org/cpython
More information about the Python-checkins
mailing list