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 "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, PyDoc_STRVAR(operator_doc,
"Operator interface.\n\ "Operator interface.\n\
\n\ \n\
...@@ -10,158 +17,702 @@ is equivalent to the expression x+y. The function names are those\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\ used for special methods; variants without leading and trailing\n\
'__' are also provided for convenience."); '__' are also provided for convenience.");
#define spam1(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a1) { \
return AOP(a1); } /*[clinic input]
_operator.truth -> bool
#define spam2(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
PyObject *a1, *a2; \ a: object
if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \ /
return AOP(a1,a2); }
Return True if a is true, False otherwise.
#define spamoi(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \ [clinic start generated code]*/
PyObject *a1; int a2; \
if(! PyArg_ParseTuple(a,"Oi:" #OP,&a1,&a2)) return NULL; \ static int
return AOP(a1,a2); } _operator_truth_impl(PyObject *module, PyObject *a)
/*[clinic end generated code: output=eaf87767234fa5d7 input=bc74a4cd90235875]*/
#define spam2n(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \ {
PyObject *a1, *a2; \ return PyObject_IsTrue(a);
if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \ }
if(-1 == AOP(a1,a2)) return NULL; \
Py_INCREF(Py_None); \ /*[clinic input]
return Py_None; } _operator.add
#define spam3n(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \ a: object
PyObject *a1, *a2, *a3; \ b: object
if(! PyArg_UnpackTuple(a,#OP,3,3,&a1,&a2,&a3)) return NULL; \ /
if(-1 == AOP(a1,a2,a3)) return NULL; \
Py_INCREF(Py_None); \ Same as a + b.
return Py_None; } [clinic start generated code]*/
#define spami(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a1) { \ static PyObject *
long r; \ _operator_add_impl(PyObject *module, PyObject *a, PyObject *b)
if(-1 == (r=AOP(a1))) return NULL; \ /*[clinic end generated code: output=8292984204f45164 input=5efe3bff856ac215]*/
return PyBool_FromLong(r); } {
return PyNumber_Add(a, b);
#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; \ /*[clinic input]
if(-1 == (r=AOP(a1,a2))) return NULL; \ _operator.sub = _operator.add
return PyLong_FromLong(r); }
Same as a - b.
#define spamn2(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \ [clinic start generated code]*/
PyObject *a1, *a2; Py_ssize_t r; \
if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \ static PyObject *
if(-1 == (r=AOP(a1,a2))) return NULL; \ _operator_sub_impl(PyObject *module, PyObject *a, PyObject *b)
return PyLong_FromSsize_t(r); } /*[clinic end generated code: output=4adfc3b888c1ee2e input=6494c6b100b8e795]*/
{
#define spami2b(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \ return PyNumber_Subtract(a, b);
PyObject *a1, *a2; long r; \ }
if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \
if(-1 == (r=AOP(a1,a2))) return NULL; \ /*[clinic input]
return PyBool_FromLong(r); } _operator.mul = _operator.add
#define spamrc(OP,A) static PyObject *OP(PyObject *s, PyObject *a) { \ Same as a * b.
PyObject *a1, *a2; \ [clinic start generated code]*/
if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \
return PyObject_RichCompare(a1,a2,A); } static PyObject *
_operator_mul_impl(PyObject *module, PyObject *a, PyObject *b)
spami(truth , PyObject_IsTrue) /*[clinic end generated code: output=d24d66f55a01944c input=2368615b4358b70d]*/
spam2(op_add , PyNumber_Add) {
spam2(op_sub , PyNumber_Subtract) return PyNumber_Multiply(a, b);
spam2(op_mul , PyNumber_Multiply) }
spam2(op_matmul , PyNumber_MatrixMultiply)
spam2(op_floordiv , PyNumber_FloorDivide) /*[clinic input]
spam2(op_truediv , PyNumber_TrueDivide) _operator.matmul = _operator.add
spam2(op_mod , PyNumber_Remainder)
spam1(op_neg , PyNumber_Negative) Same as a @ b.
spam1(op_pos , PyNumber_Positive) [clinic start generated code]*/
spam1(op_abs , PyNumber_Absolute)
spam1(op_inv , PyNumber_Invert) static PyObject *
spam1(op_invert , PyNumber_Invert) _operator_matmul_impl(PyObject *module, PyObject *a, PyObject *b)
spam2(op_lshift , PyNumber_Lshift) /*[clinic end generated code: output=a20d917eb35d0101 input=9ab304e37fb42dd4]*/
spam2(op_rshift , PyNumber_Rshift) {
spami(op_not_ , PyObject_Not) return PyNumber_MatrixMultiply(a, b);
spam2(op_and_ , PyNumber_And) }
spam2(op_xor , PyNumber_Xor)
spam2(op_or_ , PyNumber_Or) /*[clinic input]
spam2(op_iadd , PyNumber_InPlaceAdd) _operator.floordiv = _operator.add
spam2(op_isub , PyNumber_InPlaceSubtract)
spam2(op_imul , PyNumber_InPlaceMultiply) Same as a // b.
spam2(op_imatmul , PyNumber_InPlaceMatrixMultiply) [clinic start generated code]*/
spam2(op_ifloordiv , PyNumber_InPlaceFloorDivide)
spam2(op_itruediv , PyNumber_InPlaceTrueDivide) static PyObject *
spam2(op_imod , PyNumber_InPlaceRemainder) _operator_floordiv_impl(PyObject *module, PyObject *a, PyObject *b)
spam2(op_ilshift , PyNumber_InPlaceLshift) /*[clinic end generated code: output=df26b71a60589f99 input=bb2e88ba446c612c]*/
spam2(op_irshift , PyNumber_InPlaceRshift) {
spam2(op_iand , PyNumber_InPlaceAnd) return PyNumber_FloorDivide(a, b);
spam2(op_ixor , PyNumber_InPlaceXor) }
spam2(op_ior , PyNumber_InPlaceOr)
spam2(op_concat , PySequence_Concat) /*[clinic input]
spam2(op_iconcat , PySequence_InPlaceConcat) _operator.truediv = _operator.add
spami2b(op_contains , PySequence_Contains)
spamn2(indexOf , PySequence_Index) Same as a / b.
spamn2(countOf , PySequence_Count) [clinic start generated code]*/
spam2(op_getitem , PyObject_GetItem)
spam2n(op_delitem , PyObject_DelItem) static PyObject *
spam3n(op_setitem , PyObject_SetItem) _operator_truediv_impl(PyObject *module, PyObject *a, PyObject *b)
spamrc(op_lt , Py_LT) /*[clinic end generated code: output=0e6a959944d77719 input=ecbb947673f4eb1f]*/
spamrc(op_le , Py_LE) {
spamrc(op_eq , Py_EQ) return PyNumber_TrueDivide(a, b);
spamrc(op_ne , Py_NE) }
spamrc(op_gt , Py_GT)
spamrc(op_ge , Py_GE) /*[clinic input]
_operator.mod = _operator.add
static PyObject*
op_pow(PyObject *s, PyObject *a) Same as a % b.
{ [clinic start generated code]*/
PyObject *a1, *a2;
if (PyArg_UnpackTuple(a,"pow", 2, 2, &a1, &a2)) static PyObject *
return PyNumber_Power(a1, a2, Py_None); _operator_mod_impl(PyObject *module, PyObject *a, PyObject *b)
return NULL; /*[clinic end generated code: output=9519822f0bbec166 input=102e19b422342ac1]*/
} {
return PyNumber_Remainder(a, b);
static PyObject* }
op_ipow(PyObject *s, PyObject *a)
{ /*[clinic input]
PyObject *a1, *a2; _operator.neg
if (PyArg_UnpackTuple(a,"ipow", 2, 2, &a1, &a2))
return PyNumber_InPlacePower(a1, a2, Py_None); a: object
return NULL; /
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 * 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); return PyNumber_Index(a);
} }
static PyObject* /*[clinic input]
is_(PyObject *s, PyObject *a) _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; PyObject *result;
if (PyArg_UnpackTuple(a,"is_", 2, 2, &a1, &a2)) { result = (a == b) ? Py_True : Py_False;
result = (a1 == a2) ? Py_True : Py_False; Py_INCREF(result);
Py_INCREF(result);
}
return result; return result;
} }
static PyObject* /*[clinic input]
is_not(PyObject *s, PyObject *a) _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; PyObject *result;
if (PyArg_UnpackTuple(a,"is_not", 2, 2, &a1, &a2)) { result = (a != b) ? Py_True : Py_False;
result = (a1 != a2) ? Py_True : Py_False; Py_INCREF(result);
Py_INCREF(result);
}
return result; return result;
} }
#undef spam1
#undef spam2
#undef spam1o
#undef spam1o
/* compare_digest **********************************************************/ /* compare_digest **********************************************************/
/* /*
...@@ -210,53 +761,52 @@ _tscmp(const unsigned char *a, const unsigned char *b, ...@@ -210,53 +761,52 @@ _tscmp(const unsigned char *a, const unsigned char *b,
return (result == 0); return (result == 0);
} }
PyDoc_STRVAR(length_hint__doc__, /*[clinic input]
"length_hint(obj, default=0) -> int\n" _operator.length_hint -> Py_ssize_t
"Return an estimate of the number of items in obj.\n"
"This is useful for presizing containers when building from an\n" obj: object
"iterable.\n" default: Py_ssize_t = 0
"\n" /
"If the object supports len(), the result will be\n"
"exact. Otherwise, it may over- or under-estimate by an\n" Return an estimate of the number of items in obj.
"arbitrary amount. The result will be an integer >= 0.");
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; return PyObject_LengthHint(obj, default_value);
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);
} }
/*[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__, a and b must both be of the same type: either str (ASCII only),
"compare_digest(a, b) -> bool\n" or any bytes-like object.
"\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");
static PyObject* Note: If a and b are of different lengths, or if an error occurs,
compare_digest(PyObject *self, PyObject *args) 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; int rc;
if (!PyArg_ParseTuple(args, "OO:compare_digest", &a, &b)) {
return NULL;
}
/* ASCII unicode string */ /* ASCII unicode string */
if(PyUnicode_Check(a) && PyUnicode_Check(b)) { if(PyUnicode_Check(a) && PyUnicode_Check(b)) {
if (PyUnicode_READY(a) == -1 || PyUnicode_READY(b) == -1) { if (PyUnicode_READY(a) == -1 || PyUnicode_READY(b) == -1) {
...@@ -323,78 +873,60 @@ compare_digest(PyObject *self, PyObject *args) ...@@ -323,78 +873,60 @@ compare_digest(PyObject *self, PyObject *args)
/* operator methods **********************************************************/ /* 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[] = { static struct PyMethodDef operator_methods[] = {
spam1o(truth, _OPERATOR_TRUTH_METHODDEF
"truth(a) -- Return True if a is true, False otherwise.") _OPERATOR_CONTAINS_METHODDEF
spam2(contains, _OPERATOR_INDEXOF_METHODDEF
"contains(a, b) -- Same as b in a (note reversed operands).") _OPERATOR_COUNTOF_METHODDEF
spam1(indexOf, _OPERATOR_IS__METHODDEF
"indexOf(a, b) -- Return the first index of b in a.") _OPERATOR_IS_NOT_METHODDEF
spam1(countOf, _OPERATOR_INDEX_METHODDEF
"countOf(a, b) -- Return the number of times b occurs in a.") _OPERATOR_ADD_METHODDEF
_OPERATOR_SUB_METHODDEF
spam1(is_, "is_(a, b) -- Same as a is b.") _OPERATOR_MUL_METHODDEF
spam1(is_not, "is_not(a, b) -- Same as a is not b.") _OPERATOR_MATMUL_METHODDEF
spam2o(index, "index(a) -- Same as a.__index__()") _OPERATOR_FLOORDIV_METHODDEF
spam2(add, "add(a, b) -- Same as a + b.") _OPERATOR_TRUEDIV_METHODDEF
spam2(sub, "sub(a, b) -- Same as a - b.") _OPERATOR_MOD_METHODDEF
spam2(mul, "mul(a, b) -- Same as a * b.") _OPERATOR_NEG_METHODDEF
spam2(matmul, "matmul(a, b) -- Same as a @ b.") _OPERATOR_POS_METHODDEF
spam2(floordiv, "floordiv(a, b) -- Same as a // b.") _OPERATOR_ABS_METHODDEF
spam2(truediv, "truediv(a, b) -- Same as a / b.") _OPERATOR_INV_METHODDEF
spam2(mod, "mod(a, b) -- Same as a % b.") _OPERATOR_INVERT_METHODDEF
spam2o(neg, "neg(a) -- Same as -a.") _OPERATOR_LSHIFT_METHODDEF
spam2o(pos, "pos(a) -- Same as +a.") _OPERATOR_RSHIFT_METHODDEF
spam2o(abs, "abs(a) -- Same as abs(a).") _OPERATOR_NOT__METHODDEF
spam2o(inv, "inv(a) -- Same as ~a.") _OPERATOR_AND__METHODDEF
spam2o(invert, "invert(a) -- Same as ~a.") _OPERATOR_XOR_METHODDEF
spam2(lshift, "lshift(a, b) -- Same as a << b.") _OPERATOR_OR__METHODDEF
spam2(rshift, "rshift(a, b) -- Same as a >> b.") _OPERATOR_IADD_METHODDEF
spam2o(not_, "not_(a) -- Same as not a.") _OPERATOR_ISUB_METHODDEF
spam2(and_, "and_(a, b) -- Same as a & b.") _OPERATOR_IMUL_METHODDEF
spam2(xor, "xor(a, b) -- Same as a ^ b.") _OPERATOR_IMATMUL_METHODDEF
spam2(or_, "or_(a, b) -- Same as a | b.") _OPERATOR_IFLOORDIV_METHODDEF
spam2(iadd, "a = iadd(a, b) -- Same as a += b.") _OPERATOR_ITRUEDIV_METHODDEF
spam2(isub, "a = isub(a, b) -- Same as a -= b.") _OPERATOR_IMOD_METHODDEF
spam2(imul, "a = imul(a, b) -- Same as a *= b.") _OPERATOR_ILSHIFT_METHODDEF
spam2(imatmul, "a = imatmul(a, b) -- Same as a @= b.") _OPERATOR_IRSHIFT_METHODDEF
spam2(ifloordiv, "a = ifloordiv(a, b) -- Same as a //= b.") _OPERATOR_IAND_METHODDEF
spam2(itruediv, "a = itruediv(a, b) -- Same as a /= b") _OPERATOR_IXOR_METHODDEF
spam2(imod, "a = imod(a, b) -- Same as a %= b.") _OPERATOR_IOR_METHODDEF
spam2(ilshift, "a = ilshift(a, b) -- Same as a <<= b.") _OPERATOR_CONCAT_METHODDEF
spam2(irshift, "a = irshift(a, b) -- Same as a >>= b.") _OPERATOR_ICONCAT_METHODDEF
spam2(iand, "a = iand(a, b) -- Same as a &= b.") _OPERATOR_GETITEM_METHODDEF
spam2(ixor, "a = ixor(a, b) -- Same as a ^= b.") _OPERATOR_SETITEM_METHODDEF
spam2(ior, "a = ior(a, b) -- Same as a |= b.") _OPERATOR_DELITEM_METHODDEF
spam2(concat, _OPERATOR_POW_METHODDEF
"concat(a, b) -- Same as a + b, for a and b sequences.") _OPERATOR_IPOW_METHODDEF
spam2(iconcat, _OPERATOR_EQ_METHODDEF
"a = iconcat(a, b) -- Same as a += b, for a and b sequences.") _OPERATOR_NE_METHODDEF
spam2(getitem, _OPERATOR_LT_METHODDEF
"getitem(a, b) -- Same as a[b].") _OPERATOR_LE_METHODDEF
spam2(setitem, _OPERATOR_GT_METHODDEF
"setitem(a, b, c) -- Same as a[b] = c.") _OPERATOR_GE_METHODDEF
spam2(delitem, _OPERATOR__COMPARE_DIGEST_METHODDEF
"delitem(a, b) -- Same as del a[b].") _OPERATOR_LENGTH_HINT_METHODDEF
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__},
{NULL, NULL} /* sentinel */ {NULL, NULL} /* sentinel */
}; };
...@@ -409,6 +941,7 @@ typedef struct { ...@@ -409,6 +941,7 @@ typedef struct {
static PyTypeObject itemgetter_type; static PyTypeObject itemgetter_type;
/* AC 3.5: treats first argument as an iterable, otherwise uses *args */
static PyObject * static PyObject *
itemgetter_new(PyTypeObject *type, PyObject *args, PyObject *kwds) itemgetter_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{ {
...@@ -583,6 +1116,7 @@ typedef struct { ...@@ -583,6 +1116,7 @@ typedef struct {
static PyTypeObject attrgetter_type; static PyTypeObject attrgetter_type;
/* AC 3.5: treats first argument as an iterable, otherwise uses *args */
static PyObject * static PyObject *
attrgetter_new(PyTypeObject *type, PyObject *args, PyObject *kwds) attrgetter_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{ {
...@@ -927,6 +1461,7 @@ typedef struct { ...@@ -927,6 +1461,7 @@ typedef struct {
static PyTypeObject methodcaller_type; static PyTypeObject methodcaller_type;
/* AC 3.5: variable number of arguments, not currently support by AC */
static PyObject * static PyObject *
methodcaller_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 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