Debian Codegraph @

Modules/_io/_iomodule.c

raw
1 /*
2 An implementation of the new I/O lib as defined by PEP 3116 - "New I/O"
3
4 Classes defined here: UnsupportedOperation, BlockingIOError.
5 Functions defined here: open().
6
7 Mostly written by Amaury Forgeot d'Arc
8 */
9
10 #include "Python.h"
11 #include "pycore_abstract.h" // _PyNumber_Index()
12 #include "pycore_interp.h" // _PyInterpreterState_GetConfig()
13 #include "pycore_long.h" // _PyLong_IsNegative()
14 #include "pycore_pyerrors.h" // _PyErr_ChainExceptions1()
15 #include "pycore_pystate.h" // _PyInterpreterState_GET()
16
17 #include "_iomodule.h"
18
19 #ifdef HAVE_SYS_TYPES_H
20 #include <sys/types.h>
21 #endif /* HAVE_SYS_TYPES_H */
22
23 #ifdef HAVE_SYS_STAT_H
24 #include <sys/stat.h>
25 #endif /* HAVE_SYS_STAT_H */
26
27 #ifdef MS_WINDOWS
28 #include <windows.h>
29 #endif
30
31 PyDoc_STRVAR(module_doc,
32 "The io module provides the Python interfaces to stream handling. The\n"
33 "builtin open function is defined in this module.\n"
34 "\n"
35 "At the top of the I/O hierarchy is the abstract base class IOBase. It\n"
36 "defines the basic interface to a stream. Note, however, that there is no\n"
37 "separation between reading and writing to streams; implementations are\n"
38 "allowed to raise an OSError if they do not support a given operation.\n"
39 "\n"
40 "Extending IOBase is RawIOBase which deals simply with the reading and\n"
41 "writing of raw bytes to a stream. FileIO subclasses RawIOBase to provide\n"
42 "an interface to OS files.\n"
43 "\n"
44 "BufferedIOBase deals with buffering on a raw byte stream (RawIOBase). Its\n"
45 "subclasses, BufferedWriter, BufferedReader, and BufferedRWPair buffer\n"
46 "streams that are readable, writable, and both respectively.\n"
47 "BufferedRandom provides a buffered interface to random access\n"
48 "streams. BytesIO is a simple stream of in-memory bytes.\n"
49 "\n"
50 "Another IOBase subclass, TextIOBase, deals with the encoding and decoding\n"
51 "of streams into text. TextIOWrapper, which extends it, is a buffered text\n"
52 "interface to a buffered raw stream (`BufferedIOBase`). Finally, StringIO\n"
53 "is an in-memory stream for text.\n"
54 "\n"
55 "Argument names are not part of the specification, and only the arguments\n"
56 "of open() are intended to be used as keyword arguments.\n"
57 "\n"
58 "data:\n"
59 "\n"
60 "DEFAULT_BUFFER_SIZE\n"
61 "\n"
62 " An int containing the default buffer size used by the module's buffered\n"
63 " I/O classes.\n"
64 );
65
66
67 /*
68 * The main open() function
69 */
70 /*[clinic input]
71 module _io
72
73 _io.open
74 file: object
75 mode: str = "r"
76 buffering: int = -1
77 encoding: str(accept={str, NoneType}) = None
78 errors: str(accept={str, NoneType}) = None
79 newline: str(accept={str, NoneType}) = None
80 closefd: bool = True
81 opener: object = None
82
83 Open file and return a stream. Raise OSError upon failure.
84
85 file is either a text or byte string giving the name (and the path
86 if the file isn't in the current working directory) of the file to
87 be opened or an integer file descriptor of the file to be
88 wrapped. (If a file descriptor is given, it is closed when the
89 returned I/O object is closed, unless closefd is set to False.)
90
91 mode is an optional string that specifies the mode in which the file
92 is opened. It defaults to 'r' which means open for reading in text
93 mode. Other common values are 'w' for writing (truncating the file if
94 it already exists), 'x' for creating and writing to a new file, and
95 'a' for appending (which on some Unix systems, means that all writes
96 append to the end of the file regardless of the current seek position).
97 In text mode, if encoding is not specified the encoding used is platform
98 dependent: locale.getencoding() is called to get the current locale
99 encoding. (For reading and writing raw bytes use binary mode and leave
100 encoding unspecified.) The available modes are:
101
102 ========= ==========================================================
103 Character Meaning
104 --------- ----------------------------------------------------------
105 'r' open for reading (default)
106 'w' open for writing, truncating the file first
107 'x' create a new file and open it for writing
108 'a' open for writing, appending to the end of the file if it
109 exists
110 'b' binary mode
111 't' text mode (default)
112 '+' open a disk file for updating (reading and writing)
113 ========= ==========================================================
114
115 The default mode is 'rt' (open for reading text). For binary random
116 access, the mode 'w+b' opens and truncates the file to 0 bytes, while
117 'r+b' opens the file without truncation. The 'x' mode implies 'w' and
118 raises an `FileExistsError` if the file already exists.
119
120 Python distinguishes between files opened in binary and text modes,
121 even when the underlying operating system doesn't. Files opened in
122 binary mode (appending 'b' to the mode argument) return contents as
123 bytes objects without any decoding. In text mode (the default, or when
124 't' is appended to the mode argument), the contents of the file are
125 returned as strings, the bytes having been first decoded using a
126 platform-dependent encoding or using the specified encoding if given.
127
128 buffering is an optional integer used to set the buffering policy.
129 Pass 0 to switch buffering off (only allowed in binary mode), 1 to
130 select line buffering (only usable in text mode), and an integer > 1 to
131 indicate the size of a fixed-size chunk buffer. When no buffering
132 argument is given, the default buffering policy works as follows:
133
134 * Binary files are buffered in fixed-size chunks; the size of the buffer
135 is max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE) when the device
136 block size is available.
137 On most systems, the buffer will typically be 128 kilobytes long.
138
139 * "Interactive" text files (files for which isatty() returns True)
140 use line buffering. Other text files use the policy described above
141 for binary files.
142
143 encoding is the name of the encoding used to decode or encode the
144 file. This should only be used in text mode. The default encoding is
145 platform dependent, but any encoding supported by Python can be
146 passed. See the codecs module for the list of supported encodings.
147
148 errors is an optional string that specifies how encoding errors are to
149 be handled---this argument should not be used in binary mode. Pass
150 'strict' to raise a ValueError exception if there is an encoding error
151 (the default of None has the same effect), or pass 'ignore' to ignore
152 errors. (Note that ignoring encoding errors can lead to data loss.)
153 See the documentation for codecs.register or run 'help(codecs.Codec)'
154 for a list of the permitted encoding error strings.
155
156 newline controls how universal newlines works (it only applies to text
157 mode). It can be None, '', '\n', '\r', and '\r\n'. It works as
158 follows:
159
160 * On input, if newline is None, universal newlines mode is enabled.
161 Lines in the input can end in '\n', '\r', or '\r\n', and these are
162 translated into '\n' before being returned to the caller. If it is
163 '', universal newline mode is enabled, but line endings are returned
164 to the caller untranslated. If it has any of the other legal values,
165 input lines are only terminated by the given string, and the line
166 ending is returned to the caller untranslated.
167
168 * On output, if newline is None, any '\n' characters written are
169 translated to the system default line separator, os.linesep. If
170 newline is '' or '\n', no translation takes place. If newline is any
171 of the other legal values, any '\n' characters written are translated
172 to the given string.
173
174 If closefd is False, the underlying file descriptor will be kept open
175 when the file is closed. This does not work when a file name is given
176 and must be True in that case.
177
178 A custom opener can be used by passing a callable as *opener*. The
179 underlying file descriptor for the file object is then obtained by
180 calling *opener* with (*file*, *flags*). *opener* must return an open
181 file descriptor (passing os.open as *opener* results in functionality
182 similar to passing None).
183
184 open() returns a file object whose type depends on the mode, and
185 through which the standard file operations such as reading and writing
186 are performed. When open() is used to open a file in a text mode ('w',
187 'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open
188 a file in a binary mode, the returned class varies: in read binary
189 mode, it returns a BufferedReader; in write binary and append binary
190 modes, it returns a BufferedWriter, and in read/write mode, it returns
191 a BufferedRandom.
192
193 It is also possible to use a string or bytearray as a file for both
194 reading and writing. For strings StringIO can be used like a file
195 opened in a text mode, and for bytes a BytesIO can be used like a file
196 opened in a binary mode.
197 [clinic start generated code]*/
198
199 static PyObject *
200 _io_open_impl(PyObject *module, PyObject *file, const char *mode,
201 int buffering, const char *encoding, const char *errors,
202 const char *newline, int closefd, PyObject *opener)
203 /*[clinic end generated code: output=aefafc4ce2b46dc0 input=b3cefa70bef404b3]*/
204 {
205 size_t i;
206
207 int creating = 0, reading = 0, writing = 0, appending = 0, updating = 0;
208 int text = 0, binary = 0;
209
210 char rawmode[6], *m;
211 int line_buffering, is_number, isatty = 0;
212
213 PyObject *raw, *modeobj = NULL, *buffer, *wrapper, *result = NULL, *path_or_fd = NULL;
214
215 is_number = PyNumber_Check(file);
216
217 if (is_number) {
218 path_or_fd = Py_NewRef(file);
219 } else {
220 path_or_fd = PyOS_FSPath(file);
221 if (path_or_fd == NULL) {
222 return NULL;
223 }
224 }
225
226 if (!is_number &&
227 !PyUnicode_Check(path_or_fd) &&
228 !PyBytes_Check(path_or_fd)) {
229 PyErr_Format(PyExc_TypeError, "invalid file: %R", file);
230 goto error;
231 }
232
233 /* Decode mode */
234 for (i = 0; i < strlen(mode); i++) {
235 char c = mode[i];
236
237 switch (c) {
238 case 'x':
239 creating = 1;
240 break;
241 case 'r':
242 reading = 1;
243 break;
244 case 'w':
245 writing = 1;
246 break;
247 case 'a':
248 appending = 1;
249 break;
250 case '+':
251 updating = 1;
252 break;
253 case 't':
254 text = 1;
255 break;
256 case 'b':
257 binary = 1;
258 break;
259 default:
260 goto invalid_mode;
261 }
262
263 /* c must not be duplicated */
264 if (strchr(mode+i+1, c)) {
265 invalid_mode:
266 PyErr_Format(PyExc_ValueError, "invalid mode: '%s'", mode);
267 goto error;
268 }
269
270 }
271
272 m = rawmode;
273 if (creating) *(m++) = 'x';
274 if (reading) *(m++) = 'r';
275 if (writing) *(m++) = 'w';
276 if (appending) *(m++) = 'a';
277 if (updating) *(m++) = '+';
278 *m = '\0';
279
280 /* Parameters validation */
281 if (text && binary) {
282 PyErr_SetString(PyExc_ValueError,
283 "can't have text and binary mode at once");
284 goto error;
285 }
286
287 if (creating + reading + writing + appending > 1) {
288 PyErr_SetString(PyExc_ValueError,
289 "must have exactly one of create/read/write/append mode");
290 goto error;
291 }
292
293 if (binary && encoding != NULL) {
294 PyErr_SetString(PyExc_ValueError,
295 "binary mode doesn't take an encoding argument");
296 goto error;
297 }
298
299 if (binary && errors != NULL) {
300 PyErr_SetString(PyExc_ValueError,
301 "binary mode doesn't take an errors argument");
302 goto error;
303 }
304
305 if (binary && newline != NULL) {
306 PyErr_SetString(PyExc_ValueError,
307 "binary mode doesn't take a newline argument");
308 goto error;
309 }
310
311 if (binary && buffering == 1) {
312 if (PyErr_WarnEx(PyExc_RuntimeWarning,
313 "line buffering (buffering=1) isn't supported in "
314 "binary mode, the default buffer size will be used",
315 1) < 0) {
316 goto error;
317 }
318 }
319
320 /* Create the Raw file stream */
321 _PyIO_State *state = get_io_state(module);
322 {
323 PyObject *RawIO_class = (PyObject *)state->PyFileIO_Type;
324 #ifdef HAVE_WINDOWS_CONSOLE_IO
325 const PyConfig *config = _Py_GetConfig();
326 if (!config->legacy_windows_stdio && _PyIO_get_console_type(path_or_fd) != '\0') {
327 RawIO_class = (PyObject *)state->PyWindowsConsoleIO_Type;
328 encoding = "utf-8";
329 }
330 #endif
331 raw = PyObject_CallFunction(RawIO_class, "OsOO",
332 path_or_fd, rawmode,
333 closefd ? Py_True : Py_False,
334 opener);
335 }
336
337 if (raw == NULL)
338 goto error;
339 result = raw;
340
341 Py_SETREF(path_or_fd, NULL);
342
343 modeobj = PyUnicode_FromString(mode);
344 if (modeobj == NULL)
345 goto error;
346
347 /* buffering */
348 if (buffering < 0) {
349 PyObject *res = PyObject_CallMethodNoArgs(raw, &_Py_ID(_isatty_open_only));
350 if (res == NULL)
351 goto error;
352 isatty = PyObject_IsTrue(res);
353 Py_DECREF(res);
354 if (isatty < 0)
355 goto error;
356 }
357
358 if (buffering == 1 || isatty) {
359 buffering = -1;
360 line_buffering = 1;
361 }
362 else
363 line_buffering = 0;
364
365 if (buffering < 0) {
366 PyObject *blksize_obj;
367 blksize_obj = PyObject_GetAttr(raw, &_Py_ID(_blksize));
368 if (blksize_obj == NULL)
369 goto error;
370 buffering = PyLong_AsLong(blksize_obj);
371 Py_DECREF(blksize_obj);
372 if (buffering == -1 && PyErr_Occurred())
373 goto error;
374 buffering = Py_MAX(Py_MIN(buffering, 8192 * 1024), DEFAULT_BUFFER_SIZE);
375 }
376 if (buffering < 0) {
377 PyErr_SetString(PyExc_ValueError,
378 "invalid buffering size");
379 goto error;
380 }
381
382 /* if not buffering, returns the raw file object */
383 if (buffering == 0) {
384 if (!binary) {
385 PyErr_SetString(PyExc_ValueError,
386 "can't have unbuffered text I/O");
387 goto error;
388 }
389
390 Py_DECREF(modeobj);
391 return result;
392 }
393
394 /* wraps into a buffered file */
395 {
396 PyObject *Buffered_class;
397
398 if (updating) {
399 Buffered_class = (PyObject *)state->PyBufferedRandom_Type;
400 }
401 else if (creating || writing || appending) {
402 Buffered_class = (PyObject *)state->PyBufferedWriter_Type;
403 }
404 else if (reading) {
405 Buffered_class = (PyObject *)state->PyBufferedReader_Type;
406 }
407 else {
408 PyErr_Format(PyExc_ValueError,
409 "unknown mode: '%s'", mode);
410 goto error;
411 }
412
413 buffer = PyObject_CallFunction(Buffered_class, "Oi", raw, buffering);
414 }
415 if (buffer == NULL)
416 goto error;
417 result = buffer;
418 Py_DECREF(raw);
419
420
421 /* if binary, returns the buffered file */
422 if (binary) {
423 Py_DECREF(modeobj);
424 return result;
425 }
426
427 /* wraps into a TextIOWrapper */
428 wrapper = PyObject_CallFunction((PyObject *)state->PyTextIOWrapper_Type,
429 "OsssO",
430 buffer,
431 encoding, errors, newline,
432 line_buffering ? Py_True : Py_False);
433 if (wrapper == NULL)
434 goto error;
435 result = wrapper;
436 Py_DECREF(buffer);
437
438 if (PyObject_SetAttr(wrapper, &_Py_ID(mode), modeobj) < 0)
439 goto error;
440 Py_DECREF(modeobj);
441 return result;
442
443 error:
444 if (result != NULL) {
445 PyObject *exc = PyErr_GetRaisedException();
446 PyObject *close_result = PyObject_CallMethodNoArgs(result, &_Py_ID(close));
447 _PyErr_ChainExceptions1(exc);
448 Py_XDECREF(close_result);
449 Py_DECREF(result);
450 }
451 Py_XDECREF(path_or_fd);
452 Py_XDECREF(modeobj);
453 return NULL;
454 }
455
456
457 /*[clinic input]
458 _io.text_encoding
459 encoding: object
460 stacklevel: int = 2
461 /
462
463 A helper function to choose the text encoding.
464
465 When encoding is not None, this function returns it.
466 Otherwise, this function returns the default text encoding
467 (i.e. "locale" or "utf-8" depends on UTF-8 mode).
468
469 This function emits an EncodingWarning if encoding is None and
470 sys.flags.warn_default_encoding is true.
471
472 This can be used in APIs with an encoding=None parameter.
473 However, please consider using encoding="utf-8" for new APIs.
474 [clinic start generated code]*/
475
476 static PyObject *
477 _io_text_encoding_impl(PyObject *module, PyObject *encoding, int stacklevel)
478 /*[clinic end generated code: output=91b2cfea6934cc0c input=4999aa8b3d90f3d4]*/
479 {
480 if (encoding == NULL || encoding == Py_None) {
481 PyInterpreterState *interp = _PyInterpreterState_GET();
482 if (_PyInterpreterState_GetConfig(interp)->warn_default_encoding) {
483 if (PyErr_WarnEx(PyExc_EncodingWarning,
484 "'encoding' argument not specified", stacklevel)) {
485 return NULL;
486 }
487 }
488 const PyPreConfig *preconfig = &_PyRuntime.preconfig;
489 if (preconfig->utf8_mode) {
490 _Py_DECLARE_STR(utf_8, "utf-8");
491 encoding = &_Py_STR(utf_8);
492 }
493 else {
494 encoding = &_Py_ID(locale);
495 }
496 }
497 return Py_NewRef(encoding);
498 }
499
500
501 /*[clinic input]
502 _io.open_code
503
504 path : unicode
505
506 Opens the provided file with the intent to import the contents.
507
508 This may perform extra validation beyond open(), but is otherwise
509 interchangeable with calling open(path, 'rb').
510
511 [clinic start generated code]*/
512
513 static PyObject *
514 _io_open_code_impl(PyObject *module, PyObject *path)
515 /*[clinic end generated code: output=2fe4ecbd6f3d6844 input=2803c35aeb63c719]*/
516 {
517 return PyFile_OpenCodeObject(path);
518 }
519
520 /*
521 * Private helpers for the io module.
522 */
523
524 Py_off_t
525 PyNumber_AsOff_t(PyObject *item, PyObject *err)
526 {
527 Py_off_t result;
528 PyObject *runerr;
529 PyObject *value = _PyNumber_Index(item);
530 if (value == NULL)
531 return -1;
532
533 /* We're done if PyLong_AsSsize_t() returns without error. */
534 result = PyLong_AsOff_t(value);
535 if (result != -1 || !(runerr = PyErr_Occurred()))
536 goto finish;
537
538 /* Error handling code -- only manage OverflowError differently */
539 if (!PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError))
540 goto finish;
541
542 PyErr_Clear();
543 /* If no error-handling desired then the default clipping
544 is sufficient.
545 */
546 if (!err) {
547 assert(PyLong_Check(value));
548 if (_PyLong_IsNegative((PyLongObject *)value))
549 result = PY_OFF_T_MIN;
550 else
551 result = PY_OFF_T_MAX;
552 }
553 else {
554 /* Otherwise replace the error with caller's error object. */
555 PyErr_Format(err,
556 "cannot fit '%.200s' into an offset-sized integer",
557 Py_TYPE(item)->tp_name);
558 }
559
560 finish:
561 Py_DECREF(value);
562 return result;
563 }
564
565 static int
566 iomodule_traverse(PyObject *mod, visitproc visit, void *arg) {
567 _PyIO_State *state = get_io_state(mod);
568 Py_VISIT(state->unsupported_operation);
569
570 Py_VISIT(state->PyIOBase_Type);
571 Py_VISIT(state->PyIncrementalNewlineDecoder_Type);
572 Py_VISIT(state->PyRawIOBase_Type);
573 Py_VISIT(state->PyBufferedIOBase_Type);
574 Py_VISIT(state->PyBufferedRWPair_Type);
575 Py_VISIT(state->PyBufferedRandom_Type);
576 Py_VISIT(state->PyBufferedReader_Type);
577 Py_VISIT(state->PyBufferedWriter_Type);
578 Py_VISIT(state->PyBytesIOBuffer_Type);
579 Py_VISIT(state->PyBytesIO_Type);
580 Py_VISIT(state->PyFileIO_Type);
581 Py_VISIT(state->PyStringIO_Type);
582 Py_VISIT(state->PyTextIOBase_Type);
583 Py_VISIT(state->PyTextIOWrapper_Type);
584 #ifdef HAVE_WINDOWS_CONSOLE_IO
585 Py_VISIT(state->PyWindowsConsoleIO_Type);
586 #endif
587 return 0;
588 }
589
590
591 static int
592 iomodule_clear(PyObject *mod) {
593 _PyIO_State *state = get_io_state(mod);
594 Py_CLEAR(state->unsupported_operation);
595
596 Py_CLEAR(state->PyIOBase_Type);
597 Py_CLEAR(state->PyIncrementalNewlineDecoder_Type);
598 Py_CLEAR(state->PyRawIOBase_Type);
599 Py_CLEAR(state->PyBufferedIOBase_Type);
600 Py_CLEAR(state->PyBufferedRWPair_Type);
601 Py_CLEAR(state->PyBufferedRandom_Type);
602 Py_CLEAR(state->PyBufferedReader_Type);
603 Py_CLEAR(state->PyBufferedWriter_Type);
604 Py_CLEAR(state->PyBytesIOBuffer_Type);
605 Py_CLEAR(state->PyBytesIO_Type);
606 Py_CLEAR(state->PyFileIO_Type);
607 Py_CLEAR(state->PyStringIO_Type);
608 Py_CLEAR(state->PyTextIOBase_Type);
609 Py_CLEAR(state->PyTextIOWrapper_Type);
610 #ifdef HAVE_WINDOWS_CONSOLE_IO
611 Py_CLEAR(state->PyWindowsConsoleIO_Type);
612 #endif
613 return 0;
614 }
615
616 static void
617 iomodule_free(void *mod)
618 {
619 (void)iomodule_clear((PyObject *)mod);
620 }
621
622
623 /*
624 * Module definition
625 */
626
627 #define clinic_state() (get_io_state(module))
628 #include "clinic/_iomodule.c.h"
629 #undef clinic_state
630
631 static PyMethodDef module_methods[] = {
632 _IO_OPEN_METHODDEF
633 _IO_TEXT_ENCODING_METHODDEF
634 _IO_OPEN_CODE_METHODDEF
635 {NULL, NULL}
636 };
637
638 #define ADD_TYPE(module, type, spec, base) \
639 do { \
640 type = (PyTypeObject *)PyType_FromModuleAndSpec(module, spec, \
641 (PyObject *)base); \
642 if (type == NULL) { \
643 return -1; \
644 } \
645 if (PyModule_AddType(module, type) < 0) { \
646 return -1; \
647 } \
648 } while (0)
649
650 static int
651 iomodule_exec(PyObject *m)
652 {
653 _PyIO_State *state = get_io_state(m);
654
655 /* DEFAULT_BUFFER_SIZE */
656 if (PyModule_AddIntMacro(m, DEFAULT_BUFFER_SIZE) < 0)
657 return -1;
658
659 /* UnsupportedOperation inherits from ValueError and OSError */
660 state->unsupported_operation = PyObject_CallFunction(
661 (PyObject *)&PyType_Type, "s(OO){}",
662 "UnsupportedOperation", PyExc_OSError, PyExc_ValueError);
663 if (state->unsupported_operation == NULL)
664 return -1;
665 if (PyObject_SetAttrString(state->unsupported_operation,
666 "__module__", &_Py_ID(io)) < 0)
667 {
668 return -1;
669 }
670 if (PyModule_AddObjectRef(m, "UnsupportedOperation",
671 state->unsupported_operation) < 0)
672 {
673 return -1;
674 }
675
676 /* BlockingIOError, for compatibility */
677 if (PyModule_AddObjectRef(m, "BlockingIOError",
678 (PyObject *) PyExc_BlockingIOError) < 0) {
679 return -1;
680 }
681
682 // Base classes
683 ADD_TYPE(m, state->PyIncrementalNewlineDecoder_Type, &nldecoder_spec, NULL);
684 ADD_TYPE(m, state->PyBytesIOBuffer_Type, &bytesiobuf_spec, NULL);
685 ADD_TYPE(m, state->PyIOBase_Type, &iobase_spec, NULL);
686
687 // PyIOBase_Type subclasses
688 ADD_TYPE(m, state->PyTextIOBase_Type, &textiobase_spec,
689 state->PyIOBase_Type);
690 ADD_TYPE(m, state->PyBufferedIOBase_Type, &bufferediobase_spec,
691 state->PyIOBase_Type);
692 ADD_TYPE(m, state->PyRawIOBase_Type, &rawiobase_spec,
693 state->PyIOBase_Type);
694
695 // PyBufferedIOBase_Type(PyIOBase_Type) subclasses
696 ADD_TYPE(m, state->PyBytesIO_Type, &bytesio_spec, state->PyBufferedIOBase_Type);
697 ADD_TYPE(m, state->PyBufferedWriter_Type, &bufferedwriter_spec,
698 state->PyBufferedIOBase_Type);
699 ADD_TYPE(m, state->PyBufferedReader_Type, &bufferedreader_spec,
700 state->PyBufferedIOBase_Type);
701 ADD_TYPE(m, state->PyBufferedRWPair_Type, &bufferedrwpair_spec,
702 state->PyBufferedIOBase_Type);
703 ADD_TYPE(m, state->PyBufferedRandom_Type, &bufferedrandom_spec,
704 state->PyBufferedIOBase_Type);
705
706 // PyRawIOBase_Type(PyIOBase_Type) subclasses
707 ADD_TYPE(m, state->PyFileIO_Type, &fileio_spec, state->PyRawIOBase_Type);
708
709 #ifdef HAVE_WINDOWS_CONSOLE_IO
710 ADD_TYPE(m, state->PyWindowsConsoleIO_Type, &winconsoleio_spec,
711 state->PyRawIOBase_Type);
712 #endif
713
714 // PyTextIOBase_Type(PyIOBase_Type) subclasses
715 ADD_TYPE(m, state->PyStringIO_Type, &stringio_spec, state->PyTextIOBase_Type);
716 ADD_TYPE(m, state->PyTextIOWrapper_Type, &textiowrapper_spec,
717 state->PyTextIOBase_Type);
718
719 #undef ADD_TYPE
720 return 0;
721 }
722
723 static struct PyModuleDef_Slot iomodule_slots[] = {
724 {Py_mod_exec, iomodule_exec},
725 {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
726 {Py_mod_gil, Py_MOD_GIL_NOT_USED},
727 {0, NULL},
728 };
729
730 struct PyModuleDef _PyIO_Module = {
731 .m_base = PyModuleDef_HEAD_INIT,
732 .m_name = "io",
733 .m_doc = module_doc,
734 .m_size = sizeof(_PyIO_State),
735 .m_methods = module_methods,
736 .m_traverse = iomodule_traverse,
737 .m_clear = iomodule_clear,
738 .m_free = iomodule_free,
739 .m_slots = iomodule_slots,
740 };
741
742 PyMODINIT_FUNC
743 PyInit__io(void)
744 {
745 return PyModuleDef_Init(&_PyIO_Module);
746 }