Branch data Line data Source code
1 : : /*[clinic input]
2 : : preserve
3 : : [clinic start generated code]*/
4 : :
5 : : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
6 : : # include "pycore_gc.h" // PyGC_Head
7 : : # include "pycore_runtime.h" // _Py_ID()
8 : : #endif
9 : :
10 : :
11 : : PyDoc_STRVAR(_operator_truth__doc__,
12 : : "truth($module, a, /)\n"
13 : : "--\n"
14 : : "\n"
15 : : "Return True if a is true, False otherwise.");
16 : :
17 : : #define _OPERATOR_TRUTH_METHODDEF \
18 : : {"truth", (PyCFunction)_operator_truth, METH_O, _operator_truth__doc__},
19 : :
20 : : static int
21 : : _operator_truth_impl(PyObject *module, PyObject *a);
22 : :
23 : : static PyObject *
24 : 0 : _operator_truth(PyObject *module, PyObject *a)
25 : : {
26 : 0 : PyObject *return_value = NULL;
27 : : int _return_value;
28 : :
29 : 0 : _return_value = _operator_truth_impl(module, a);
30 [ # # # # ]: 0 : if ((_return_value == -1) && PyErr_Occurred()) {
31 : 0 : goto exit;
32 : : }
33 : 0 : return_value = PyBool_FromLong((long)_return_value);
34 : :
35 : 0 : exit:
36 : 0 : return return_value;
37 : : }
38 : :
39 : : PyDoc_STRVAR(_operator_add__doc__,
40 : : "add($module, a, b, /)\n"
41 : : "--\n"
42 : : "\n"
43 : : "Same as a + b.");
44 : :
45 : : #define _OPERATOR_ADD_METHODDEF \
46 : : {"add", _PyCFunction_CAST(_operator_add), METH_FASTCALL, _operator_add__doc__},
47 : :
48 : : static PyObject *
49 : : _operator_add_impl(PyObject *module, PyObject *a, PyObject *b);
50 : :
51 : : static PyObject *
52 : 2 : _operator_add(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
53 : : {
54 : 2 : PyObject *return_value = NULL;
55 : : PyObject *a;
56 : : PyObject *b;
57 : :
58 [ + - - + : 2 : if (!_PyArg_CheckPositional("add", nargs, 2, 2)) {
- - ]
59 : 0 : goto exit;
60 : : }
61 : 2 : a = args[0];
62 : 2 : b = args[1];
63 : 2 : return_value = _operator_add_impl(module, a, b);
64 : :
65 : 2 : exit:
66 : 2 : return return_value;
67 : : }
68 : :
69 : : PyDoc_STRVAR(_operator_sub__doc__,
70 : : "sub($module, a, b, /)\n"
71 : : "--\n"
72 : : "\n"
73 : : "Same as a - b.");
74 : :
75 : : #define _OPERATOR_SUB_METHODDEF \
76 : : {"sub", _PyCFunction_CAST(_operator_sub), METH_FASTCALL, _operator_sub__doc__},
77 : :
78 : : static PyObject *
79 : : _operator_sub_impl(PyObject *module, PyObject *a, PyObject *b);
80 : :
81 : : static PyObject *
82 : 0 : _operator_sub(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
83 : : {
84 : 0 : PyObject *return_value = NULL;
85 : : PyObject *a;
86 : : PyObject *b;
87 : :
88 [ # # # # : 0 : if (!_PyArg_CheckPositional("sub", nargs, 2, 2)) {
# # ]
89 : 0 : goto exit;
90 : : }
91 : 0 : a = args[0];
92 : 0 : b = args[1];
93 : 0 : return_value = _operator_sub_impl(module, a, b);
94 : :
95 : 0 : exit:
96 : 0 : return return_value;
97 : : }
98 : :
99 : : PyDoc_STRVAR(_operator_mul__doc__,
100 : : "mul($module, a, b, /)\n"
101 : : "--\n"
102 : : "\n"
103 : : "Same as a * b.");
104 : :
105 : : #define _OPERATOR_MUL_METHODDEF \
106 : : {"mul", _PyCFunction_CAST(_operator_mul), METH_FASTCALL, _operator_mul__doc__},
107 : :
108 : : static PyObject *
109 : : _operator_mul_impl(PyObject *module, PyObject *a, PyObject *b);
110 : :
111 : : static PyObject *
112 : 4 : _operator_mul(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
113 : : {
114 : 4 : PyObject *return_value = NULL;
115 : : PyObject *a;
116 : : PyObject *b;
117 : :
118 [ + - - + : 4 : if (!_PyArg_CheckPositional("mul", nargs, 2, 2)) {
- - ]
119 : 0 : goto exit;
120 : : }
121 : 4 : a = args[0];
122 : 4 : b = args[1];
123 : 4 : return_value = _operator_mul_impl(module, a, b);
124 : :
125 : 4 : exit:
126 : 4 : return return_value;
127 : : }
128 : :
129 : : PyDoc_STRVAR(_operator_matmul__doc__,
130 : : "matmul($module, a, b, /)\n"
131 : : "--\n"
132 : : "\n"
133 : : "Same as a @ b.");
134 : :
135 : : #define _OPERATOR_MATMUL_METHODDEF \
136 : : {"matmul", _PyCFunction_CAST(_operator_matmul), METH_FASTCALL, _operator_matmul__doc__},
137 : :
138 : : static PyObject *
139 : : _operator_matmul_impl(PyObject *module, PyObject *a, PyObject *b);
140 : :
141 : : static PyObject *
142 : 0 : _operator_matmul(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
143 : : {
144 : 0 : PyObject *return_value = NULL;
145 : : PyObject *a;
146 : : PyObject *b;
147 : :
148 [ # # # # : 0 : if (!_PyArg_CheckPositional("matmul", nargs, 2, 2)) {
# # ]
149 : 0 : goto exit;
150 : : }
151 : 0 : a = args[0];
152 : 0 : b = args[1];
153 : 0 : return_value = _operator_matmul_impl(module, a, b);
154 : :
155 : 0 : exit:
156 : 0 : return return_value;
157 : : }
158 : :
159 : : PyDoc_STRVAR(_operator_floordiv__doc__,
160 : : "floordiv($module, a, b, /)\n"
161 : : "--\n"
162 : : "\n"
163 : : "Same as a // b.");
164 : :
165 : : #define _OPERATOR_FLOORDIV_METHODDEF \
166 : : {"floordiv", _PyCFunction_CAST(_operator_floordiv), METH_FASTCALL, _operator_floordiv__doc__},
167 : :
168 : : static PyObject *
169 : : _operator_floordiv_impl(PyObject *module, PyObject *a, PyObject *b);
170 : :
171 : : static PyObject *
172 : 0 : _operator_floordiv(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
173 : : {
174 : 0 : PyObject *return_value = NULL;
175 : : PyObject *a;
176 : : PyObject *b;
177 : :
178 [ # # # # : 0 : if (!_PyArg_CheckPositional("floordiv", nargs, 2, 2)) {
# # ]
179 : 0 : goto exit;
180 : : }
181 : 0 : a = args[0];
182 : 0 : b = args[1];
183 : 0 : return_value = _operator_floordiv_impl(module, a, b);
184 : :
185 : 0 : exit:
186 : 0 : return return_value;
187 : : }
188 : :
189 : : PyDoc_STRVAR(_operator_truediv__doc__,
190 : : "truediv($module, a, b, /)\n"
191 : : "--\n"
192 : : "\n"
193 : : "Same as a / b.");
194 : :
195 : : #define _OPERATOR_TRUEDIV_METHODDEF \
196 : : {"truediv", _PyCFunction_CAST(_operator_truediv), METH_FASTCALL, _operator_truediv__doc__},
197 : :
198 : : static PyObject *
199 : : _operator_truediv_impl(PyObject *module, PyObject *a, PyObject *b);
200 : :
201 : : static PyObject *
202 : 0 : _operator_truediv(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
203 : : {
204 : 0 : PyObject *return_value = NULL;
205 : : PyObject *a;
206 : : PyObject *b;
207 : :
208 [ # # # # : 0 : if (!_PyArg_CheckPositional("truediv", nargs, 2, 2)) {
# # ]
209 : 0 : goto exit;
210 : : }
211 : 0 : a = args[0];
212 : 0 : b = args[1];
213 : 0 : return_value = _operator_truediv_impl(module, a, b);
214 : :
215 : 0 : exit:
216 : 0 : return return_value;
217 : : }
218 : :
219 : : PyDoc_STRVAR(_operator_mod__doc__,
220 : : "mod($module, a, b, /)\n"
221 : : "--\n"
222 : : "\n"
223 : : "Same as a % b.");
224 : :
225 : : #define _OPERATOR_MOD_METHODDEF \
226 : : {"mod", _PyCFunction_CAST(_operator_mod), METH_FASTCALL, _operator_mod__doc__},
227 : :
228 : : static PyObject *
229 : : _operator_mod_impl(PyObject *module, PyObject *a, PyObject *b);
230 : :
231 : : static PyObject *
232 : 0 : _operator_mod(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
233 : : {
234 : 0 : PyObject *return_value = NULL;
235 : : PyObject *a;
236 : : PyObject *b;
237 : :
238 [ # # # # : 0 : if (!_PyArg_CheckPositional("mod", nargs, 2, 2)) {
# # ]
239 : 0 : goto exit;
240 : : }
241 : 0 : a = args[0];
242 : 0 : b = args[1];
243 : 0 : return_value = _operator_mod_impl(module, a, b);
244 : :
245 : 0 : exit:
246 : 0 : return return_value;
247 : : }
248 : :
249 : : PyDoc_STRVAR(_operator_neg__doc__,
250 : : "neg($module, a, /)\n"
251 : : "--\n"
252 : : "\n"
253 : : "Same as -a.");
254 : :
255 : : #define _OPERATOR_NEG_METHODDEF \
256 : : {"neg", (PyCFunction)_operator_neg, METH_O, _operator_neg__doc__},
257 : :
258 : : PyDoc_STRVAR(_operator_pos__doc__,
259 : : "pos($module, a, /)\n"
260 : : "--\n"
261 : : "\n"
262 : : "Same as +a.");
263 : :
264 : : #define _OPERATOR_POS_METHODDEF \
265 : : {"pos", (PyCFunction)_operator_pos, METH_O, _operator_pos__doc__},
266 : :
267 : : PyDoc_STRVAR(_operator_abs__doc__,
268 : : "abs($module, a, /)\n"
269 : : "--\n"
270 : : "\n"
271 : : "Same as abs(a).");
272 : :
273 : : #define _OPERATOR_ABS_METHODDEF \
274 : : {"abs", (PyCFunction)_operator_abs, METH_O, _operator_abs__doc__},
275 : :
276 : : PyDoc_STRVAR(_operator_inv__doc__,
277 : : "inv($module, a, /)\n"
278 : : "--\n"
279 : : "\n"
280 : : "Same as ~a.");
281 : :
282 : : #define _OPERATOR_INV_METHODDEF \
283 : : {"inv", (PyCFunction)_operator_inv, METH_O, _operator_inv__doc__},
284 : :
285 : : PyDoc_STRVAR(_operator_invert__doc__,
286 : : "invert($module, a, /)\n"
287 : : "--\n"
288 : : "\n"
289 : : "Same as ~a.");
290 : :
291 : : #define _OPERATOR_INVERT_METHODDEF \
292 : : {"invert", (PyCFunction)_operator_invert, METH_O, _operator_invert__doc__},
293 : :
294 : : PyDoc_STRVAR(_operator_lshift__doc__,
295 : : "lshift($module, a, b, /)\n"
296 : : "--\n"
297 : : "\n"
298 : : "Same as a << b.");
299 : :
300 : : #define _OPERATOR_LSHIFT_METHODDEF \
301 : : {"lshift", _PyCFunction_CAST(_operator_lshift), METH_FASTCALL, _operator_lshift__doc__},
302 : :
303 : : static PyObject *
304 : : _operator_lshift_impl(PyObject *module, PyObject *a, PyObject *b);
305 : :
306 : : static PyObject *
307 : 0 : _operator_lshift(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
308 : : {
309 : 0 : PyObject *return_value = NULL;
310 : : PyObject *a;
311 : : PyObject *b;
312 : :
313 [ # # # # : 0 : if (!_PyArg_CheckPositional("lshift", nargs, 2, 2)) {
# # ]
314 : 0 : goto exit;
315 : : }
316 : 0 : a = args[0];
317 : 0 : b = args[1];
318 : 0 : return_value = _operator_lshift_impl(module, a, b);
319 : :
320 : 0 : exit:
321 : 0 : return return_value;
322 : : }
323 : :
324 : : PyDoc_STRVAR(_operator_rshift__doc__,
325 : : "rshift($module, a, b, /)\n"
326 : : "--\n"
327 : : "\n"
328 : : "Same as a >> b.");
329 : :
330 : : #define _OPERATOR_RSHIFT_METHODDEF \
331 : : {"rshift", _PyCFunction_CAST(_operator_rshift), METH_FASTCALL, _operator_rshift__doc__},
332 : :
333 : : static PyObject *
334 : : _operator_rshift_impl(PyObject *module, PyObject *a, PyObject *b);
335 : :
336 : : static PyObject *
337 : 0 : _operator_rshift(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
338 : : {
339 : 0 : PyObject *return_value = NULL;
340 : : PyObject *a;
341 : : PyObject *b;
342 : :
343 [ # # # # : 0 : if (!_PyArg_CheckPositional("rshift", nargs, 2, 2)) {
# # ]
344 : 0 : goto exit;
345 : : }
346 : 0 : a = args[0];
347 : 0 : b = args[1];
348 : 0 : return_value = _operator_rshift_impl(module, a, b);
349 : :
350 : 0 : exit:
351 : 0 : return return_value;
352 : : }
353 : :
354 : : PyDoc_STRVAR(_operator_not___doc__,
355 : : "not_($module, a, /)\n"
356 : : "--\n"
357 : : "\n"
358 : : "Same as not a.");
359 : :
360 : : #define _OPERATOR_NOT__METHODDEF \
361 : : {"not_", (PyCFunction)_operator_not_, METH_O, _operator_not___doc__},
362 : :
363 : : static int
364 : : _operator_not__impl(PyObject *module, PyObject *a);
365 : :
366 : : static PyObject *
367 : 0 : _operator_not_(PyObject *module, PyObject *a)
368 : : {
369 : 0 : PyObject *return_value = NULL;
370 : : int _return_value;
371 : :
372 : 0 : _return_value = _operator_not__impl(module, a);
373 [ # # # # ]: 0 : if ((_return_value == -1) && PyErr_Occurred()) {
374 : 0 : goto exit;
375 : : }
376 : 0 : return_value = PyBool_FromLong((long)_return_value);
377 : :
378 : 0 : exit:
379 : 0 : return return_value;
380 : : }
381 : :
382 : : PyDoc_STRVAR(_operator_and___doc__,
383 : : "and_($module, a, b, /)\n"
384 : : "--\n"
385 : : "\n"
386 : : "Same as a & b.");
387 : :
388 : : #define _OPERATOR_AND__METHODDEF \
389 : : {"and_", _PyCFunction_CAST(_operator_and_), METH_FASTCALL, _operator_and___doc__},
390 : :
391 : : static PyObject *
392 : : _operator_and__impl(PyObject *module, PyObject *a, PyObject *b);
393 : :
394 : : static PyObject *
395 : 0 : _operator_and_(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
396 : : {
397 : 0 : PyObject *return_value = NULL;
398 : : PyObject *a;
399 : : PyObject *b;
400 : :
401 [ # # # # : 0 : if (!_PyArg_CheckPositional("and_", nargs, 2, 2)) {
# # ]
402 : 0 : goto exit;
403 : : }
404 : 0 : a = args[0];
405 : 0 : b = args[1];
406 : 0 : return_value = _operator_and__impl(module, a, b);
407 : :
408 : 0 : exit:
409 : 0 : return return_value;
410 : : }
411 : :
412 : : PyDoc_STRVAR(_operator_xor__doc__,
413 : : "xor($module, a, b, /)\n"
414 : : "--\n"
415 : : "\n"
416 : : "Same as a ^ b.");
417 : :
418 : : #define _OPERATOR_XOR_METHODDEF \
419 : : {"xor", _PyCFunction_CAST(_operator_xor), METH_FASTCALL, _operator_xor__doc__},
420 : :
421 : : static PyObject *
422 : : _operator_xor_impl(PyObject *module, PyObject *a, PyObject *b);
423 : :
424 : : static PyObject *
425 : 0 : _operator_xor(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
426 : : {
427 : 0 : PyObject *return_value = NULL;
428 : : PyObject *a;
429 : : PyObject *b;
430 : :
431 [ # # # # : 0 : if (!_PyArg_CheckPositional("xor", nargs, 2, 2)) {
# # ]
432 : 0 : goto exit;
433 : : }
434 : 0 : a = args[0];
435 : 0 : b = args[1];
436 : 0 : return_value = _operator_xor_impl(module, a, b);
437 : :
438 : 0 : exit:
439 : 0 : return return_value;
440 : : }
441 : :
442 : : PyDoc_STRVAR(_operator_or___doc__,
443 : : "or_($module, a, b, /)\n"
444 : : "--\n"
445 : : "\n"
446 : : "Same as a | b.");
447 : :
448 : : #define _OPERATOR_OR__METHODDEF \
449 : : {"or_", _PyCFunction_CAST(_operator_or_), METH_FASTCALL, _operator_or___doc__},
450 : :
451 : : static PyObject *
452 : : _operator_or__impl(PyObject *module, PyObject *a, PyObject *b);
453 : :
454 : : static PyObject *
455 : 0 : _operator_or_(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
456 : : {
457 : 0 : PyObject *return_value = NULL;
458 : : PyObject *a;
459 : : PyObject *b;
460 : :
461 [ # # # # : 0 : if (!_PyArg_CheckPositional("or_", nargs, 2, 2)) {
# # ]
462 : 0 : goto exit;
463 : : }
464 : 0 : a = args[0];
465 : 0 : b = args[1];
466 : 0 : return_value = _operator_or__impl(module, a, b);
467 : :
468 : 0 : exit:
469 : 0 : return return_value;
470 : : }
471 : :
472 : : PyDoc_STRVAR(_operator_iadd__doc__,
473 : : "iadd($module, a, b, /)\n"
474 : : "--\n"
475 : : "\n"
476 : : "Same as a += b.");
477 : :
478 : : #define _OPERATOR_IADD_METHODDEF \
479 : : {"iadd", _PyCFunction_CAST(_operator_iadd), METH_FASTCALL, _operator_iadd__doc__},
480 : :
481 : : static PyObject *
482 : : _operator_iadd_impl(PyObject *module, PyObject *a, PyObject *b);
483 : :
484 : : static PyObject *
485 : 0 : _operator_iadd(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
486 : : {
487 : 0 : PyObject *return_value = NULL;
488 : : PyObject *a;
489 : : PyObject *b;
490 : :
491 [ # # # # : 0 : if (!_PyArg_CheckPositional("iadd", nargs, 2, 2)) {
# # ]
492 : 0 : goto exit;
493 : : }
494 : 0 : a = args[0];
495 : 0 : b = args[1];
496 : 0 : return_value = _operator_iadd_impl(module, a, b);
497 : :
498 : 0 : exit:
499 : 0 : return return_value;
500 : : }
501 : :
502 : : PyDoc_STRVAR(_operator_isub__doc__,
503 : : "isub($module, a, b, /)\n"
504 : : "--\n"
505 : : "\n"
506 : : "Same as a -= b.");
507 : :
508 : : #define _OPERATOR_ISUB_METHODDEF \
509 : : {"isub", _PyCFunction_CAST(_operator_isub), METH_FASTCALL, _operator_isub__doc__},
510 : :
511 : : static PyObject *
512 : : _operator_isub_impl(PyObject *module, PyObject *a, PyObject *b);
513 : :
514 : : static PyObject *
515 : 0 : _operator_isub(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
516 : : {
517 : 0 : PyObject *return_value = NULL;
518 : : PyObject *a;
519 : : PyObject *b;
520 : :
521 [ # # # # : 0 : if (!_PyArg_CheckPositional("isub", nargs, 2, 2)) {
# # ]
522 : 0 : goto exit;
523 : : }
524 : 0 : a = args[0];
525 : 0 : b = args[1];
526 : 0 : return_value = _operator_isub_impl(module, a, b);
527 : :
528 : 0 : exit:
529 : 0 : return return_value;
530 : : }
531 : :
532 : : PyDoc_STRVAR(_operator_imul__doc__,
533 : : "imul($module, a, b, /)\n"
534 : : "--\n"
535 : : "\n"
536 : : "Same as a *= b.");
537 : :
538 : : #define _OPERATOR_IMUL_METHODDEF \
539 : : {"imul", _PyCFunction_CAST(_operator_imul), METH_FASTCALL, _operator_imul__doc__},
540 : :
541 : : static PyObject *
542 : : _operator_imul_impl(PyObject *module, PyObject *a, PyObject *b);
543 : :
544 : : static PyObject *
545 : 0 : _operator_imul(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
546 : : {
547 : 0 : PyObject *return_value = NULL;
548 : : PyObject *a;
549 : : PyObject *b;
550 : :
551 [ # # # # : 0 : if (!_PyArg_CheckPositional("imul", nargs, 2, 2)) {
# # ]
552 : 0 : goto exit;
553 : : }
554 : 0 : a = args[0];
555 : 0 : b = args[1];
556 : 0 : return_value = _operator_imul_impl(module, a, b);
557 : :
558 : 0 : exit:
559 : 0 : return return_value;
560 : : }
561 : :
562 : : PyDoc_STRVAR(_operator_imatmul__doc__,
563 : : "imatmul($module, a, b, /)\n"
564 : : "--\n"
565 : : "\n"
566 : : "Same as a @= b.");
567 : :
568 : : #define _OPERATOR_IMATMUL_METHODDEF \
569 : : {"imatmul", _PyCFunction_CAST(_operator_imatmul), METH_FASTCALL, _operator_imatmul__doc__},
570 : :
571 : : static PyObject *
572 : : _operator_imatmul_impl(PyObject *module, PyObject *a, PyObject *b);
573 : :
574 : : static PyObject *
575 : 0 : _operator_imatmul(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
576 : : {
577 : 0 : PyObject *return_value = NULL;
578 : : PyObject *a;
579 : : PyObject *b;
580 : :
581 [ # # # # : 0 : if (!_PyArg_CheckPositional("imatmul", nargs, 2, 2)) {
# # ]
582 : 0 : goto exit;
583 : : }
584 : 0 : a = args[0];
585 : 0 : b = args[1];
586 : 0 : return_value = _operator_imatmul_impl(module, a, b);
587 : :
588 : 0 : exit:
589 : 0 : return return_value;
590 : : }
591 : :
592 : : PyDoc_STRVAR(_operator_ifloordiv__doc__,
593 : : "ifloordiv($module, a, b, /)\n"
594 : : "--\n"
595 : : "\n"
596 : : "Same as a //= b.");
597 : :
598 : : #define _OPERATOR_IFLOORDIV_METHODDEF \
599 : : {"ifloordiv", _PyCFunction_CAST(_operator_ifloordiv), METH_FASTCALL, _operator_ifloordiv__doc__},
600 : :
601 : : static PyObject *
602 : : _operator_ifloordiv_impl(PyObject *module, PyObject *a, PyObject *b);
603 : :
604 : : static PyObject *
605 : 0 : _operator_ifloordiv(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
606 : : {
607 : 0 : PyObject *return_value = NULL;
608 : : PyObject *a;
609 : : PyObject *b;
610 : :
611 [ # # # # : 0 : if (!_PyArg_CheckPositional("ifloordiv", nargs, 2, 2)) {
# # ]
612 : 0 : goto exit;
613 : : }
614 : 0 : a = args[0];
615 : 0 : b = args[1];
616 : 0 : return_value = _operator_ifloordiv_impl(module, a, b);
617 : :
618 : 0 : exit:
619 : 0 : return return_value;
620 : : }
621 : :
622 : : PyDoc_STRVAR(_operator_itruediv__doc__,
623 : : "itruediv($module, a, b, /)\n"
624 : : "--\n"
625 : : "\n"
626 : : "Same as a /= b.");
627 : :
628 : : #define _OPERATOR_ITRUEDIV_METHODDEF \
629 : : {"itruediv", _PyCFunction_CAST(_operator_itruediv), METH_FASTCALL, _operator_itruediv__doc__},
630 : :
631 : : static PyObject *
632 : : _operator_itruediv_impl(PyObject *module, PyObject *a, PyObject *b);
633 : :
634 : : static PyObject *
635 : 0 : _operator_itruediv(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
636 : : {
637 : 0 : PyObject *return_value = NULL;
638 : : PyObject *a;
639 : : PyObject *b;
640 : :
641 [ # # # # : 0 : if (!_PyArg_CheckPositional("itruediv", nargs, 2, 2)) {
# # ]
642 : 0 : goto exit;
643 : : }
644 : 0 : a = args[0];
645 : 0 : b = args[1];
646 : 0 : return_value = _operator_itruediv_impl(module, a, b);
647 : :
648 : 0 : exit:
649 : 0 : return return_value;
650 : : }
651 : :
652 : : PyDoc_STRVAR(_operator_imod__doc__,
653 : : "imod($module, a, b, /)\n"
654 : : "--\n"
655 : : "\n"
656 : : "Same as a %= b.");
657 : :
658 : : #define _OPERATOR_IMOD_METHODDEF \
659 : : {"imod", _PyCFunction_CAST(_operator_imod), METH_FASTCALL, _operator_imod__doc__},
660 : :
661 : : static PyObject *
662 : : _operator_imod_impl(PyObject *module, PyObject *a, PyObject *b);
663 : :
664 : : static PyObject *
665 : 0 : _operator_imod(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
666 : : {
667 : 0 : PyObject *return_value = NULL;
668 : : PyObject *a;
669 : : PyObject *b;
670 : :
671 [ # # # # : 0 : if (!_PyArg_CheckPositional("imod", nargs, 2, 2)) {
# # ]
672 : 0 : goto exit;
673 : : }
674 : 0 : a = args[0];
675 : 0 : b = args[1];
676 : 0 : return_value = _operator_imod_impl(module, a, b);
677 : :
678 : 0 : exit:
679 : 0 : return return_value;
680 : : }
681 : :
682 : : PyDoc_STRVAR(_operator_ilshift__doc__,
683 : : "ilshift($module, a, b, /)\n"
684 : : "--\n"
685 : : "\n"
686 : : "Same as a <<= b.");
687 : :
688 : : #define _OPERATOR_ILSHIFT_METHODDEF \
689 : : {"ilshift", _PyCFunction_CAST(_operator_ilshift), METH_FASTCALL, _operator_ilshift__doc__},
690 : :
691 : : static PyObject *
692 : : _operator_ilshift_impl(PyObject *module, PyObject *a, PyObject *b);
693 : :
694 : : static PyObject *
695 : 0 : _operator_ilshift(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
696 : : {
697 : 0 : PyObject *return_value = NULL;
698 : : PyObject *a;
699 : : PyObject *b;
700 : :
701 [ # # # # : 0 : if (!_PyArg_CheckPositional("ilshift", nargs, 2, 2)) {
# # ]
702 : 0 : goto exit;
703 : : }
704 : 0 : a = args[0];
705 : 0 : b = args[1];
706 : 0 : return_value = _operator_ilshift_impl(module, a, b);
707 : :
708 : 0 : exit:
709 : 0 : return return_value;
710 : : }
711 : :
712 : : PyDoc_STRVAR(_operator_irshift__doc__,
713 : : "irshift($module, a, b, /)\n"
714 : : "--\n"
715 : : "\n"
716 : : "Same as a >>= b.");
717 : :
718 : : #define _OPERATOR_IRSHIFT_METHODDEF \
719 : : {"irshift", _PyCFunction_CAST(_operator_irshift), METH_FASTCALL, _operator_irshift__doc__},
720 : :
721 : : static PyObject *
722 : : _operator_irshift_impl(PyObject *module, PyObject *a, PyObject *b);
723 : :
724 : : static PyObject *
725 : 0 : _operator_irshift(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
726 : : {
727 : 0 : PyObject *return_value = NULL;
728 : : PyObject *a;
729 : : PyObject *b;
730 : :
731 [ # # # # : 0 : if (!_PyArg_CheckPositional("irshift", nargs, 2, 2)) {
# # ]
732 : 0 : goto exit;
733 : : }
734 : 0 : a = args[0];
735 : 0 : b = args[1];
736 : 0 : return_value = _operator_irshift_impl(module, a, b);
737 : :
738 : 0 : exit:
739 : 0 : return return_value;
740 : : }
741 : :
742 : : PyDoc_STRVAR(_operator_iand__doc__,
743 : : "iand($module, a, b, /)\n"
744 : : "--\n"
745 : : "\n"
746 : : "Same as a &= b.");
747 : :
748 : : #define _OPERATOR_IAND_METHODDEF \
749 : : {"iand", _PyCFunction_CAST(_operator_iand), METH_FASTCALL, _operator_iand__doc__},
750 : :
751 : : static PyObject *
752 : : _operator_iand_impl(PyObject *module, PyObject *a, PyObject *b);
753 : :
754 : : static PyObject *
755 : 0 : _operator_iand(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
756 : : {
757 : 0 : PyObject *return_value = NULL;
758 : : PyObject *a;
759 : : PyObject *b;
760 : :
761 [ # # # # : 0 : if (!_PyArg_CheckPositional("iand", nargs, 2, 2)) {
# # ]
762 : 0 : goto exit;
763 : : }
764 : 0 : a = args[0];
765 : 0 : b = args[1];
766 : 0 : return_value = _operator_iand_impl(module, a, b);
767 : :
768 : 0 : exit:
769 : 0 : return return_value;
770 : : }
771 : :
772 : : PyDoc_STRVAR(_operator_ixor__doc__,
773 : : "ixor($module, a, b, /)\n"
774 : : "--\n"
775 : : "\n"
776 : : "Same as a ^= b.");
777 : :
778 : : #define _OPERATOR_IXOR_METHODDEF \
779 : : {"ixor", _PyCFunction_CAST(_operator_ixor), METH_FASTCALL, _operator_ixor__doc__},
780 : :
781 : : static PyObject *
782 : : _operator_ixor_impl(PyObject *module, PyObject *a, PyObject *b);
783 : :
784 : : static PyObject *
785 : 0 : _operator_ixor(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
786 : : {
787 : 0 : PyObject *return_value = NULL;
788 : : PyObject *a;
789 : : PyObject *b;
790 : :
791 [ # # # # : 0 : if (!_PyArg_CheckPositional("ixor", nargs, 2, 2)) {
# # ]
792 : 0 : goto exit;
793 : : }
794 : 0 : a = args[0];
795 : 0 : b = args[1];
796 : 0 : return_value = _operator_ixor_impl(module, a, b);
797 : :
798 : 0 : exit:
799 : 0 : return return_value;
800 : : }
801 : :
802 : : PyDoc_STRVAR(_operator_ior__doc__,
803 : : "ior($module, a, b, /)\n"
804 : : "--\n"
805 : : "\n"
806 : : "Same as a |= b.");
807 : :
808 : : #define _OPERATOR_IOR_METHODDEF \
809 : : {"ior", _PyCFunction_CAST(_operator_ior), METH_FASTCALL, _operator_ior__doc__},
810 : :
811 : : static PyObject *
812 : : _operator_ior_impl(PyObject *module, PyObject *a, PyObject *b);
813 : :
814 : : static PyObject *
815 : 0 : _operator_ior(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
816 : : {
817 : 0 : PyObject *return_value = NULL;
818 : : PyObject *a;
819 : : PyObject *b;
820 : :
821 [ # # # # : 0 : if (!_PyArg_CheckPositional("ior", nargs, 2, 2)) {
# # ]
822 : 0 : goto exit;
823 : : }
824 : 0 : a = args[0];
825 : 0 : b = args[1];
826 : 0 : return_value = _operator_ior_impl(module, a, b);
827 : :
828 : 0 : exit:
829 : 0 : return return_value;
830 : : }
831 : :
832 : : PyDoc_STRVAR(_operator_concat__doc__,
833 : : "concat($module, a, b, /)\n"
834 : : "--\n"
835 : : "\n"
836 : : "Same as a + b, for a and b sequences.");
837 : :
838 : : #define _OPERATOR_CONCAT_METHODDEF \
839 : : {"concat", _PyCFunction_CAST(_operator_concat), METH_FASTCALL, _operator_concat__doc__},
840 : :
841 : : static PyObject *
842 : : _operator_concat_impl(PyObject *module, PyObject *a, PyObject *b);
843 : :
844 : : static PyObject *
845 : 0 : _operator_concat(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
846 : : {
847 : 0 : PyObject *return_value = NULL;
848 : : PyObject *a;
849 : : PyObject *b;
850 : :
851 [ # # # # : 0 : if (!_PyArg_CheckPositional("concat", nargs, 2, 2)) {
# # ]
852 : 0 : goto exit;
853 : : }
854 : 0 : a = args[0];
855 : 0 : b = args[1];
856 : 0 : return_value = _operator_concat_impl(module, a, b);
857 : :
858 : 0 : exit:
859 : 0 : return return_value;
860 : : }
861 : :
862 : : PyDoc_STRVAR(_operator_iconcat__doc__,
863 : : "iconcat($module, a, b, /)\n"
864 : : "--\n"
865 : : "\n"
866 : : "Same as a += b, for a and b sequences.");
867 : :
868 : : #define _OPERATOR_ICONCAT_METHODDEF \
869 : : {"iconcat", _PyCFunction_CAST(_operator_iconcat), METH_FASTCALL, _operator_iconcat__doc__},
870 : :
871 : : static PyObject *
872 : : _operator_iconcat_impl(PyObject *module, PyObject *a, PyObject *b);
873 : :
874 : : static PyObject *
875 : 0 : _operator_iconcat(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
876 : : {
877 : 0 : PyObject *return_value = NULL;
878 : : PyObject *a;
879 : : PyObject *b;
880 : :
881 [ # # # # : 0 : if (!_PyArg_CheckPositional("iconcat", nargs, 2, 2)) {
# # ]
882 : 0 : goto exit;
883 : : }
884 : 0 : a = args[0];
885 : 0 : b = args[1];
886 : 0 : return_value = _operator_iconcat_impl(module, a, b);
887 : :
888 : 0 : exit:
889 : 0 : return return_value;
890 : : }
891 : :
892 : : PyDoc_STRVAR(_operator_contains__doc__,
893 : : "contains($module, a, b, /)\n"
894 : : "--\n"
895 : : "\n"
896 : : "Same as b in a (note reversed operands).");
897 : :
898 : : #define _OPERATOR_CONTAINS_METHODDEF \
899 : : {"contains", _PyCFunction_CAST(_operator_contains), METH_FASTCALL, _operator_contains__doc__},
900 : :
901 : : static int
902 : : _operator_contains_impl(PyObject *module, PyObject *a, PyObject *b);
903 : :
904 : : static PyObject *
905 : 0 : _operator_contains(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
906 : : {
907 : 0 : PyObject *return_value = NULL;
908 : : PyObject *a;
909 : : PyObject *b;
910 : : int _return_value;
911 : :
912 [ # # # # : 0 : if (!_PyArg_CheckPositional("contains", nargs, 2, 2)) {
# # ]
913 : 0 : goto exit;
914 : : }
915 : 0 : a = args[0];
916 : 0 : b = args[1];
917 : 0 : _return_value = _operator_contains_impl(module, a, b);
918 [ # # # # ]: 0 : if ((_return_value == -1) && PyErr_Occurred()) {
919 : 0 : goto exit;
920 : : }
921 : 0 : return_value = PyBool_FromLong((long)_return_value);
922 : :
923 : 0 : exit:
924 : 0 : return return_value;
925 : : }
926 : :
927 : : PyDoc_STRVAR(_operator_indexOf__doc__,
928 : : "indexOf($module, a, b, /)\n"
929 : : "--\n"
930 : : "\n"
931 : : "Return the first index of b in a.");
932 : :
933 : : #define _OPERATOR_INDEXOF_METHODDEF \
934 : : {"indexOf", _PyCFunction_CAST(_operator_indexOf), METH_FASTCALL, _operator_indexOf__doc__},
935 : :
936 : : static Py_ssize_t
937 : : _operator_indexOf_impl(PyObject *module, PyObject *a, PyObject *b);
938 : :
939 : : static PyObject *
940 : 0 : _operator_indexOf(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
941 : : {
942 : 0 : PyObject *return_value = NULL;
943 : : PyObject *a;
944 : : PyObject *b;
945 : : Py_ssize_t _return_value;
946 : :
947 [ # # # # : 0 : if (!_PyArg_CheckPositional("indexOf", nargs, 2, 2)) {
# # ]
948 : 0 : goto exit;
949 : : }
950 : 0 : a = args[0];
951 : 0 : b = args[1];
952 : 0 : _return_value = _operator_indexOf_impl(module, a, b);
953 [ # # # # ]: 0 : if ((_return_value == -1) && PyErr_Occurred()) {
954 : 0 : goto exit;
955 : : }
956 : 0 : return_value = PyLong_FromSsize_t(_return_value);
957 : :
958 : 0 : exit:
959 : 0 : return return_value;
960 : : }
961 : :
962 : : PyDoc_STRVAR(_operator_countOf__doc__,
963 : : "countOf($module, a, b, /)\n"
964 : : "--\n"
965 : : "\n"
966 : : "Return the number of items in a which are, or which equal, b.");
967 : :
968 : : #define _OPERATOR_COUNTOF_METHODDEF \
969 : : {"countOf", _PyCFunction_CAST(_operator_countOf), METH_FASTCALL, _operator_countOf__doc__},
970 : :
971 : : static Py_ssize_t
972 : : _operator_countOf_impl(PyObject *module, PyObject *a, PyObject *b);
973 : :
974 : : static PyObject *
975 : 0 : _operator_countOf(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
976 : : {
977 : 0 : PyObject *return_value = NULL;
978 : : PyObject *a;
979 : : PyObject *b;
980 : : Py_ssize_t _return_value;
981 : :
982 [ # # # # : 0 : if (!_PyArg_CheckPositional("countOf", nargs, 2, 2)) {
# # ]
983 : 0 : goto exit;
984 : : }
985 : 0 : a = args[0];
986 : 0 : b = args[1];
987 : 0 : _return_value = _operator_countOf_impl(module, a, b);
988 [ # # # # ]: 0 : if ((_return_value == -1) && PyErr_Occurred()) {
989 : 0 : goto exit;
990 : : }
991 : 0 : return_value = PyLong_FromSsize_t(_return_value);
992 : :
993 : 0 : exit:
994 : 0 : return return_value;
995 : : }
996 : :
997 : : PyDoc_STRVAR(_operator_getitem__doc__,
998 : : "getitem($module, a, b, /)\n"
999 : : "--\n"
1000 : : "\n"
1001 : : "Same as a[b].");
1002 : :
1003 : : #define _OPERATOR_GETITEM_METHODDEF \
1004 : : {"getitem", _PyCFunction_CAST(_operator_getitem), METH_FASTCALL, _operator_getitem__doc__},
1005 : :
1006 : : static PyObject *
1007 : : _operator_getitem_impl(PyObject *module, PyObject *a, PyObject *b);
1008 : :
1009 : : static PyObject *
1010 : 0 : _operator_getitem(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1011 : : {
1012 : 0 : PyObject *return_value = NULL;
1013 : : PyObject *a;
1014 : : PyObject *b;
1015 : :
1016 [ # # # # : 0 : if (!_PyArg_CheckPositional("getitem", nargs, 2, 2)) {
# # ]
1017 : 0 : goto exit;
1018 : : }
1019 : 0 : a = args[0];
1020 : 0 : b = args[1];
1021 : 0 : return_value = _operator_getitem_impl(module, a, b);
1022 : :
1023 : 0 : exit:
1024 : 0 : return return_value;
1025 : : }
1026 : :
1027 : : PyDoc_STRVAR(_operator_setitem__doc__,
1028 : : "setitem($module, a, b, c, /)\n"
1029 : : "--\n"
1030 : : "\n"
1031 : : "Same as a[b] = c.");
1032 : :
1033 : : #define _OPERATOR_SETITEM_METHODDEF \
1034 : : {"setitem", _PyCFunction_CAST(_operator_setitem), METH_FASTCALL, _operator_setitem__doc__},
1035 : :
1036 : : static PyObject *
1037 : : _operator_setitem_impl(PyObject *module, PyObject *a, PyObject *b,
1038 : : PyObject *c);
1039 : :
1040 : : static PyObject *
1041 : 0 : _operator_setitem(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1042 : : {
1043 : 0 : PyObject *return_value = NULL;
1044 : : PyObject *a;
1045 : : PyObject *b;
1046 : : PyObject *c;
1047 : :
1048 [ # # # # : 0 : if (!_PyArg_CheckPositional("setitem", nargs, 3, 3)) {
# # ]
1049 : 0 : goto exit;
1050 : : }
1051 : 0 : a = args[0];
1052 : 0 : b = args[1];
1053 : 0 : c = args[2];
1054 : 0 : return_value = _operator_setitem_impl(module, a, b, c);
1055 : :
1056 : 0 : exit:
1057 : 0 : return return_value;
1058 : : }
1059 : :
1060 : : PyDoc_STRVAR(_operator_delitem__doc__,
1061 : : "delitem($module, a, b, /)\n"
1062 : : "--\n"
1063 : : "\n"
1064 : : "Same as del a[b].");
1065 : :
1066 : : #define _OPERATOR_DELITEM_METHODDEF \
1067 : : {"delitem", _PyCFunction_CAST(_operator_delitem), METH_FASTCALL, _operator_delitem__doc__},
1068 : :
1069 : : static PyObject *
1070 : : _operator_delitem_impl(PyObject *module, PyObject *a, PyObject *b);
1071 : :
1072 : : static PyObject *
1073 : 0 : _operator_delitem(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1074 : : {
1075 : 0 : PyObject *return_value = NULL;
1076 : : PyObject *a;
1077 : : PyObject *b;
1078 : :
1079 [ # # # # : 0 : if (!_PyArg_CheckPositional("delitem", nargs, 2, 2)) {
# # ]
1080 : 0 : goto exit;
1081 : : }
1082 : 0 : a = args[0];
1083 : 0 : b = args[1];
1084 : 0 : return_value = _operator_delitem_impl(module, a, b);
1085 : :
1086 : 0 : exit:
1087 : 0 : return return_value;
1088 : : }
1089 : :
1090 : : PyDoc_STRVAR(_operator_eq__doc__,
1091 : : "eq($module, a, b, /)\n"
1092 : : "--\n"
1093 : : "\n"
1094 : : "Same as a == b.");
1095 : :
1096 : : #define _OPERATOR_EQ_METHODDEF \
1097 : : {"eq", _PyCFunction_CAST(_operator_eq), METH_FASTCALL, _operator_eq__doc__},
1098 : :
1099 : : static PyObject *
1100 : : _operator_eq_impl(PyObject *module, PyObject *a, PyObject *b);
1101 : :
1102 : : static PyObject *
1103 : 0 : _operator_eq(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1104 : : {
1105 : 0 : PyObject *return_value = NULL;
1106 : : PyObject *a;
1107 : : PyObject *b;
1108 : :
1109 [ # # # # : 0 : if (!_PyArg_CheckPositional("eq", nargs, 2, 2)) {
# # ]
1110 : 0 : goto exit;
1111 : : }
1112 : 0 : a = args[0];
1113 : 0 : b = args[1];
1114 : 0 : return_value = _operator_eq_impl(module, a, b);
1115 : :
1116 : 0 : exit:
1117 : 0 : return return_value;
1118 : : }
1119 : :
1120 : : PyDoc_STRVAR(_operator_ne__doc__,
1121 : : "ne($module, a, b, /)\n"
1122 : : "--\n"
1123 : : "\n"
1124 : : "Same as a != b.");
1125 : :
1126 : : #define _OPERATOR_NE_METHODDEF \
1127 : : {"ne", _PyCFunction_CAST(_operator_ne), METH_FASTCALL, _operator_ne__doc__},
1128 : :
1129 : : static PyObject *
1130 : : _operator_ne_impl(PyObject *module, PyObject *a, PyObject *b);
1131 : :
1132 : : static PyObject *
1133 : 0 : _operator_ne(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1134 : : {
1135 : 0 : PyObject *return_value = NULL;
1136 : : PyObject *a;
1137 : : PyObject *b;
1138 : :
1139 [ # # # # : 0 : if (!_PyArg_CheckPositional("ne", nargs, 2, 2)) {
# # ]
1140 : 0 : goto exit;
1141 : : }
1142 : 0 : a = args[0];
1143 : 0 : b = args[1];
1144 : 0 : return_value = _operator_ne_impl(module, a, b);
1145 : :
1146 : 0 : exit:
1147 : 0 : return return_value;
1148 : : }
1149 : :
1150 : : PyDoc_STRVAR(_operator_lt__doc__,
1151 : : "lt($module, a, b, /)\n"
1152 : : "--\n"
1153 : : "\n"
1154 : : "Same as a < b.");
1155 : :
1156 : : #define _OPERATOR_LT_METHODDEF \
1157 : : {"lt", _PyCFunction_CAST(_operator_lt), METH_FASTCALL, _operator_lt__doc__},
1158 : :
1159 : : static PyObject *
1160 : : _operator_lt_impl(PyObject *module, PyObject *a, PyObject *b);
1161 : :
1162 : : static PyObject *
1163 : 0 : _operator_lt(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1164 : : {
1165 : 0 : PyObject *return_value = NULL;
1166 : : PyObject *a;
1167 : : PyObject *b;
1168 : :
1169 [ # # # # : 0 : if (!_PyArg_CheckPositional("lt", nargs, 2, 2)) {
# # ]
1170 : 0 : goto exit;
1171 : : }
1172 : 0 : a = args[0];
1173 : 0 : b = args[1];
1174 : 0 : return_value = _operator_lt_impl(module, a, b);
1175 : :
1176 : 0 : exit:
1177 : 0 : return return_value;
1178 : : }
1179 : :
1180 : : PyDoc_STRVAR(_operator_le__doc__,
1181 : : "le($module, a, b, /)\n"
1182 : : "--\n"
1183 : : "\n"
1184 : : "Same as a <= b.");
1185 : :
1186 : : #define _OPERATOR_LE_METHODDEF \
1187 : : {"le", _PyCFunction_CAST(_operator_le), METH_FASTCALL, _operator_le__doc__},
1188 : :
1189 : : static PyObject *
1190 : : _operator_le_impl(PyObject *module, PyObject *a, PyObject *b);
1191 : :
1192 : : static PyObject *
1193 : 9848 : _operator_le(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1194 : : {
1195 : 9848 : PyObject *return_value = NULL;
1196 : : PyObject *a;
1197 : : PyObject *b;
1198 : :
1199 [ + - - + : 9848 : if (!_PyArg_CheckPositional("le", nargs, 2, 2)) {
- - ]
1200 : 0 : goto exit;
1201 : : }
1202 : 9848 : a = args[0];
1203 : 9848 : b = args[1];
1204 : 9848 : return_value = _operator_le_impl(module, a, b);
1205 : :
1206 : 9848 : exit:
1207 : 9848 : return return_value;
1208 : : }
1209 : :
1210 : : PyDoc_STRVAR(_operator_gt__doc__,
1211 : : "gt($module, a, b, /)\n"
1212 : : "--\n"
1213 : : "\n"
1214 : : "Same as a > b.");
1215 : :
1216 : : #define _OPERATOR_GT_METHODDEF \
1217 : : {"gt", _PyCFunction_CAST(_operator_gt), METH_FASTCALL, _operator_gt__doc__},
1218 : :
1219 : : static PyObject *
1220 : : _operator_gt_impl(PyObject *module, PyObject *a, PyObject *b);
1221 : :
1222 : : static PyObject *
1223 : 0 : _operator_gt(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1224 : : {
1225 : 0 : PyObject *return_value = NULL;
1226 : : PyObject *a;
1227 : : PyObject *b;
1228 : :
1229 [ # # # # : 0 : if (!_PyArg_CheckPositional("gt", nargs, 2, 2)) {
# # ]
1230 : 0 : goto exit;
1231 : : }
1232 : 0 : a = args[0];
1233 : 0 : b = args[1];
1234 : 0 : return_value = _operator_gt_impl(module, a, b);
1235 : :
1236 : 0 : exit:
1237 : 0 : return return_value;
1238 : : }
1239 : :
1240 : : PyDoc_STRVAR(_operator_ge__doc__,
1241 : : "ge($module, a, b, /)\n"
1242 : : "--\n"
1243 : : "\n"
1244 : : "Same as a >= b.");
1245 : :
1246 : : #define _OPERATOR_GE_METHODDEF \
1247 : : {"ge", _PyCFunction_CAST(_operator_ge), METH_FASTCALL, _operator_ge__doc__},
1248 : :
1249 : : static PyObject *
1250 : : _operator_ge_impl(PyObject *module, PyObject *a, PyObject *b);
1251 : :
1252 : : static PyObject *
1253 : 0 : _operator_ge(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1254 : : {
1255 : 0 : PyObject *return_value = NULL;
1256 : : PyObject *a;
1257 : : PyObject *b;
1258 : :
1259 [ # # # # : 0 : if (!_PyArg_CheckPositional("ge", nargs, 2, 2)) {
# # ]
1260 : 0 : goto exit;
1261 : : }
1262 : 0 : a = args[0];
1263 : 0 : b = args[1];
1264 : 0 : return_value = _operator_ge_impl(module, a, b);
1265 : :
1266 : 0 : exit:
1267 : 0 : return return_value;
1268 : : }
1269 : :
1270 : : PyDoc_STRVAR(_operator_pow__doc__,
1271 : : "pow($module, a, b, /)\n"
1272 : : "--\n"
1273 : : "\n"
1274 : : "Same as a ** b.");
1275 : :
1276 : : #define _OPERATOR_POW_METHODDEF \
1277 : : {"pow", _PyCFunction_CAST(_operator_pow), METH_FASTCALL, _operator_pow__doc__},
1278 : :
1279 : : static PyObject *
1280 : : _operator_pow_impl(PyObject *module, PyObject *a, PyObject *b);
1281 : :
1282 : : static PyObject *
1283 : 0 : _operator_pow(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1284 : : {
1285 : 0 : PyObject *return_value = NULL;
1286 : : PyObject *a;
1287 : : PyObject *b;
1288 : :
1289 [ # # # # : 0 : if (!_PyArg_CheckPositional("pow", nargs, 2, 2)) {
# # ]
1290 : 0 : goto exit;
1291 : : }
1292 : 0 : a = args[0];
1293 : 0 : b = args[1];
1294 : 0 : return_value = _operator_pow_impl(module, a, b);
1295 : :
1296 : 0 : exit:
1297 : 0 : return return_value;
1298 : : }
1299 : :
1300 : : PyDoc_STRVAR(_operator_ipow__doc__,
1301 : : "ipow($module, a, b, /)\n"
1302 : : "--\n"
1303 : : "\n"
1304 : : "Same as a **= b.");
1305 : :
1306 : : #define _OPERATOR_IPOW_METHODDEF \
1307 : : {"ipow", _PyCFunction_CAST(_operator_ipow), METH_FASTCALL, _operator_ipow__doc__},
1308 : :
1309 : : static PyObject *
1310 : : _operator_ipow_impl(PyObject *module, PyObject *a, PyObject *b);
1311 : :
1312 : : static PyObject *
1313 : 0 : _operator_ipow(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1314 : : {
1315 : 0 : PyObject *return_value = NULL;
1316 : : PyObject *a;
1317 : : PyObject *b;
1318 : :
1319 [ # # # # : 0 : if (!_PyArg_CheckPositional("ipow", nargs, 2, 2)) {
# # ]
1320 : 0 : goto exit;
1321 : : }
1322 : 0 : a = args[0];
1323 : 0 : b = args[1];
1324 : 0 : return_value = _operator_ipow_impl(module, a, b);
1325 : :
1326 : 0 : exit:
1327 : 0 : return return_value;
1328 : : }
1329 : :
1330 : : PyDoc_STRVAR(_operator_index__doc__,
1331 : : "index($module, a, /)\n"
1332 : : "--\n"
1333 : : "\n"
1334 : : "Same as a.__index__()");
1335 : :
1336 : : #define _OPERATOR_INDEX_METHODDEF \
1337 : : {"index", (PyCFunction)_operator_index, METH_O, _operator_index__doc__},
1338 : :
1339 : : PyDoc_STRVAR(_operator_is___doc__,
1340 : : "is_($module, a, b, /)\n"
1341 : : "--\n"
1342 : : "\n"
1343 : : "Same as a is b.");
1344 : :
1345 : : #define _OPERATOR_IS__METHODDEF \
1346 : : {"is_", _PyCFunction_CAST(_operator_is_), METH_FASTCALL, _operator_is___doc__},
1347 : :
1348 : : static PyObject *
1349 : : _operator_is__impl(PyObject *module, PyObject *a, PyObject *b);
1350 : :
1351 : : static PyObject *
1352 : 0 : _operator_is_(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1353 : : {
1354 : 0 : PyObject *return_value = NULL;
1355 : : PyObject *a;
1356 : : PyObject *b;
1357 : :
1358 [ # # # # : 0 : if (!_PyArg_CheckPositional("is_", nargs, 2, 2)) {
# # ]
1359 : 0 : goto exit;
1360 : : }
1361 : 0 : a = args[0];
1362 : 0 : b = args[1];
1363 : 0 : return_value = _operator_is__impl(module, a, b);
1364 : :
1365 : 0 : exit:
1366 : 0 : return return_value;
1367 : : }
1368 : :
1369 : : PyDoc_STRVAR(_operator_is_not__doc__,
1370 : : "is_not($module, a, b, /)\n"
1371 : : "--\n"
1372 : : "\n"
1373 : : "Same as a is not b.");
1374 : :
1375 : : #define _OPERATOR_IS_NOT_METHODDEF \
1376 : : {"is_not", _PyCFunction_CAST(_operator_is_not), METH_FASTCALL, _operator_is_not__doc__},
1377 : :
1378 : : static PyObject *
1379 : : _operator_is_not_impl(PyObject *module, PyObject *a, PyObject *b);
1380 : :
1381 : : static PyObject *
1382 : 0 : _operator_is_not(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1383 : : {
1384 : 0 : PyObject *return_value = NULL;
1385 : : PyObject *a;
1386 : : PyObject *b;
1387 : :
1388 [ # # # # : 0 : if (!_PyArg_CheckPositional("is_not", nargs, 2, 2)) {
# # ]
1389 : 0 : goto exit;
1390 : : }
1391 : 0 : a = args[0];
1392 : 0 : b = args[1];
1393 : 0 : return_value = _operator_is_not_impl(module, a, b);
1394 : :
1395 : 0 : exit:
1396 : 0 : return return_value;
1397 : : }
1398 : :
1399 : : PyDoc_STRVAR(_operator_length_hint__doc__,
1400 : : "length_hint($module, obj, default=0, /)\n"
1401 : : "--\n"
1402 : : "\n"
1403 : : "Return an estimate of the number of items in obj.\n"
1404 : : "\n"
1405 : : "This is useful for presizing containers when building from an iterable.\n"
1406 : : "\n"
1407 : : "If the object supports len(), the result will be exact.\n"
1408 : : "Otherwise, it may over- or under-estimate by an arbitrary amount.\n"
1409 : : "The result will be an integer >= 0.");
1410 : :
1411 : : #define _OPERATOR_LENGTH_HINT_METHODDEF \
1412 : : {"length_hint", _PyCFunction_CAST(_operator_length_hint), METH_FASTCALL, _operator_length_hint__doc__},
1413 : :
1414 : : static Py_ssize_t
1415 : : _operator_length_hint_impl(PyObject *module, PyObject *obj,
1416 : : Py_ssize_t default_value);
1417 : :
1418 : : static PyObject *
1419 : 0 : _operator_length_hint(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1420 : : {
1421 : 0 : PyObject *return_value = NULL;
1422 : : PyObject *obj;
1423 : 0 : Py_ssize_t default_value = 0;
1424 : : Py_ssize_t _return_value;
1425 : :
1426 [ # # # # : 0 : if (!_PyArg_CheckPositional("length_hint", nargs, 1, 2)) {
# # ]
1427 : 0 : goto exit;
1428 : : }
1429 : 0 : obj = args[0];
1430 [ # # ]: 0 : if (nargs < 2) {
1431 : 0 : goto skip_optional;
1432 : : }
1433 : : {
1434 : 0 : Py_ssize_t ival = -1;
1435 : 0 : PyObject *iobj = _PyNumber_Index(args[1]);
1436 [ # # ]: 0 : if (iobj != NULL) {
1437 : 0 : ival = PyLong_AsSsize_t(iobj);
1438 : 0 : Py_DECREF(iobj);
1439 : : }
1440 [ # # # # ]: 0 : if (ival == -1 && PyErr_Occurred()) {
1441 : 0 : goto exit;
1442 : : }
1443 : 0 : default_value = ival;
1444 : : }
1445 : 0 : skip_optional:
1446 : 0 : _return_value = _operator_length_hint_impl(module, obj, default_value);
1447 [ # # # # ]: 0 : if ((_return_value == -1) && PyErr_Occurred()) {
1448 : 0 : goto exit;
1449 : : }
1450 : 0 : return_value = PyLong_FromSsize_t(_return_value);
1451 : :
1452 : 0 : exit:
1453 : 0 : return return_value;
1454 : : }
1455 : :
1456 : : PyDoc_STRVAR(_operator__compare_digest__doc__,
1457 : : "_compare_digest($module, a, b, /)\n"
1458 : : "--\n"
1459 : : "\n"
1460 : : "Return \'a == b\'.\n"
1461 : : "\n"
1462 : : "This function uses an approach designed to prevent\n"
1463 : : "timing analysis, making it appropriate for cryptography.\n"
1464 : : "\n"
1465 : : "a and b must both be of the same type: either str (ASCII only),\n"
1466 : : "or any bytes-like object.\n"
1467 : : "\n"
1468 : : "Note: If a and b are of different lengths, or if an error occurs,\n"
1469 : : "a timing attack could theoretically reveal information about the\n"
1470 : : "types and lengths of a and b--but not their values.");
1471 : :
1472 : : #define _OPERATOR__COMPARE_DIGEST_METHODDEF \
1473 : : {"_compare_digest", _PyCFunction_CAST(_operator__compare_digest), METH_FASTCALL, _operator__compare_digest__doc__},
1474 : :
1475 : : static PyObject *
1476 : : _operator__compare_digest_impl(PyObject *module, PyObject *a, PyObject *b);
1477 : :
1478 : : static PyObject *
1479 : 0 : _operator__compare_digest(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1480 : : {
1481 : 0 : PyObject *return_value = NULL;
1482 : : PyObject *a;
1483 : : PyObject *b;
1484 : :
1485 [ # # # # : 0 : if (!_PyArg_CheckPositional("_compare_digest", nargs, 2, 2)) {
# # ]
1486 : 0 : goto exit;
1487 : : }
1488 : 0 : a = args[0];
1489 : 0 : b = args[1];
1490 : 0 : return_value = _operator__compare_digest_impl(module, a, b);
1491 : :
1492 : 0 : exit:
1493 : 0 : return return_value;
1494 : : }
1495 : : /*[clinic end generated code: output=227cbcfed44f736e input=a9049054013a1b77]*/
|