Skip to content

C
cpython
Kaydet (Commit) b813a0e9 authored tarafından Serhiy Storchaka's avatar Serhiy Storchaka
Dosyalara gözat
Seçenekler

Issue #20186: Converted the _operator module to Argument Clinic. 

Patch by Tal Einat.
üst bd584f16
Hide whitespace changes
Inline Side-by-side
Showing with 2428 additions and 245 deletions
Modules/_operator.c
Dosyayı görüntüle @ b813a0e9
#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 @@ is equivalent to the expression x+y. The function names are those\n\
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); }
#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); }
#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; }
#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)
{
PyObject *a1, *a2;
if (PyArg_UnpackTuple(a,"pow", 2, 2, &a1, &a2))
return PyNumber_Power(a1, a2, Py_None);
return NULL;
}
static PyObject*
op_ipow(PyObject *s, PyObject *a)
{
PyObject *a1, *a2;
if (PyArg_UnpackTuple(a,"ipow", 2, 2, &a1, &a2))
return PyNumber_InPlacePower(a1, a2, Py_None);
return NULL;
/*[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);
}
/*[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
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]*/
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 *
op_index(PyObject *s, PyObject *a)
_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 @@ _tscmp(const unsigned char *a, const unsigned char *b,
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.
static PyObject *length_hint(PyObject *self, PyObject *args)
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
Return 'a == b'.
This function uses an approach designed to prevent
timing analysis, making it appropriate for cryptography.
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");
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;
}
/* 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 *args)
/* 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 @@ 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)
{
......
Modules/clinic/_operator.c.h 0 → 100644
Dosyayı görüntüle @ b813a0e9
/*[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]*/
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment