Debian Codegraph @

Modules/clinic/mmapmodule.c.h

raw
1 /*[clinic input]
2 preserve
3 [clinic start generated code]*/
4
5 #include "pycore_abstract.h" // _PyNumber_Index()
6 #include "pycore_critical_section.h"// Py_BEGIN_CRITICAL_SECTION()
7 #include "pycore_modsupport.h" // _PyArg_CheckPositional()
8
9 PyDoc_STRVAR(mmap_mmap_close__doc__,
10 "close($self, /)\n"
11 "--\n"
12 "\n");
13
14 #define MMAP_MMAP_CLOSE_METHODDEF \
15 {"close", (PyCFunction)mmap_mmap_close, METH_NOARGS, mmap_mmap_close__doc__},
16
17 static PyObject *
18 mmap_mmap_close_impl(mmap_object *self);
19
20 static PyObject *
21 mmap_mmap_close(PyObject *self, PyObject *Py_UNUSED(ignored))
22 {
23 PyObject *return_value = NULL;
24
25 Py_BEGIN_CRITICAL_SECTION(self);
26 return_value = mmap_mmap_close_impl((mmap_object *)self);
27 Py_END_CRITICAL_SECTION();
28
29 return return_value;
30 }
31
32 PyDoc_STRVAR(mmap_mmap_read_byte__doc__,
33 "read_byte($self, /)\n"
34 "--\n"
35 "\n");
36
37 #define MMAP_MMAP_READ_BYTE_METHODDEF \
38 {"read_byte", (PyCFunction)mmap_mmap_read_byte, METH_NOARGS, mmap_mmap_read_byte__doc__},
39
40 static PyObject *
41 mmap_mmap_read_byte_impl(mmap_object *self);
42
43 static PyObject *
44 mmap_mmap_read_byte(PyObject *self, PyObject *Py_UNUSED(ignored))
45 {
46 PyObject *return_value = NULL;
47
48 Py_BEGIN_CRITICAL_SECTION(self);
49 return_value = mmap_mmap_read_byte_impl((mmap_object *)self);
50 Py_END_CRITICAL_SECTION();
51
52 return return_value;
53 }
54
55 PyDoc_STRVAR(mmap_mmap_readline__doc__,
56 "readline($self, /)\n"
57 "--\n"
58 "\n");
59
60 #define MMAP_MMAP_READLINE_METHODDEF \
61 {"readline", (PyCFunction)mmap_mmap_readline, METH_NOARGS, mmap_mmap_readline__doc__},
62
63 static PyObject *
64 mmap_mmap_readline_impl(mmap_object *self);
65
66 static PyObject *
67 mmap_mmap_readline(PyObject *self, PyObject *Py_UNUSED(ignored))
68 {
69 PyObject *return_value = NULL;
70
71 Py_BEGIN_CRITICAL_SECTION(self);
72 return_value = mmap_mmap_readline_impl((mmap_object *)self);
73 Py_END_CRITICAL_SECTION();
74
75 return return_value;
76 }
77
78 PyDoc_STRVAR(mmap_mmap_read__doc__,
79 "read($self, n=None, /)\n"
80 "--\n"
81 "\n");
82
83 #define MMAP_MMAP_READ_METHODDEF \
84 {"read", _PyCFunction_CAST(mmap_mmap_read), METH_FASTCALL, mmap_mmap_read__doc__},
85
86 static PyObject *
87 mmap_mmap_read_impl(mmap_object *self, Py_ssize_t num_bytes);
88
89 static PyObject *
90 mmap_mmap_read(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
91 {
92 PyObject *return_value = NULL;
93 Py_ssize_t num_bytes = PY_SSIZE_T_MAX;
94
95 if (!_PyArg_CheckPositional("read", nargs, 0, 1)) {
96 goto exit;
97 }
98 if (nargs < 1) {
99 goto skip_optional;
100 }
101 if (!_Py_convert_optional_to_ssize_t(args[0], &num_bytes)) {
102 goto exit;
103 }
104 skip_optional:
105 Py_BEGIN_CRITICAL_SECTION(self);
106 return_value = mmap_mmap_read_impl((mmap_object *)self, num_bytes);
107 Py_END_CRITICAL_SECTION();
108
109 exit:
110 return return_value;
111 }
112
113 PyDoc_STRVAR(mmap_mmap_find__doc__,
114 "find($self, view, start=None, end=None, /)\n"
115 "--\n"
116 "\n");
117
118 #define MMAP_MMAP_FIND_METHODDEF \
119 {"find", _PyCFunction_CAST(mmap_mmap_find), METH_FASTCALL, mmap_mmap_find__doc__},
120
121 static PyObject *
122 mmap_mmap_find_impl(mmap_object *self, Py_buffer *view, PyObject *start,
123 PyObject *end);
124
125 static PyObject *
126 mmap_mmap_find(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
127 {
128 PyObject *return_value = NULL;
129 Py_buffer view = {NULL, NULL};
130 PyObject *start = Py_None;
131 PyObject *end = Py_None;
132
133 if (!_PyArg_CheckPositional("find", nargs, 1, 3)) {
134 goto exit;
135 }
136 if (PyObject_GetBuffer(args[0], &view, PyBUF_SIMPLE) != 0) {
137 goto exit;
138 }
139 if (nargs < 2) {
140 goto skip_optional;
141 }
142 start = args[1];
143 if (nargs < 3) {
144 goto skip_optional;
145 }
146 end = args[2];
147 skip_optional:
148 Py_BEGIN_CRITICAL_SECTION(self);
149 return_value = mmap_mmap_find_impl((mmap_object *)self, &view, start, end);
150 Py_END_CRITICAL_SECTION();
151
152 exit:
153 /* Cleanup for view */
154 if (view.obj) {
155 PyBuffer_Release(&view);
156 }
157
158 return return_value;
159 }
160
161 PyDoc_STRVAR(mmap_mmap_rfind__doc__,
162 "rfind($self, view, start=None, end=None, /)\n"
163 "--\n"
164 "\n");
165
166 #define MMAP_MMAP_RFIND_METHODDEF \
167 {"rfind", _PyCFunction_CAST(mmap_mmap_rfind), METH_FASTCALL, mmap_mmap_rfind__doc__},
168
169 static PyObject *
170 mmap_mmap_rfind_impl(mmap_object *self, Py_buffer *view, PyObject *start,
171 PyObject *end);
172
173 static PyObject *
174 mmap_mmap_rfind(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
175 {
176 PyObject *return_value = NULL;
177 Py_buffer view = {NULL, NULL};
178 PyObject *start = Py_None;
179 PyObject *end = Py_None;
180
181 if (!_PyArg_CheckPositional("rfind", nargs, 1, 3)) {
182 goto exit;
183 }
184 if (PyObject_GetBuffer(args[0], &view, PyBUF_SIMPLE) != 0) {
185 goto exit;
186 }
187 if (nargs < 2) {
188 goto skip_optional;
189 }
190 start = args[1];
191 if (nargs < 3) {
192 goto skip_optional;
193 }
194 end = args[2];
195 skip_optional:
196 Py_BEGIN_CRITICAL_SECTION(self);
197 return_value = mmap_mmap_rfind_impl((mmap_object *)self, &view, start, end);
198 Py_END_CRITICAL_SECTION();
199
200 exit:
201 /* Cleanup for view */
202 if (view.obj) {
203 PyBuffer_Release(&view);
204 }
205
206 return return_value;
207 }
208
209 PyDoc_STRVAR(mmap_mmap_write__doc__,
210 "write($self, bytes, /)\n"
211 "--\n"
212 "\n");
213
214 #define MMAP_MMAP_WRITE_METHODDEF \
215 {"write", (PyCFunction)mmap_mmap_write, METH_O, mmap_mmap_write__doc__},
216
217 static PyObject *
218 mmap_mmap_write_impl(mmap_object *self, Py_buffer *data);
219
220 static PyObject *
221 mmap_mmap_write(PyObject *self, PyObject *arg)
222 {
223 PyObject *return_value = NULL;
224 Py_buffer data = {NULL, NULL};
225
226 if (PyObject_GetBuffer(arg, &data, PyBUF_SIMPLE) != 0) {
227 goto exit;
228 }
229 Py_BEGIN_CRITICAL_SECTION(self);
230 return_value = mmap_mmap_write_impl((mmap_object *)self, &data);
231 Py_END_CRITICAL_SECTION();
232
233 exit:
234 /* Cleanup for data */
235 if (data.obj) {
236 PyBuffer_Release(&data);
237 }
238
239 return return_value;
240 }
241
242 PyDoc_STRVAR(mmap_mmap_write_byte__doc__,
243 "write_byte($self, byte, /)\n"
244 "--\n"
245 "\n");
246
247 #define MMAP_MMAP_WRITE_BYTE_METHODDEF \
248 {"write_byte", (PyCFunction)mmap_mmap_write_byte, METH_O, mmap_mmap_write_byte__doc__},
249
250 static PyObject *
251 mmap_mmap_write_byte_impl(mmap_object *self, unsigned char value);
252
253 static PyObject *
254 mmap_mmap_write_byte(PyObject *self, PyObject *arg)
255 {
256 PyObject *return_value = NULL;
257 unsigned char value;
258
259 {
260 long ival = PyLong_AsLong(arg);
261 if (ival == -1 && PyErr_Occurred()) {
262 goto exit;
263 }
264 else if (ival < 0) {
265 PyErr_SetString(PyExc_OverflowError,
266 "unsigned byte integer is less than minimum");
267 goto exit;
268 }
269 else if (ival > UCHAR_MAX) {
270 PyErr_SetString(PyExc_OverflowError,
271 "unsigned byte integer is greater than maximum");
272 goto exit;
273 }
274 else {
275 value = (unsigned char) ival;
276 }
277 }
278 Py_BEGIN_CRITICAL_SECTION(self);
279 return_value = mmap_mmap_write_byte_impl((mmap_object *)self, value);
280 Py_END_CRITICAL_SECTION();
281
282 exit:
283 return return_value;
284 }
285
286 PyDoc_STRVAR(mmap_mmap_size__doc__,
287 "size($self, /)\n"
288 "--\n"
289 "\n");
290
291 #define MMAP_MMAP_SIZE_METHODDEF \
292 {"size", (PyCFunction)mmap_mmap_size, METH_NOARGS, mmap_mmap_size__doc__},
293
294 static PyObject *
295 mmap_mmap_size_impl(mmap_object *self);
296
297 static PyObject *
298 mmap_mmap_size(PyObject *self, PyObject *Py_UNUSED(ignored))
299 {
300 PyObject *return_value = NULL;
301
302 Py_BEGIN_CRITICAL_SECTION(self);
303 return_value = mmap_mmap_size_impl((mmap_object *)self);
304 Py_END_CRITICAL_SECTION();
305
306 return return_value;
307 }
308
309 PyDoc_STRVAR(mmap_mmap_resize__doc__,
310 "resize($self, newsize, /)\n"
311 "--\n"
312 "\n");
313
314 #define MMAP_MMAP_RESIZE_METHODDEF \
315 {"resize", (PyCFunction)mmap_mmap_resize, METH_O, mmap_mmap_resize__doc__},
316
317 static PyObject *
318 mmap_mmap_resize_impl(mmap_object *self, Py_ssize_t new_size);
319
320 static PyObject *
321 mmap_mmap_resize(PyObject *self, PyObject *arg)
322 {
323 PyObject *return_value = NULL;
324 Py_ssize_t new_size;
325
326 {
327 Py_ssize_t ival = -1;
328 PyObject *iobj = _PyNumber_Index(arg);
329 if (iobj != NULL) {
330 ival = PyLong_AsSsize_t(iobj);
331 Py_DECREF(iobj);
332 }
333 if (ival == -1 && PyErr_Occurred()) {
334 goto exit;
335 }
336 new_size = ival;
337 }
338 Py_BEGIN_CRITICAL_SECTION(self);
339 return_value = mmap_mmap_resize_impl((mmap_object *)self, new_size);
340 Py_END_CRITICAL_SECTION();
341
342 exit:
343 return return_value;
344 }
345
346 PyDoc_STRVAR(mmap_mmap_tell__doc__,
347 "tell($self, /)\n"
348 "--\n"
349 "\n");
350
351 #define MMAP_MMAP_TELL_METHODDEF \
352 {"tell", (PyCFunction)mmap_mmap_tell, METH_NOARGS, mmap_mmap_tell__doc__},
353
354 static PyObject *
355 mmap_mmap_tell_impl(mmap_object *self);
356
357 static PyObject *
358 mmap_mmap_tell(PyObject *self, PyObject *Py_UNUSED(ignored))
359 {
360 PyObject *return_value = NULL;
361
362 Py_BEGIN_CRITICAL_SECTION(self);
363 return_value = mmap_mmap_tell_impl((mmap_object *)self);
364 Py_END_CRITICAL_SECTION();
365
366 return return_value;
367 }
368
369 PyDoc_STRVAR(mmap_mmap_flush__doc__,
370 "flush($self, offset=0, size=None, /)\n"
371 "--\n"
372 "\n");
373
374 #define MMAP_MMAP_FLUSH_METHODDEF \
375 {"flush", _PyCFunction_CAST(mmap_mmap_flush), METH_FASTCALL, mmap_mmap_flush__doc__},
376
377 static PyObject *
378 mmap_mmap_flush_impl(mmap_object *self, Py_ssize_t offset,
379 PyObject *size_obj);
380
381 static PyObject *
382 mmap_mmap_flush(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
383 {
384 PyObject *return_value = NULL;
385 Py_ssize_t offset = 0;
386 PyObject *size_obj = Py_None;
387
388 if (!_PyArg_CheckPositional("flush", nargs, 0, 2)) {
389 goto exit;
390 }
391 if (nargs < 1) {
392 goto skip_optional;
393 }
394 {
395 Py_ssize_t ival = -1;
396 PyObject *iobj = _PyNumber_Index(args[0]);
397 if (iobj != NULL) {
398 ival = PyLong_AsSsize_t(iobj);
399 Py_DECREF(iobj);
400 }
401 if (ival == -1 && PyErr_Occurred()) {
402 goto exit;
403 }
404 offset = ival;
405 }
406 if (nargs < 2) {
407 goto skip_optional;
408 }
409 size_obj = args[1];
410 skip_optional:
411 Py_BEGIN_CRITICAL_SECTION(self);
412 return_value = mmap_mmap_flush_impl((mmap_object *)self, offset, size_obj);
413 Py_END_CRITICAL_SECTION();
414
415 exit:
416 return return_value;
417 }
418
419 PyDoc_STRVAR(mmap_mmap_seek__doc__,
420 "seek($self, pos, whence=0, /)\n"
421 "--\n"
422 "\n");
423
424 #define MMAP_MMAP_SEEK_METHODDEF \
425 {"seek", _PyCFunction_CAST(mmap_mmap_seek), METH_FASTCALL, mmap_mmap_seek__doc__},
426
427 static PyObject *
428 mmap_mmap_seek_impl(mmap_object *self, Py_ssize_t dist, int how);
429
430 static PyObject *
431 mmap_mmap_seek(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
432 {
433 PyObject *return_value = NULL;
434 Py_ssize_t dist;
435 int how = 0;
436
437 if (!_PyArg_CheckPositional("seek", nargs, 1, 2)) {
438 goto exit;
439 }
440 {
441 Py_ssize_t ival = -1;
442 PyObject *iobj = _PyNumber_Index(args[0]);
443 if (iobj != NULL) {
444 ival = PyLong_AsSsize_t(iobj);
445 Py_DECREF(iobj);
446 }
447 if (ival == -1 && PyErr_Occurred()) {
448 goto exit;
449 }
450 dist = ival;
451 }
452 if (nargs < 2) {
453 goto skip_optional;
454 }
455 how = PyLong_AsInt(args[1]);
456 if (how == -1 && PyErr_Occurred()) {
457 goto exit;
458 }
459 skip_optional:
460 Py_BEGIN_CRITICAL_SECTION(self);
461 return_value = mmap_mmap_seek_impl((mmap_object *)self, dist, how);
462 Py_END_CRITICAL_SECTION();
463
464 exit:
465 return return_value;
466 }
467
468 PyDoc_STRVAR(mmap_mmap_seekable__doc__,
469 "seekable($self, /)\n"
470 "--\n"
471 "\n");
472
473 #define MMAP_MMAP_SEEKABLE_METHODDEF \
474 {"seekable", (PyCFunction)mmap_mmap_seekable, METH_NOARGS, mmap_mmap_seekable__doc__},
475
476 static PyObject *
477 mmap_mmap_seekable_impl(mmap_object *self);
478
479 static PyObject *
480 mmap_mmap_seekable(PyObject *self, PyObject *Py_UNUSED(ignored))
481 {
482 return mmap_mmap_seekable_impl((mmap_object *)self);
483 }
484
485 PyDoc_STRVAR(mmap_mmap_move__doc__,
486 "move($self, dest, src, count, /)\n"
487 "--\n"
488 "\n");
489
490 #define MMAP_MMAP_MOVE_METHODDEF \
491 {"move", _PyCFunction_CAST(mmap_mmap_move), METH_FASTCALL, mmap_mmap_move__doc__},
492
493 static PyObject *
494 mmap_mmap_move_impl(mmap_object *self, Py_ssize_t dest, Py_ssize_t src,
495 Py_ssize_t cnt);
496
497 static PyObject *
498 mmap_mmap_move(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
499 {
500 PyObject *return_value = NULL;
501 Py_ssize_t dest;
502 Py_ssize_t src;
503 Py_ssize_t cnt;
504
505 if (!_PyArg_CheckPositional("move", nargs, 3, 3)) {
506 goto exit;
507 }
508 {
509 Py_ssize_t ival = -1;
510 PyObject *iobj = _PyNumber_Index(args[0]);
511 if (iobj != NULL) {
512 ival = PyLong_AsSsize_t(iobj);
513 Py_DECREF(iobj);
514 }
515 if (ival == -1 && PyErr_Occurred()) {
516 goto exit;
517 }
518 dest = ival;
519 }
520 {
521 Py_ssize_t ival = -1;
522 PyObject *iobj = _PyNumber_Index(args[1]);
523 if (iobj != NULL) {
524 ival = PyLong_AsSsize_t(iobj);
525 Py_DECREF(iobj);
526 }
527 if (ival == -1 && PyErr_Occurred()) {
528 goto exit;
529 }
530 src = ival;
531 }
532 {
533 Py_ssize_t ival = -1;
534 PyObject *iobj = _PyNumber_Index(args[2]);
535 if (iobj != NULL) {
536 ival = PyLong_AsSsize_t(iobj);
537 Py_DECREF(iobj);
538 }
539 if (ival == -1 && PyErr_Occurred()) {
540 goto exit;
541 }
542 cnt = ival;
543 }
544 Py_BEGIN_CRITICAL_SECTION(self);
545 return_value = mmap_mmap_move_impl((mmap_object *)self, dest, src, cnt);
546 Py_END_CRITICAL_SECTION();
547
548 exit:
549 return return_value;
550 }
551
552 PyDoc_STRVAR(mmap_mmap___enter____doc__,
553 "__enter__($self, /)\n"
554 "--\n"
555 "\n");
556
557 #define MMAP_MMAP___ENTER___METHODDEF \
558 {"__enter__", (PyCFunction)mmap_mmap___enter__, METH_NOARGS, mmap_mmap___enter____doc__},
559
560 static PyObject *
561 mmap_mmap___enter___impl(mmap_object *self);
562
563 static PyObject *
564 mmap_mmap___enter__(PyObject *self, PyObject *Py_UNUSED(ignored))
565 {
566 PyObject *return_value = NULL;
567
568 Py_BEGIN_CRITICAL_SECTION(self);
569 return_value = mmap_mmap___enter___impl((mmap_object *)self);
570 Py_END_CRITICAL_SECTION();
571
572 return return_value;
573 }
574
575 PyDoc_STRVAR(mmap_mmap___exit____doc__,
576 "__exit__($self, exc_type, exc_value, traceback, /)\n"
577 "--\n"
578 "\n");
579
580 #define MMAP_MMAP___EXIT___METHODDEF \
581 {"__exit__", _PyCFunction_CAST(mmap_mmap___exit__), METH_FASTCALL, mmap_mmap___exit____doc__},
582
583 static PyObject *
584 mmap_mmap___exit___impl(mmap_object *self, PyObject *exc_type,
585 PyObject *exc_value, PyObject *traceback);
586
587 static PyObject *
588 mmap_mmap___exit__(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
589 {
590 PyObject *return_value = NULL;
591 PyObject *exc_type;
592 PyObject *exc_value;
593 PyObject *traceback;
594
595 if (!_PyArg_CheckPositional("__exit__", nargs, 3, 3)) {
596 goto exit;
597 }
598 exc_type = args[0];
599 exc_value = args[1];
600 traceback = args[2];
601 Py_BEGIN_CRITICAL_SECTION(self);
602 return_value = mmap_mmap___exit___impl((mmap_object *)self, exc_type, exc_value, traceback);
603 Py_END_CRITICAL_SECTION();
604
605 exit:
606 return return_value;
607 }
608
609 #if defined(MS_WINDOWS)
610
611 PyDoc_STRVAR(mmap_mmap___sizeof____doc__,
612 "__sizeof__($self, /)\n"
613 "--\n"
614 "\n");
615
616 #define MMAP_MMAP___SIZEOF___METHODDEF \
617 {"__sizeof__", (PyCFunction)mmap_mmap___sizeof__, METH_NOARGS, mmap_mmap___sizeof____doc__},
618
619 static PyObject *
620 mmap_mmap___sizeof___impl(mmap_object *self);
621
622 static PyObject *
623 mmap_mmap___sizeof__(PyObject *self, PyObject *Py_UNUSED(ignored))
624 {
625 PyObject *return_value = NULL;
626
627 Py_BEGIN_CRITICAL_SECTION(self);
628 return_value = mmap_mmap___sizeof___impl((mmap_object *)self);
629 Py_END_CRITICAL_SECTION();
630
631 return return_value;
632 }
633
634 #endif /* defined(MS_WINDOWS) */
635
636 #if (defined(MS_WINDOWS) && defined(Py_DEBUG))
637
638 PyDoc_STRVAR(mmap_mmap__protect__doc__,
639 "_protect($self, flNewProtect, start, length, /)\n"
640 "--\n"
641 "\n");
642
643 #define MMAP_MMAP__PROTECT_METHODDEF \
644 {"_protect", _PyCFunction_CAST(mmap_mmap__protect), METH_FASTCALL, mmap_mmap__protect__doc__},
645
646 static PyObject *
647 mmap_mmap__protect_impl(mmap_object *self, unsigned int flNewProtect,
648 Py_ssize_t start, Py_ssize_t length);
649
650 static PyObject *
651 mmap_mmap__protect(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
652 {
653 PyObject *return_value = NULL;
654 unsigned int flNewProtect;
655 Py_ssize_t start;
656 Py_ssize_t length;
657
658 if (!_PyArg_CheckPositional("_protect", nargs, 3, 3)) {
659 goto exit;
660 }
661 flNewProtect = (unsigned int)PyLong_AsUnsignedLongMask(args[0]);
662 if (flNewProtect == (unsigned int)-1 && PyErr_Occurred()) {
663 goto exit;
664 }
665 {
666 Py_ssize_t ival = -1;
667 PyObject *iobj = _PyNumber_Index(args[1]);
668 if (iobj != NULL) {
669 ival = PyLong_AsSsize_t(iobj);
670 Py_DECREF(iobj);
671 }
672 if (ival == -1 && PyErr_Occurred()) {
673 goto exit;
674 }
675 start = ival;
676 }
677 {
678 Py_ssize_t ival = -1;
679 PyObject *iobj = _PyNumber_Index(args[2]);
680 if (iobj != NULL) {
681 ival = PyLong_AsSsize_t(iobj);
682 Py_DECREF(iobj);
683 }
684 if (ival == -1 && PyErr_Occurred()) {
685 goto exit;
686 }
687 length = ival;
688 }
689 Py_BEGIN_CRITICAL_SECTION(self);
690 return_value = mmap_mmap__protect_impl((mmap_object *)self, flNewProtect, start, length);
691 Py_END_CRITICAL_SECTION();
692
693 exit:
694 return return_value;
695 }
696
697 #endif /* (defined(MS_WINDOWS) && defined(Py_DEBUG)) */
698
699 #if defined(HAVE_MADVISE)
700
701 PyDoc_STRVAR(mmap_mmap_madvise__doc__,
702 "madvise($self, option, start=0, length=None, /)\n"
703 "--\n"
704 "\n");
705
706 #define MMAP_MMAP_MADVISE_METHODDEF \
707 {"madvise", _PyCFunction_CAST(mmap_mmap_madvise), METH_FASTCALL, mmap_mmap_madvise__doc__},
708
709 static PyObject *
710 mmap_mmap_madvise_impl(mmap_object *self, int option, Py_ssize_t start,
711 PyObject *length_obj);
712
713 static PyObject *
714 mmap_mmap_madvise(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
715 {
716 PyObject *return_value = NULL;
717 int option;
718 Py_ssize_t start = 0;
719 PyObject *length_obj = Py_None;
720
721 if (!_PyArg_CheckPositional("madvise", nargs, 1, 3)) {
722 goto exit;
723 }
724 option = PyLong_AsInt(args[0]);
725 if (option == -1 && PyErr_Occurred()) {
726 goto exit;
727 }
728 if (nargs < 2) {
729 goto skip_optional;
730 }
731 {
732 Py_ssize_t ival = -1;
733 PyObject *iobj = _PyNumber_Index(args[1]);
734 if (iobj != NULL) {
735 ival = PyLong_AsSsize_t(iobj);
736 Py_DECREF(iobj);
737 }
738 if (ival == -1 && PyErr_Occurred()) {
739 goto exit;
740 }
741 start = ival;
742 }
743 if (nargs < 3) {
744 goto skip_optional;
745 }
746 length_obj = args[2];
747 skip_optional:
748 Py_BEGIN_CRITICAL_SECTION(self);
749 return_value = mmap_mmap_madvise_impl((mmap_object *)self, option, start, length_obj);
750 Py_END_CRITICAL_SECTION();
751
752 exit:
753 return return_value;
754 }
755
756 #endif /* defined(HAVE_MADVISE) */
757
758 #ifndef MMAP_MMAP___SIZEOF___METHODDEF
759 #define MMAP_MMAP___SIZEOF___METHODDEF
760 #endif /* !defined(MMAP_MMAP___SIZEOF___METHODDEF) */
761
762 #ifndef MMAP_MMAP__PROTECT_METHODDEF
763 #define MMAP_MMAP__PROTECT_METHODDEF
764 #endif /* !defined(MMAP_MMAP__PROTECT_METHODDEF) */
765
766 #ifndef MMAP_MMAP_MADVISE_METHODDEF
767 #define MMAP_MMAP_MADVISE_METHODDEF
768 #endif /* !defined(MMAP_MMAP_MADVISE_METHODDEF) */
769 /*[clinic end generated code: output=fe4e2131abc1e971 input=a9049054013a1b77]*/