cpython: 3713f7de576d (original) (raw)

--- 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[](#l1.15) \n[](#l1.16) @@ -10,158 +17,702 @@ is equivalent to the expression x+y. Th used for special methods; variants without leading and trailing\n[](#l1.18) '__' are also provided for convenience."); -#define spam1(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a1) { [](#l1.21)

• return AOP(a1); } + +/*[clinic input] +_operator.truth -> bool +

• a: object
• /

+ +Return True if a is true, False otherwise. +[clinic start generated code]*/ + +static int +_operator_truth_impl(PyObject module, PyObject a) +/[clinic end generated code: output=eaf87767234fa5d7 input=bc74a4cd90235875]/ +{

• return PyObject_IsTrue(a);

+} -#define spam2(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { [](#l1.40)

• PyObject *a1, *a2; [](#l1.41)
• if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; [](#l1.42)
• return AOP(a1,a2); } +/*[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]/ +{

• return PyNumber_Add(a, b);

+} + +/*[clinic input] +_operator.sub = _operator.add -#define spamoi(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { [](#l1.64)

• PyObject *a1; int a2; [](#l1.65)
• if(! PyArg_ParseTuple(a,"Oi:" #OP,&a1,&a2)) return NULL; [](#l1.66)
• return AOP(a1,a2); } +Same as a - b. +[clinic start generated code]*/ + +static PyObject * +_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]/ -#define spam2n(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { [](#l1.84)

• PyObject *a1, *a2; [](#l1.85)
• if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; [](#l1.86)
• if(-1 == AOP(a1,a2)) return NULL; [](#l1.87)
• Py_INCREF(Py_None); [](#l1.88)
• return Py_None; } +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]/ -#define spam3n(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { [](#l1.116)

• PyObject *a1, *a2, *a3; [](#l1.117)
• if(! PyArg_UnpackTuple(a,#OP,3,3,&a1,&a2,&a3)) return NULL; [](#l1.118)
• if(-1 == AOP(a1,a2,a3)) return NULL; [](#l1.119)
• Py_INCREF(Py_None); [](#l1.120)
• return Py_None; } +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]/ -#define spami(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a1) { [](#l1.135)

• long r; [](#l1.136)
• if(-1 == (r=AOP(a1))) return NULL; [](#l1.137)
• return PyBool_FromLong(r); } +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
• /

-#define spami2(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { [](#l1.165)

• PyObject *a1, *a2; long r; [](#l1.166)
• if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; [](#l1.167)
• if(-1 == (r=AOP(a1,a2))) return NULL; [](#l1.168)
• return PyLong_FromLong(r); } +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]/ -#define spamn2(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { [](#l1.186)

• PyObject *a1, *a2; Py_ssize_t r; [](#l1.187)
• if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; [](#l1.188)
• if(-1 == (r=AOP(a1,a2))) return NULL; [](#l1.189)
• return PyLong_FromSsize_t(r); } +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]/ -#define spami2b(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { [](#l1.204)

• PyObject *a1, *a2; long r; [](#l1.205)
• if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; [](#l1.206)
• if(-1 == (r=AOP(a1,a2))) return NULL; [](#l1.207)
• return PyBool_FromLong(r); } +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]/ -#define spamrc(OP,A) static PyObject *OP(PyObject *s, PyObject *a) { [](#l1.222)

• PyObject *a1, *a2; [](#l1.223)
• if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; [](#l1.224)
• return PyObject_RichCompare(a1,a2,A); } +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]/ -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 * +_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* -op_pow(PyObject *s, PyObject *a) +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]/ {

• PyObject *a1, *a2;
• if (PyArg_UnpackTuple(a,"pow", 2, 2, &a1, &a2))

•    return PyNumber_Power(a1, a2, Py_None);[](#l1.409)

• return NULL;

• 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);

} -static PyObject* -op_ipow(PyObject s, PyObject a) +/[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]/ {

• PyObject *a1, *a2;
• if (PyArg_UnpackTuple(a,"ipow", 2, 2, &a1, &a2))

•    return PyNumber_InPlacePower(a1, a2, Py_None);[](#l1.519)

• return NULL;

• 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 * -op_index(PyObject *s, PyObject *a) +_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)[](#l1.641)

+/[clinic end generated code: output=1324f9061ae99e25 input=ceaf453c4d3a58df]/ +{

• if (-1 == PyObject_SetItem(a, b, c))

•    return NULL;[](#l1.645)

• 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;[](#l1.660)

• 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;[](#l1.802)

•    Py_INCREF(result);[](#l1.803)

• }

• 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;[](#l1.825)

•    Py_INCREF(result);[](#l1.826)

• }

• 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 @@ static int 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 +

• 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. -static PyObject *length_hint(PyObject *self, PyObject args) +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)[](#l1.874)

+/[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;[](#l1.880)

• }
• res = PyObject_LengthHint(obj, defaultvalue);
• if (res == -1 && PyErr_Occurred()) {

•    return NULL;[](#l1.884)

• }
• 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'. + +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. -static PyObject -compare_digest(PyObject *self, PyObject args) +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;[](#l1.927)

• }

- /* ASCII unicode string */ if(PyUnicode_Check(a) && PyUnicode_Check(b)) { if (PyUnicode_READY(a) == -1 || PyUnicode_READY(b) == -1) { @@ -323,78 +873,60 @@ compare_digest(PyObject self, PyObject / 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__},[](#l1.1006)

• {"length_hint", (PyCFunction)length_hint, METH_VARARGS,[](#l1.1007)

• length_hint__doc__},[](#l1.1008)

• _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 @@ typedef struct { 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 @@ typedef struct { 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 @@ typedef struct { 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) {

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 [](#l2.15)

• {"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;[](#l2.29)

• }
• 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 [](#l2.43)

• {"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,[](#l2.57)

•    &a, &b)) {[](#l2.58)

•    goto exit;[](#l2.59)

• }

+

• if (!_PyArg_NoStackKeywords("add", kwnames)) {

•    goto exit;[](#l2.63)

• }
• 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 [](#l2.77)

• {"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,[](#l2.91)

•    &a, &b)) {[](#l2.92)

•    goto exit;[](#l2.93)

• }

+

• if (!_PyArg_NoStackKeywords("sub", kwnames)) {

•    goto exit;[](#l2.97)

• }
• 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 [](#l2.111)

• {"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,[](#l2.125)

•    &a, &b)) {[](#l2.126)

•    goto exit;[](#l2.127)

• }

+

• if (!_PyArg_NoStackKeywords("mul", kwnames)) {

•    goto exit;[](#l2.131)

• }
• 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 [](#l2.145)

• {"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,[](#l2.159)

•    &a, &b)) {[](#l2.160)

•    goto exit;[](#l2.161)

• }

+

• if (!_PyArg_NoStackKeywords("matmul", kwnames)) {

•    goto exit;[](#l2.165)

• }
• 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 [](#l2.179)

• {"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,[](#l2.193)

•    &a, &b)) {[](#l2.194)

•    goto exit;[](#l2.195)

• }

+

• if (!_PyArg_NoStackKeywords("floordiv", kwnames)) {

•    goto exit;[](#l2.199)

• }
• 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 [](#l2.213)

• {"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,[](#l2.227)

•    &a, &b)) {[](#l2.228)

•    goto exit;[](#l2.229)

• }

+

• if (!_PyArg_NoStackKeywords("truediv", kwnames)) {

•    goto exit;[](#l2.233)

• }
• 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 [](#l2.247)

• {"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,[](#l2.261)

•    &a, &b)) {[](#l2.262)

•    goto exit;[](#l2.263)

• }

+

• if (!_PyArg_NoStackKeywords("mod", kwnames)) {

•    goto exit;[](#l2.267)

• }
• 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 [](#l2.281)

• {"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 [](#l2.290)

• {"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 [](#l2.299)

• {"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 [](#l2.308)

• {"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 [](#l2.317)

• {"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 [](#l2.326)

• {"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,[](#l2.340)

•    &a, &b)) {[](#l2.341)

•    goto exit;[](#l2.342)

• }

+

• if (!_PyArg_NoStackKeywords("lshift", kwnames)) {

•    goto exit;[](#l2.346)

• }
• 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 [](#l2.360)

• {"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,[](#l2.374)

•    &a, &b)) {[](#l2.375)

•    goto exit;[](#l2.376)

• }

+

• if (!_PyArg_NoStackKeywords("rshift", kwnames)) {

•    goto exit;[](#l2.380)

• }
• 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 [](#l2.394)

• {"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;[](#l2.408)

• }
• 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 [](#l2.422)

• {"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,[](#l2.436)

•    &a, &b)) {[](#l2.437)

•    goto exit;[](#l2.438)

• }

+

• if (!PyArg_NoStackKeywords("and", kwnames)) {

•    goto exit;[](#l2.442)

• }
• 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 [](#l2.456)

• {"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,[](#l2.470)

•    &a, &b)) {[](#l2.471)

•    goto exit;[](#l2.472)

• }

+

• if (!_PyArg_NoStackKeywords("xor", kwnames)) {

•    goto exit;[](#l2.476)

• }
• 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 [](#l2.490)

• {"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,[](#l2.504)

•    &a, &b)) {[](#l2.505)

•    goto exit;[](#l2.506)

• }

+

• if (!PyArg_NoStackKeywords("or", kwnames)) {

•    goto exit;[](#l2.510)

• }
• 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 [](#l2.524)

• {"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,[](#l2.538)

•    &a, &b)) {[](#l2.539)

•    goto exit;[](#l2.540)

• }

+

• if (!_PyArg_NoStackKeywords("iadd", kwnames)) {

•    goto exit;[](#l2.544)

• }
• 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 [](#l2.558)

• {"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,[](#l2.572)

•    &a, &b)) {[](#l2.573)

•    goto exit;[](#l2.574)

• }

+

• if (!_PyArg_NoStackKeywords("isub", kwnames)) {

•    goto exit;[](#l2.578)

• }
• 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 [](#l2.592)

• {"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,[](#l2.606)

•    &a, &b)) {[](#l2.607)

•    goto exit;[](#l2.608)

• }

+

• if (!_PyArg_NoStackKeywords("imul", kwnames)) {

•    goto exit;[](#l2.612)

• }
• 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 [](#l2.626)

• {"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,[](#l2.640)

•    &a, &b)) {[](#l2.641)

•    goto exit;[](#l2.642)

• }

+

• if (!_PyArg_NoStackKeywords("imatmul", kwnames)) {

•    goto exit;[](#l2.646)

• }
• 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 [](#l2.660)

• {"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,[](#l2.674)

•    &a, &b)) {[](#l2.675)

•    goto exit;[](#l2.676)

• }

+

• if (!_PyArg_NoStackKeywords("ifloordiv", kwnames)) {

•    goto exit;[](#l2.680)

• }
• 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 [](#l2.694)

• {"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,[](#l2.708)

•    &a, &b)) {[](#l2.709)

•    goto exit;[](#l2.710)

• }

+

• if (!_PyArg_NoStackKeywords("itruediv", kwnames)) {

•    goto exit;[](#l2.714)

• }
• 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 [](#l2.728)

• {"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,[](#l2.742)

•    &a, &b)) {[](#l2.743)

•    goto exit;[](#l2.744)

• }

+

• if (!_PyArg_NoStackKeywords("imod", kwnames)) {

•    goto exit;[](#l2.748)

• }
• 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 [](#l2.762)

• {"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,[](#l2.776)

•    &a, &b)) {[](#l2.777)

•    goto exit;[](#l2.778)

• }

+

• if (!_PyArg_NoStackKeywords("ilshift", kwnames)) {

•    goto exit;[](#l2.782)

• }
• 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 [](#l2.796)

• {"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,[](#l2.810)

•    &a, &b)) {[](#l2.811)

•    goto exit;[](#l2.812)

• }

+

• if (!_PyArg_NoStackKeywords("irshift", kwnames)) {

•    goto exit;[](#l2.816)

• }
• 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 [](#l2.830)

• {"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,[](#l2.844)

•    &a, &b)) {[](#l2.845)

•    goto exit;[](#l2.846)

• }

+

• if (!_PyArg_NoStackKeywords("iand", kwnames)) {

•    goto exit;[](#l2.850)

• }
• 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 [](#l2.864)

• {"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,[](#l2.878)

•    &a, &b)) {[](#l2.879)

•    goto exit;[](#l2.880)

• }

+

• if (!_PyArg_NoStackKeywords("ixor", kwnames)) {

•    goto exit;[](#l2.884)

• }
• 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 [](#l2.898)

• {"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,[](#l2.912)

•    &a, &b)) {[](#l2.913)

•    goto exit;[](#l2.914)

• }

+

• if (!_PyArg_NoStackKeywords("ior", kwnames)) {

•    goto exit;[](#l2.918)

• }
• 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 [](#l2.932)

• {"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,[](#l2.946)

•    &a, &b)) {[](#l2.947)

•    goto exit;[](#l2.948)

• }

+

• if (!_PyArg_NoStackKeywords("concat", kwnames)) {

•    goto exit;[](#l2.952)

• }
• 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 [](#l2.966)

• {"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,[](#l2.980)

•    &a, &b)) {[](#l2.981)

•    goto exit;[](#l2.982)

• }

+

• if (!_PyArg_NoStackKeywords("iconcat", kwnames)) {

•    goto exit;[](#l2.986)

• }
• 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 [](#l2.1000)

• {"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,[](#l2.1015)

•    &a, &b)) {[](#l2.1016)

•    goto exit;[](#l2.1017)

• }

+

• if (!_PyArg_NoStackKeywords("contains", kwnames)) {

•    goto exit;[](#l2.1021)

• }
• _return_value = _operator_contains_impl(module, a, b);
• if ((_return_value == -1) && PyErr_Occurred()) {

•    goto exit;[](#l2.1025)

• }
• 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 [](#l2.1039)

• {"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,[](#l2.1054)

•    &a, &b)) {[](#l2.1055)

•    goto exit;[](#l2.1056)

• }

+

• if (!_PyArg_NoStackKeywords("indexOf", kwnames)) {

•    goto exit;[](#l2.1060)

• }
• _return_value = _operator_indexOf_impl(module, a, b);
• if ((_return_value == -1) && PyErr_Occurred()) {

•    goto exit;[](#l2.1064)

• }
• 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 [](#l2.1078)

• {"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,[](#l2.1093)

•    &a, &b)) {[](#l2.1094)

•    goto exit;[](#l2.1095)

• }

+

• if (!_PyArg_NoStackKeywords("countOf", kwnames)) {

•    goto exit;[](#l2.1099)

• }
• _return_value = _operator_countOf_impl(module, a, b);
• if ((_return_value == -1) && PyErr_Occurred()) {

•    goto exit;[](#l2.1103)

• }
• 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 [](#l2.1117)

• {"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,[](#l2.1131)

•    &a, &b)) {[](#l2.1132)

•    goto exit;[](#l2.1133)

• }

+

• if (!_PyArg_NoStackKeywords("getitem", kwnames)) {

•    goto exit;[](#l2.1137)

• }
• 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 [](#l2.1151)

• {"setitem", (PyCFunction)operator_setitem, METH_FASTCALL, operator_setitem__doc},

+ +static PyObject * +_operator_setitem_impl(PyObject *module, PyObject *a, PyObject *b,

•                   PyObject *c);[](#l2.1156)

+ +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,[](#l2.1167)

•    &a, &b, &c)) {[](#l2.1168)

•    goto exit;[](#l2.1169)

• }

+

• if (!_PyArg_NoStackKeywords("setitem", kwnames)) {

•    goto exit;[](#l2.1173)

• }
• 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 [](#l2.1187)

• {"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,[](#l2.1201)

•    &a, &b)) {[](#l2.1202)

•    goto exit;[](#l2.1203)

• }

+

• if (!_PyArg_NoStackKeywords("delitem", kwnames)) {

•    goto exit;[](#l2.1207)

• }
• 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 [](#l2.1221)

• {"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,[](#l2.1235)

•    &a, &b)) {[](#l2.1236)

•    goto exit;[](#l2.1237)

• }

+

• if (!_PyArg_NoStackKeywords("eq", kwnames)) {

•    goto exit;[](#l2.1241)

• }
• 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 [](#l2.1255)

• {"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,[](#l2.1269)

•    &a, &b)) {[](#l2.1270)

•    goto exit;[](#l2.1271)

• }

+

• if (!_PyArg_NoStackKeywords("ne", kwnames)) {

•    goto exit;[](#l2.1275)

• }
• 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 [](#l2.1289)

• {"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,[](#l2.1303)

•    &a, &b)) {[](#l2.1304)

•    goto exit;[](#l2.1305)

• }

+

• if (!_PyArg_NoStackKeywords("lt", kwnames)) {

•    goto exit;[](#l2.1309)

• }
• 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 [](#l2.1323)

• {"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,[](#l2.1337)

•    &a, &b)) {[](#l2.1338)

•    goto exit;[](#l2.1339)

• }

+

• if (!_PyArg_NoStackKeywords("le", kwnames)) {

•    goto exit;[](#l2.1343)

• }
• 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 [](#l2.1357)

• {"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,[](#l2.1371)

•    &a, &b)) {[](#l2.1372)

•    goto exit;[](#l2.1373)

• }

+

• if (!_PyArg_NoStackKeywords("gt", kwnames)) {

•    goto exit;[](#l2.1377)

• }
• 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 [](#l2.1391)

• {"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,[](#l2.1405)

•    &a, &b)) {[](#l2.1406)

•    goto exit;[](#l2.1407)

• }

+

• if (!_PyArg_NoStackKeywords("ge", kwnames)) {

•    goto exit;[](#l2.1411)

• }
• 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 [](#l2.1425)

• {"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,[](#l2.1439)

•    &a, &b)) {[](#l2.1440)

•    goto exit;[](#l2.1441)

• }

+

• if (!_PyArg_NoStackKeywords("pow", kwnames)) {

•    goto exit;[](#l2.1445)

• }
• 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 [](#l2.1459)

• {"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,[](#l2.1473)

•    &a, &b)) {[](#l2.1474)

•    goto exit;[](#l2.1475)

• }

+

• if (!_PyArg_NoStackKeywords("ipow", kwnames)) {

•    goto exit;[](#l2.1479)

• }
• 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 [](#l2.1493)

• {"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 [](#l2.1502)

• {"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,[](#l2.1516)

•    &a, &b)) {[](#l2.1517)

•    goto exit;[](#l2.1518)

• }

+

• if (!PyArg_NoStackKeywords("is", kwnames)) {

•    goto exit;[](#l2.1522)

• }
• 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 [](#l2.1536)

• {"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,[](#l2.1550)

•    &a, &b)) {[](#l2.1551)

•    goto exit;[](#l2.1552)

• }

+

• if (!_PyArg_NoStackKeywords("is_not", kwnames)) {

•    goto exit;[](#l2.1556)

• }
• 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 [](#l2.1576)

• {"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);[](#l2.1581)

+ +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)) {[](#l2.1592)

•    goto exit;[](#l2.1593)

• }

+

• if (!_PyArg_NoStackKeywords("length_hint", kwnames)) {

•    goto exit;[](#l2.1597)

• }
• _return_value = _operator_length_hint_impl(module, obj, default_value);
• if ((_return_value == -1) && PyErr_Occurred()) {

•    goto exit;[](#l2.1601)

• }
• 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 [](#l2.1625)

• {"_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,[](#l2.1639)

•    &a, &b)) {[](#l2.1640)

•    goto exit;[](#l2.1641)

• }

+

• if (!_PyArg_NoStackKeywords("_compare_digest", kwnames)) {

•    goto exit;[](#l2.1645)

• }
• return_value = _operator__compare_digest_impl(module, a, b);

+ +exit:

• return return_value;

+} +/[clinic end generated code: output=c030b6747fddd9c6 input=a9049054013a1b77]/