mirror of
https://github.com/python/cpython
synced 2024-11-02 08:22:14 +00:00
5f4b229df7
Previously, the result could have been an instance of a subclass of int. Also revert bpo-26202 and make attributes start, stop and step of the range object having exact type int. Add private function _PyNumber_Index() which preserves the old behavior of PyNumber_Index() for performance to use it in the conversion functions like PyLong_AsLong().
1489 lines
34 KiB
C
Generated
1489 lines
34 KiB
C
Generated
/*[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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("add", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("sub", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("mul", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("matmul", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("floordiv", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("truediv", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("mod", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("lshift", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("rshift", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("and_", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("xor", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("or_", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("iadd", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("isub", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("imul", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("imatmul", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("ifloordiv", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("itruediv", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("imod", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("ilshift", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("irshift", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("iand", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("ixor", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("ior", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("concat", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("iconcat", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
int _return_value;
|
|
|
|
if (!_PyArg_CheckPositional("contains", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
_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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
Py_ssize_t _return_value;
|
|
|
|
if (!_PyArg_CheckPositional("indexOf", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
_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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
Py_ssize_t _return_value;
|
|
|
|
if (!_PyArg_CheckPositional("countOf", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
_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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("getitem", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
PyObject *c;
|
|
|
|
if (!_PyArg_CheckPositional("setitem", nargs, 3, 3)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
c = args[2];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("delitem", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("eq", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("ne", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("lt", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("le", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("gt", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("ge", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("pow", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("ipow", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("is_", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("is_not", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *obj;
|
|
Py_ssize_t default_value = 0;
|
|
Py_ssize_t _return_value;
|
|
|
|
if (!_PyArg_CheckPositional("length_hint", nargs, 1, 2)) {
|
|
goto exit;
|
|
}
|
|
obj = args[0];
|
|
if (nargs < 2) {
|
|
goto skip_optional;
|
|
}
|
|
{
|
|
Py_ssize_t ival = -1;
|
|
PyObject *iobj = _PyNumber_Index(args[1]);
|
|
if (iobj != NULL) {
|
|
ival = PyLong_AsSsize_t(iobj);
|
|
Py_DECREF(iobj);
|
|
}
|
|
if (ival == -1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
default_value = ival;
|
|
}
|
|
skip_optional:
|
|
_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)(void(*)(void))_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 *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
PyObject *a;
|
|
PyObject *b;
|
|
|
|
if (!_PyArg_CheckPositional("_compare_digest", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
a = args[0];
|
|
b = args[1];
|
|
return_value = _operator__compare_digest_impl(module, a, b);
|
|
|
|
exit:
|
|
return return_value;
|
|
}
|
|
/*[clinic end generated code: output=eae5d08f971a65fd input=a9049054013a1b77]*/
|