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 #define PY_SSIZE_T_CLEAN 11 #include "Python.h" 12 #include "structmember.h" 13 #include "_iomodule.h" 14 15 #ifdef HAVE_SYS_TYPES_H 16 #include <sys/types.h> 17 #endif /* HAVE_SYS_TYPES_H */ 18 19 #ifdef HAVE_SYS_STAT_H 20 #include <sys/stat.h> 21 #endif /* HAVE_SYS_STAT_H */ 22 23 24 /* Various interned strings */ 25 26 PyObject *_PyIO_str_close; 27 PyObject *_PyIO_str_closed; 28 PyObject *_PyIO_str_decode; 29 PyObject *_PyIO_str_encode; 30 PyObject *_PyIO_str_fileno; 31 PyObject *_PyIO_str_flush; 32 PyObject *_PyIO_str_getstate; 33 PyObject *_PyIO_str_isatty; 34 PyObject *_PyIO_str_newlines; 35 PyObject *_PyIO_str_nl; 36 PyObject *_PyIO_str_read; 37 PyObject *_PyIO_str_read1; 38 PyObject *_PyIO_str_readable; 39 PyObject *_PyIO_str_readinto; 40 PyObject *_PyIO_str_readline; 41 PyObject *_PyIO_str_reset; 42 PyObject *_PyIO_str_seek; 43 PyObject *_PyIO_str_seekable; 44 PyObject *_PyIO_str_setstate; 45 PyObject *_PyIO_str_tell; 46 PyObject *_PyIO_str_truncate; 47 PyObject *_PyIO_str_writable; 48 PyObject *_PyIO_str_write; 49 50 PyObject *_PyIO_empty_str; 51 PyObject *_PyIO_empty_bytes; 52 PyObject *_PyIO_zero; 53 54 55 PyDoc_STRVAR(module_doc, 57 "The io module provides the Python interfaces to stream handling. The\n" 58 "builtin open function is defined in this module.\n" 59 "\n" 60 "At the top of the I/O hierarchy is the abstract base class IOBase. It\n" 61 "defines the basic interface to a stream. Note, however, that there is no\n" 62 "seperation between reading and writing to streams; implementations are\n" 63 "allowed to throw an IOError if they do not support a given operation.\n" 64 "\n" 65 "Extending IOBase is RawIOBase which deals simply with the reading and\n" 66 "writing of raw bytes to a stream. FileIO subclasses RawIOBase to provide\n" 67 "an interface to OS files.\n" 68 "\n" 69 "BufferedIOBase deals with buffering on a raw byte stream (RawIOBase). Its\n" 70 "subclasses, BufferedWriter, BufferedReader, and BufferedRWPair buffer\n" 71 "streams that are readable, writable, and both respectively.\n" 72 "BufferedRandom provides a buffered interface to random access\n" 73 "streams. BytesIO is a simple stream of in-memory bytes.\n" 74 "\n" 75 "Another IOBase subclass, TextIOBase, deals with the encoding and decoding\n" 76 "of streams into text. TextIOWrapper, which extends it, is a buffered text\n" 77 "interface to a buffered raw stream (`BufferedIOBase`). Finally, StringIO\n" 78 "is a in-memory stream for text.\n" 79 "\n" 80 "Argument names are not part of the specification, and only the arguments\n" 81 "of open() are intended to be used as keyword arguments.\n" 82 "\n" 83 "data:\n" 84 "\n" 85 "DEFAULT_BUFFER_SIZE\n" 86 "\n" 87 " An int containing the default buffer size used by the module's buffered\n" 88 " I/O classes. open() uses the file's blksize (as obtained by os.stat) if\n" 89 " possible.\n" 90 ); 91 92 94 /* 95 * BlockingIOError extends IOError 96 */ 97 98 static int 99 blockingioerror_init(PyBlockingIOErrorObject *self, PyObject *args, 100 PyObject *kwds) 101 { 102 PyObject *myerrno = NULL, *strerror = NULL; 103 PyObject *baseargs = NULL; 104 Py_ssize_t written = 0; 105 106 assert(PyTuple_Check(args)); 107 108 self->written = 0; 109 if (!PyArg_ParseTuple(args, "OO|n:BlockingIOError", 110 &myerrno, &strerror, &written)) 111 return -1; 112 113 baseargs = PyTuple_Pack(2, myerrno, strerror); 114 if (baseargs == NULL) 115 return -1; 116 /* This will take care of initializing of myerrno and strerror members */ 117 if (((PyTypeObject *)PyExc_IOError)->tp_init( 118 (PyObject *)self, baseargs, kwds) == -1) { 119 Py_DECREF(baseargs); 120 return -1; 121 } 122 Py_DECREF(baseargs); 123 124 self->written = written; 125 return 0; 126 } 127 128 static PyMemberDef blockingioerror_members[] = { 129 {"characters_written", T_PYSSIZET, offsetof(PyBlockingIOErrorObject, written), 0}, 130 {NULL} /* Sentinel */ 131 }; 132 133 static PyTypeObject _PyExc_BlockingIOError = { 134 PyVarObject_HEAD_INIT(NULL, 0) 135 "BlockingIOError", /*tp_name*/ 136 sizeof(PyBlockingIOErrorObject), /*tp_basicsize*/ 137 0, /*tp_itemsize*/ 138 0, /*tp_dealloc*/ 139 0, /*tp_print*/ 140 0, /*tp_getattr*/ 141 0, /*tp_setattr*/ 142 0, /*tp_compare */ 143 0, /*tp_repr*/ 144 0, /*tp_as_number*/ 145 0, /*tp_as_sequence*/ 146 0, /*tp_as_mapping*/ 147 0, /*tp_hash */ 148 0, /*tp_call*/ 149 0, /*tp_str*/ 150 0, /*tp_getattro*/ 151 0, /*tp_setattro*/ 152 0, /*tp_as_buffer*/ 153 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ 154 PyDoc_STR("Exception raised when I/O would block " 155 "on a non-blocking I/O stream"), /* tp_doc */ 156 0, /* tp_traverse */ 157 0, /* tp_clear */ 158 0, /* tp_richcompare */ 159 0, /* tp_weaklistoffset */ 160 0, /* tp_iter */ 161 0, /* tp_iternext */ 162 0, /* tp_methods */ 163 blockingioerror_members, /* tp_members */ 164 0, /* tp_getset */ 165 0, /* tp_base */ 166 0, /* tp_dict */ 167 0, /* tp_descr_get */ 168 0, /* tp_descr_set */ 169 0, /* tp_dictoffset */ 170 (initproc)blockingioerror_init, /* tp_init */ 171 0, /* tp_alloc */ 172 0, /* tp_new */ 173 }; 174 PyObject *PyExc_BlockingIOError = (PyObject *)&_PyExc_BlockingIOError; 175 176 178 /* 179 * The main open() function 180 */ 181 PyDoc_STRVAR(open_doc, 182 "Open file and return a stream. Raise IOError upon failure.\n" 183 "\n" 184 "file is either a text or byte string giving the name (and the path\n" 185 "if the file isn't in the current working directory) of the file to\n" 186 "be opened or an integer file descriptor of the file to be\n" 187 "wrapped. (If a file descriptor is given, it is closed when the\n" 188 "returned I/O object is closed, unless closefd is set to False.)\n" 189 "\n" 190 "mode is an optional string that specifies the mode in which the file\n" 191 "is opened. It defaults to 'r' which means open for reading in text\n" 192 "mode. Other common values are 'w' for writing (truncating the file if\n" 193 "it already exists), and 'a' for appending (which on some Unix systems,\n" 194 "means that all writes append to the end of the file regardless of the\n" 195 "current seek position). In text mode, if encoding is not specified the\n" 196 "encoding used is platform dependent. (For reading and writing raw\n" 197 "bytes use binary mode and leave encoding unspecified.) The available\n" 198 "modes are:\n" 199 "\n" 200 "========= ===============================================================\n" 201 "Character Meaning\n" 202 "--------- ---------------------------------------------------------------\n" 203 "'r' open for reading (default)\n" 204 "'w' open for writing, truncating the file first\n" 205 "'a' open for writing, appending to the end of the file if it exists\n" 206 "'b' binary mode\n" 207 "'t' text mode (default)\n" 208 "'+' open a disk file for updating (reading and writing)\n" 209 "'U' universal newline mode (for backwards compatibility; unneeded\n" 210 " for new code)\n" 211 "========= ===============================================================\n" 212 "\n" 213 "The default mode is 'rt' (open for reading text). For binary random\n" 214 "access, the mode 'w+b' opens and truncates the file to 0 bytes, while\n" 215 "'r+b' opens the file without truncation.\n" 216 "\n" 217 "Python distinguishes between files opened in binary and text modes,\n" 218 "even when the underlying operating system doesn't. Files opened in\n" 219 "binary mode (appending 'b' to the mode argument) return contents as\n" 220 "bytes objects without any decoding. In text mode (the default, or when\n" 221 "'t' is appended to the mode argument), the contents of the file are\n" 222 "returned as strings, the bytes having been first decoded using a\n" 223 "platform-dependent encoding or using the specified encoding if given.\n" 224 "\n" 225 "buffering is an optional integer used to set the buffering policy.\n" 226 "Pass 0 to switch buffering off (only allowed in binary mode), 1 to select\n" 227 "line buffering (only usable in text mode), and an integer > 1 to indicate\n" 228 "the size of a fixed-size chunk buffer. When no buffering argument is\n" 229 "given, the default buffering policy works as follows:\n" 230 "\n" 231 "* Binary files are buffered in fixed-size chunks; the size of the buffer\n" 232 " is chosen using a heuristic trying to determine the underlying device's\n" 233 " \"block size\" and falling back on `io.DEFAULT_BUFFER_SIZE`.\n" 234 " On many systems, the buffer will typically be 4096 or 8192 bytes long.\n" 235 "\n" 236 "* \"Interactive\" text files (files for which isatty() returns True)\n" 237 " use line buffering. Other text files use the policy described above\n" 238 " for binary files.\n" 239 "\n" 240 "encoding is the name of the encoding used to decode or encode the\n" 241 "file. This should only be used in text mode. The default encoding is\n" 242 "platform dependent, but any encoding supported by Python can be\n" 243 "passed. See the codecs module for the list of supported encodings.\n" 244 "\n" 245 "errors is an optional string that specifies how encoding errors are to\n" 246 "be handled---this argument should not be used in binary mode. Pass\n" 247 "'strict' to raise a ValueError exception if there is an encoding error\n" 248 "(the default of None has the same effect), or pass 'ignore' to ignore\n" 249 "errors. (Note that ignoring encoding errors can lead to data loss.)\n" 250 "See the documentation for codecs.register for a list of the permitted\n" 251 "encoding error strings.\n" 252 "\n" 253 "newline controls how universal newlines works (it only applies to text\n" 254 "mode). It can be None, '', '\\n', '\\r', and '\\r\\n'. It works as\n" 255 "follows:\n" 256 "\n" 257 "* On input, if newline is None, universal newlines mode is\n" 258 " enabled. Lines in the input can end in '\\n', '\\r', or '\\r\\n', and\n" 259 " these are translated into '\\n' before being returned to the\n" 260 " caller. If it is '', universal newline mode is enabled, but line\n" 261 " endings are returned to the caller untranslated. If it has any of\n" 262 " the other legal values, input lines are only terminated by the given\n" 263 " string, and the line ending is returned to the caller untranslated.\n" 264 "\n" 265 "* On output, if newline is None, any '\\n' characters written are\n" 266 " translated to the system default line separator, os.linesep. If\n" 267 " newline is '', no translation takes place. If newline is any of the\n" 268 " other legal values, any '\\n' characters written are translated to\n" 269 " the given string.\n" 270 "\n" 271 "If closefd is False, the underlying file descriptor will be kept open\n" 272 "when the file is closed. This does not work when a file name is given\n" 273 "and must be True in that case.\n" 274 "\n" 275 "open() returns a file object whose type depends on the mode, and\n" 276 "through which the standard file operations such as reading and writing\n" 277 "are performed. When open() is used to open a file in a text mode ('w',\n" 278 "'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open\n" 279 "a file in a binary mode, the returned class varies: in read binary\n" 280 "mode, it returns a BufferedReader; in write binary and append binary\n" 281 "modes, it returns a BufferedWriter, and in read/write mode, it returns\n" 282 "a BufferedRandom.\n" 283 "\n" 284 "It is also possible to use a string or bytearray as a file for both\n" 285 "reading and writing. For strings StringIO can be used like a file\n" 286 "opened in a text mode, and for bytes a BytesIO can be used like a file\n" 287 "opened in a binary mode.\n" 288 ); 289 290 static PyObject * 291 io_open(PyObject *self, PyObject *args, PyObject *kwds) 292 { 293 char *kwlist[] = {"file", "mode", "buffering", 294 "encoding", "errors", "newline", 295 "closefd", NULL}; 296 PyObject *file; 297 char *mode = "r"; 298 int buffering = -1, closefd = 1; 299 char *encoding = NULL, *errors = NULL, *newline = NULL; 300 unsigned i; 301 302 int reading = 0, writing = 0, appending = 0, updating = 0; 303 int text = 0, binary = 0, universal = 0; 304 305 char rawmode[5], *m; 306 int line_buffering, isatty; 307 308 PyObject *raw, *modeobj = NULL, *buffer = NULL, *wrapper = NULL; 309 310 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|sizzzi:open", kwlist, 311 &file, &mode, &buffering, 312 &encoding, &errors, &newline, 313 &closefd)) { 314 return NULL; 315 } 316 317 if (!PyUnicode_Check(file) && 318 !PyBytes_Check(file) && 319 !PyNumber_Check(file)) { 320 PyObject *repr = PyObject_Repr(file); 321 if (repr != NULL) { 322 PyErr_Format(PyExc_TypeError, "invalid file: %s", 323 PyString_AS_STRING(repr)); 324 Py_DECREF(repr); 325 } 326 return NULL; 327 } 328 329 /* Decode mode */ 330 for (i = 0; i < strlen(mode); i++) { 331 char c = mode[i]; 332 333 switch (c) { 334 case 'r': 335 reading = 1; 336 break; 337 case 'w': 338 writing = 1; 339 break; 340 case 'a': 341 appending = 1; 342 break; 343 case '+': 344 updating = 1; 345 break; 346 case 't': 347 text = 1; 348 break; 349 case 'b': 350 binary = 1; 351 break; 352 case 'U': 353 universal = 1; 354 reading = 1; 355 break; 356 default: 357 goto invalid_mode; 358 } 359 360 /* c must not be duplicated */ 361 if (strchr(mode+i+1, c)) { 362 invalid_mode: 363 PyErr_Format(PyExc_ValueError, "invalid mode: '%s'", mode); 364 return NULL; 365 } 366 367 } 368 369 m = rawmode; 370 if (reading) *(m++) = 'r'; 371 if (writing) *(m++) = 'w'; 372 if (appending) *(m++) = 'a'; 373 if (updating) *(m++) = '+'; 374 *m = '\0'; 375 376 /* Parameters validation */ 377 if (universal) { 378 if (writing || appending) { 379 PyErr_SetString(PyExc_ValueError, 380 "can't use U and writing mode at once"); 381 return NULL; 382 } 383 reading = 1; 384 } 385 386 if (text && binary) { 387 PyErr_SetString(PyExc_ValueError, 388 "can't have text and binary mode at once"); 389 return NULL; 390 } 391 392 if (reading + writing + appending > 1) { 393 PyErr_SetString(PyExc_ValueError, 394 "must have exactly one of read/write/append mode"); 395 return NULL; 396 } 397 398 if (binary && encoding != NULL) { 399 PyErr_SetString(PyExc_ValueError, 400 "binary mode doesn't take an encoding argument"); 401 return NULL; 402 } 403 404 if (binary && errors != NULL) { 405 PyErr_SetString(PyExc_ValueError, 406 "binary mode doesn't take an errors argument"); 407 return NULL; 408 } 409 410 if (binary && newline != NULL) { 411 PyErr_SetString(PyExc_ValueError, 412 "binary mode doesn't take a newline argument"); 413 return NULL; 414 } 415 416 /* Create the Raw file stream */ 417 raw = PyObject_CallFunction((PyObject *)&PyFileIO_Type, 418 "Osi", file, rawmode, closefd); 419 if (raw == NULL) 420 return NULL; 421 422 modeobj = PyUnicode_FromString(mode); 423 if (modeobj == NULL) 424 goto error; 425 426 /* buffering */ 427 { 428 PyObject *res = PyObject_CallMethod(raw, "isatty", NULL); 429 if (res == NULL) 430 goto error; 431 isatty = PyLong_AsLong(res); 432 Py_DECREF(res); 433 if (isatty == -1 && PyErr_Occurred()) 434 goto error; 435 } 436 437 if (buffering == 1 || (buffering < 0 && isatty)) { 438 buffering = -1; 439 line_buffering = 1; 440 } 441 else 442 line_buffering = 0; 443 444 if (buffering < 0) { 445 buffering = DEFAULT_BUFFER_SIZE; 446 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE 447 { 448 struct stat st; 449 long fileno; 450 PyObject *res = PyObject_CallMethod(raw, "fileno", NULL); 451 if (res == NULL) 452 goto error; 453 454 fileno = PyInt_AsLong(res); 455 Py_DECREF(res); 456 if (fileno == -1 && PyErr_Occurred()) 457 goto error; 458 459 if (fstat(fileno, &st) >= 0 && st.st_blksize > 1) 460 buffering = st.st_blksize; 461 } 462 #endif 463 } 464 if (buffering < 0) { 465 PyErr_SetString(PyExc_ValueError, 466 "invalid buffering size"); 467 goto error; 468 } 469 470 /* if not buffering, returns the raw file object */ 471 if (buffering == 0) { 472 if (!binary) { 473 PyErr_SetString(PyExc_ValueError, 474 "can't have unbuffered text I/O"); 475 goto error; 476 } 477 478 Py_DECREF(modeobj); 479 return raw; 480 } 481 482 /* wraps into a buffered file */ 483 { 484 PyObject *Buffered_class; 485 486 if (updating) 487 Buffered_class = (PyObject *)&PyBufferedRandom_Type; 488 else if (writing || appending) 489 Buffered_class = (PyObject *)&PyBufferedWriter_Type; 490 else if (reading) 491 Buffered_class = (PyObject *)&PyBufferedReader_Type; 492 else { 493 PyErr_Format(PyExc_ValueError, 494 "unknown mode: '%s'", mode); 495 goto error; 496 } 497 498 buffer = PyObject_CallFunction(Buffered_class, "Oi", raw, buffering); 499 } 500 Py_CLEAR(raw); 501 if (buffer == NULL) 502 goto error; 503 504 505 /* if binary, returns the buffered file */ 506 if (binary) { 507 Py_DECREF(modeobj); 508 return buffer; 509 } 510 511 /* wraps into a TextIOWrapper */ 512 wrapper = PyObject_CallFunction((PyObject *)&PyTextIOWrapper_Type, 513 "Osssi", 514 buffer, 515 encoding, errors, newline, 516 line_buffering); 517 Py_CLEAR(buffer); 518 if (wrapper == NULL) 519 goto error; 520 521 if (PyObject_SetAttrString(wrapper, "mode", modeobj) < 0) 522 goto error; 523 Py_DECREF(modeobj); 524 return wrapper; 525 526 error: 527 Py_XDECREF(raw); 528 Py_XDECREF(modeobj); 529 Py_XDECREF(buffer); 530 Py_XDECREF(wrapper); 531 return NULL; 532 } 533 534 /* 536 * Private helpers for the io module. 537 */ 538 539 Py_off_t 540 PyNumber_AsOff_t(PyObject *item, PyObject *err) 541 { 542 Py_off_t result; 543 PyObject *runerr; 544 PyObject *value = PyNumber_Index(item); 545 if (value == NULL) 546 return -1; 547 548 if (PyInt_Check(value)) { 549 /* We assume a long always fits in a Py_off_t... */ 550 result = (Py_off_t) PyInt_AS_LONG(value); 551 goto finish; 552 } 553 554 /* We're done if PyLong_AsSsize_t() returns without error. */ 555 result = PyLong_AsOff_t(value); 556 if (result != -1 || !(runerr = PyErr_Occurred())) 557 goto finish; 558 559 /* Error handling code -- only manage OverflowError differently */ 560 if (!PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) 561 goto finish; 562 563 PyErr_Clear(); 564 /* If no error-handling desired then the default clipping 565 is sufficient. 566 */ 567 if (!err) { 568 assert(PyLong_Check(value)); 569 /* Whether or not it is less than or equal to 570 zero is determined by the sign of ob_size 571 */ 572 if (_PyLong_Sign(value) < 0) 573 result = PY_OFF_T_MIN; 574 else 575 result = PY_OFF_T_MAX; 576 } 577 else { 578 /* Otherwise replace the error with caller's error object. */ 579 PyErr_Format(err, 580 "cannot fit '%.200s' into an offset-sized integer", 581 item->ob_type->tp_name); 582 } 583 584 finish: 585 Py_DECREF(value); 586 return result; 587 } 588 589 590 /* Basically the "n" format code with the ability to turn None into -1. */ 591 int 592 _PyIO_ConvertSsize_t(PyObject *obj, void *result) { 593 Py_ssize_t limit; 594 if (obj == Py_None) { 595 limit = -1; 596 } 597 else if (PyNumber_Check(obj)) { 598 limit = PyNumber_AsSsize_t(obj, PyExc_OverflowError); 599 if (limit == -1 && PyErr_Occurred()) 600 return 0; 601 } 602 else { 603 PyErr_Format(PyExc_TypeError, 604 "integer argument expected, got '%.200s'", 605 Py_TYPE(obj)->tp_name); 606 return 0; 607 } 608 *((Py_ssize_t *)result) = limit; 609 return 1; 610 } 611 612 613 /* 614 * Module definition 615 */ 616 617 PyObject *_PyIO_os_module = NULL; 618 PyObject *_PyIO_locale_module = NULL; 619 PyObject *_PyIO_unsupported_operation = NULL; 620 621 static PyMethodDef module_methods[] = { 622 {"open", (PyCFunction)io_open, METH_VARARGS|METH_KEYWORDS, open_doc}, 623 {NULL, NULL} 624 }; 625 626 PyMODINIT_FUNC 627 init_io(void) 628 { 629 PyObject *m = Py_InitModule4("_io", module_methods, 630 module_doc, NULL, PYTHON_API_VERSION); 631 if (m == NULL) 632 return; 633 634 /* put os in the module state */ 635 _PyIO_os_module = PyImport_ImportModule("os"); 636 if (_PyIO_os_module == NULL) 637 goto fail; 638 639 #define ADD_TYPE(type, name) \ 640 if (PyType_Ready(type) < 0) \ 641 goto fail; \ 642 Py_INCREF(type); \ 643 if (PyModule_AddObject(m, name, (PyObject *)type) < 0) { \ 644 Py_DECREF(type); \ 645 goto fail; \ 646 } 647 648 /* DEFAULT_BUFFER_SIZE */ 649 if (PyModule_AddIntMacro(m, DEFAULT_BUFFER_SIZE) < 0) 650 goto fail; 651 652 /* UnsupportedOperation inherits from ValueError and IOError */ 653 _PyIO_unsupported_operation = PyObject_CallFunction( 654 (PyObject *)&PyType_Type, "s(OO){}", 655 "UnsupportedOperation", PyExc_ValueError, PyExc_IOError); 656 if (_PyIO_unsupported_operation == NULL) 657 goto fail; 658 Py_INCREF(_PyIO_unsupported_operation); 659 if (PyModule_AddObject(m, "UnsupportedOperation", 660 _PyIO_unsupported_operation) < 0) 661 goto fail; 662 663 /* BlockingIOError */ 664 _PyExc_BlockingIOError.tp_base = (PyTypeObject *) PyExc_IOError; 665 ADD_TYPE(&_PyExc_BlockingIOError, "BlockingIOError"); 666 667 /* Concrete base types of the IO ABCs. 668 (the ABCs themselves are declared through inheritance in io.py) 669 */ 670 ADD_TYPE(&PyIOBase_Type, "_IOBase"); 671 ADD_TYPE(&PyRawIOBase_Type, "_RawIOBase"); 672 ADD_TYPE(&PyBufferedIOBase_Type, "_BufferedIOBase"); 673 ADD_TYPE(&PyTextIOBase_Type, "_TextIOBase"); 674 675 /* Implementation of concrete IO objects. */ 676 /* FileIO */ 677 PyFileIO_Type.tp_base = &PyRawIOBase_Type; 678 ADD_TYPE(&PyFileIO_Type, "FileIO"); 679 680 /* BytesIO */ 681 PyBytesIO_Type.tp_base = &PyBufferedIOBase_Type; 682 ADD_TYPE(&PyBytesIO_Type, "BytesIO"); 683 684 /* StringIO */ 685 PyStringIO_Type.tp_base = &PyTextIOBase_Type; 686 ADD_TYPE(&PyStringIO_Type, "StringIO"); 687 688 /* BufferedReader */ 689 PyBufferedReader_Type.tp_base = &PyBufferedIOBase_Type; 690 ADD_TYPE(&PyBufferedReader_Type, "BufferedReader"); 691 692 /* BufferedWriter */ 693 PyBufferedWriter_Type.tp_base = &PyBufferedIOBase_Type; 694 ADD_TYPE(&PyBufferedWriter_Type, "BufferedWriter"); 695 696 /* BufferedRWPair */ 697 PyBufferedRWPair_Type.tp_base = &PyBufferedIOBase_Type; 698 ADD_TYPE(&PyBufferedRWPair_Type, "BufferedRWPair"); 699 700 /* BufferedRandom */ 701 PyBufferedRandom_Type.tp_base = &PyBufferedIOBase_Type; 702 ADD_TYPE(&PyBufferedRandom_Type, "BufferedRandom"); 703 704 /* TextIOWrapper */ 705 PyTextIOWrapper_Type.tp_base = &PyTextIOBase_Type; 706 ADD_TYPE(&PyTextIOWrapper_Type, "TextIOWrapper"); 707 708 /* IncrementalNewlineDecoder */ 709 ADD_TYPE(&PyIncrementalNewlineDecoder_Type, "IncrementalNewlineDecoder"); 710 711 /* Interned strings */ 712 if (!(_PyIO_str_close = PyString_InternFromString("close"))) 713 goto fail; 714 if (!(_PyIO_str_closed = PyString_InternFromString("closed"))) 715 goto fail; 716 if (!(_PyIO_str_decode = PyString_InternFromString("decode"))) 717 goto fail; 718 if (!(_PyIO_str_encode = PyString_InternFromString("encode"))) 719 goto fail; 720 if (!(_PyIO_str_fileno = PyString_InternFromString("fileno"))) 721 goto fail; 722 if (!(_PyIO_str_flush = PyString_InternFromString("flush"))) 723 goto fail; 724 if (!(_PyIO_str_getstate = PyString_InternFromString("getstate"))) 725 goto fail; 726 if (!(_PyIO_str_isatty = PyString_InternFromString("isatty"))) 727 goto fail; 728 if (!(_PyIO_str_newlines = PyString_InternFromString("newlines"))) 729 goto fail; 730 if (!(_PyIO_str_nl = PyString_InternFromString("\n"))) 731 goto fail; 732 if (!(_PyIO_str_read = PyString_InternFromString("read"))) 733 goto fail; 734 if (!(_PyIO_str_read1 = PyString_InternFromString("read1"))) 735 goto fail; 736 if (!(_PyIO_str_readable = PyString_InternFromString("readable"))) 737 goto fail; 738 if (!(_PyIO_str_readinto = PyString_InternFromString("readinto"))) 739 goto fail; 740 if (!(_PyIO_str_readline = PyString_InternFromString("readline"))) 741 goto fail; 742 if (!(_PyIO_str_reset = PyString_InternFromString("reset"))) 743 goto fail; 744 if (!(_PyIO_str_seek = PyString_InternFromString("seek"))) 745 goto fail; 746 if (!(_PyIO_str_seekable = PyString_InternFromString("seekable"))) 747 goto fail; 748 if (!(_PyIO_str_setstate = PyString_InternFromString("setstate"))) 749 goto fail; 750 if (!(_PyIO_str_tell = PyString_InternFromString("tell"))) 751 goto fail; 752 if (!(_PyIO_str_truncate = PyString_InternFromString("truncate"))) 753 goto fail; 754 if (!(_PyIO_str_write = PyString_InternFromString("write"))) 755 goto fail; 756 if (!(_PyIO_str_writable = PyString_InternFromString("writable"))) 757 goto fail; 758 759 if (!(_PyIO_empty_str = PyUnicode_FromStringAndSize(NULL, 0))) 760 goto fail; 761 if (!(_PyIO_empty_bytes = PyBytes_FromStringAndSize(NULL, 0))) 762 goto fail; 763 if (!(_PyIO_zero = PyLong_FromLong(0L))) 764 goto fail; 765 766 return; 767 768 fail: 769 Py_CLEAR(_PyIO_os_module); 770 Py_CLEAR(_PyIO_unsupported_operation); 771 Py_DECREF(m); 772 } 773