Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 1 | /* |
| 2 | An implementation of the I/O abstract base classes hierarchy |
| 3 | as defined by PEP 3116 - "New I/O" |
| 4 | |
| 5 | Classes defined here: IOBase, RawIOBase. |
| 6 | |
| 7 | Written by Amaury Forgeot d'Arc and Antoine Pitrou |
| 8 | */ |
| 9 | |
| 10 | |
| 11 | #define PY_SSIZE_T_CLEAN |
| 12 | #include "Python.h" |
| 13 | #include "structmember.h" |
| 14 | #include "_iomodule.h" |
| 15 | |
| 16 | /* |
| 17 | * IOBase class, an abstract class |
| 18 | */ |
| 19 | |
| 20 | typedef struct { |
| 21 | PyObject_HEAD |
| 22 | |
| 23 | PyObject *dict; |
| 24 | PyObject *weakreflist; |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 25 | } iobase; |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 26 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 27 | PyDoc_STRVAR(iobase_doc, |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 28 | "The abstract base class for all I/O classes, acting on streams of\n" |
| 29 | "bytes. There is no public constructor.\n" |
| 30 | "\n" |
| 31 | "This class provides dummy implementations for many methods that\n" |
| 32 | "derived classes can override selectively; the default implementations\n" |
| 33 | "represent a file that cannot be read, written or seeked.\n" |
| 34 | "\n" |
| 35 | "Even though IOBase does not declare read, readinto, or write because\n" |
| 36 | "their signatures will vary, implementations and clients should\n" |
| 37 | "consider those methods part of the interface. Also, implementations\n" |
Amaury Forgeot d'Arc | 616453c | 2010-09-06 22:31:52 +0000 | [diff] [blame] | 38 | "may raise UnsupportedOperation when operations they do not support are\n" |
| 39 | "called.\n" |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 40 | "\n" |
| 41 | "The basic type used for binary data read from or written to a file is\n" |
| 42 | "bytes. bytearrays are accepted too, and in some cases (such as\n" |
| 43 | "readinto) needed. Text I/O classes work with str data.\n" |
| 44 | "\n" |
| 45 | "Note that calling any method (even inquiries) on a closed stream is\n" |
| 46 | "undefined. Implementations may raise IOError in this case.\n" |
| 47 | "\n" |
| 48 | "IOBase (and its subclasses) support the iterator protocol, meaning\n" |
| 49 | "that an IOBase object can be iterated over yielding the lines in a\n" |
| 50 | "stream.\n" |
| 51 | "\n" |
| 52 | "IOBase also supports the :keyword:`with` statement. In this example,\n" |
Ezio Melotti | 1392500 | 2011-03-16 11:05:33 +0200 | [diff] [blame] | 53 | "fp is closed after the suite of the with statement is complete:\n" |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 54 | "\n" |
| 55 | "with open('spam.txt', 'r') as fp:\n" |
| 56 | " fp.write('Spam and eggs!')\n"); |
| 57 | |
| 58 | /* Use this macro whenever you want to check the internal `closed` status |
| 59 | of the IOBase object rather than the virtual `closed` attribute as returned |
| 60 | by whatever subclass. */ |
| 61 | |
Martin v. Löwis | 767046a | 2011-10-14 15:35:36 +0200 | [diff] [blame] | 62 | _Py_IDENTIFIER(__IOBase_closed); |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 63 | #define IS_CLOSED(self) \ |
Martin v. Löwis | 767046a | 2011-10-14 15:35:36 +0200 | [diff] [blame] | 64 | _PyObject_HasAttrId(self, &PyId___IOBase_closed) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 65 | |
| 66 | /* Internal methods */ |
| 67 | static PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 68 | iobase_unsupported(const char *message) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 69 | { |
| 70 | PyErr_SetString(IO_STATE->unsupported_operation, message); |
| 71 | return NULL; |
| 72 | } |
| 73 | |
| 74 | /* Positionning */ |
| 75 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 76 | PyDoc_STRVAR(iobase_seek_doc, |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 77 | "Change stream position.\n" |
| 78 | "\n" |
| 79 | "Change the stream position to byte offset offset. offset is\n" |
| 80 | "interpreted relative to the position indicated by whence. Values\n" |
| 81 | "for whence are:\n" |
| 82 | "\n" |
| 83 | "* 0 -- start of stream (the default); offset should be zero or positive\n" |
| 84 | "* 1 -- current stream position; offset may be negative\n" |
| 85 | "* 2 -- end of stream; offset is usually negative\n" |
| 86 | "\n" |
| 87 | "Return the new absolute position."); |
| 88 | |
| 89 | static PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 90 | iobase_seek(PyObject *self, PyObject *args) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 91 | { |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 92 | return iobase_unsupported("seek"); |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 93 | } |
| 94 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 95 | PyDoc_STRVAR(iobase_tell_doc, |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 96 | "Return current stream position."); |
| 97 | |
| 98 | static PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 99 | iobase_tell(PyObject *self, PyObject *args) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 100 | { |
Martin v. Löwis | bd928fe | 2011-10-14 10:20:37 +0200 | [diff] [blame] | 101 | _Py_IDENTIFIER(seek); |
Martin v. Löwis | afe55bb | 2011-10-09 10:38:36 +0200 | [diff] [blame] | 102 | |
| 103 | return _PyObject_CallMethodId(self, &PyId_seek, "ii", 0, 1); |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 104 | } |
| 105 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 106 | PyDoc_STRVAR(iobase_truncate_doc, |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 107 | "Truncate file to size bytes.\n" |
| 108 | "\n" |
Antoine Pitrou | 905a2ff | 2010-01-31 22:47:27 +0000 | [diff] [blame] | 109 | "File pointer is left unchanged. Size defaults to the current IO\n" |
| 110 | "position as reported by tell(). Returns the new size."); |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 111 | |
| 112 | static PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 113 | iobase_truncate(PyObject *self, PyObject *args) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 114 | { |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 115 | return iobase_unsupported("truncate"); |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 116 | } |
| 117 | |
| 118 | /* Flush and close methods */ |
| 119 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 120 | PyDoc_STRVAR(iobase_flush_doc, |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 121 | "Flush write buffers, if applicable.\n" |
| 122 | "\n" |
| 123 | "This is not implemented for read-only and non-blocking streams.\n"); |
| 124 | |
| 125 | static PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 126 | iobase_flush(PyObject *self, PyObject *args) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 127 | { |
| 128 | /* XXX Should this return the number of bytes written??? */ |
| 129 | if (IS_CLOSED(self)) { |
| 130 | PyErr_SetString(PyExc_ValueError, "I/O operation on closed file."); |
| 131 | return NULL; |
| 132 | } |
| 133 | Py_RETURN_NONE; |
| 134 | } |
| 135 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 136 | PyDoc_STRVAR(iobase_close_doc, |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 137 | "Flush and close the IO object.\n" |
| 138 | "\n" |
| 139 | "This method has no effect if the file is already closed.\n"); |
| 140 | |
| 141 | static int |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 142 | iobase_closed(PyObject *self) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 143 | { |
| 144 | PyObject *res; |
| 145 | int closed; |
| 146 | /* This gets the derived attribute, which is *not* __IOBase_closed |
| 147 | in most cases! */ |
| 148 | res = PyObject_GetAttr(self, _PyIO_str_closed); |
| 149 | if (res == NULL) |
| 150 | return 0; |
| 151 | closed = PyObject_IsTrue(res); |
| 152 | Py_DECREF(res); |
| 153 | return closed; |
| 154 | } |
| 155 | |
| 156 | static PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 157 | iobase_closed_get(PyObject *self, void *context) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 158 | { |
| 159 | return PyBool_FromLong(IS_CLOSED(self)); |
| 160 | } |
| 161 | |
| 162 | PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 163 | _PyIOBase_check_closed(PyObject *self, PyObject *args) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 164 | { |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 165 | if (iobase_closed(self)) { |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 166 | PyErr_SetString(PyExc_ValueError, "I/O operation on closed file."); |
| 167 | return NULL; |
| 168 | } |
| 169 | if (args == Py_True) |
| 170 | return Py_None; |
| 171 | else |
| 172 | Py_RETURN_NONE; |
| 173 | } |
| 174 | |
| 175 | /* XXX: IOBase thinks it has to maintain its own internal state in |
| 176 | `__IOBase_closed` and call flush() by itself, but it is redundant with |
| 177 | whatever behaviour a non-trivial derived class will implement. */ |
| 178 | |
| 179 | static PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 180 | iobase_close(PyObject *self, PyObject *args) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 181 | { |
| 182 | PyObject *res; |
Martin v. Löwis | 767046a | 2011-10-14 15:35:36 +0200 | [diff] [blame] | 183 | _Py_IDENTIFIER(__IOBase_closed); |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 184 | |
| 185 | if (IS_CLOSED(self)) |
| 186 | Py_RETURN_NONE; |
| 187 | |
| 188 | res = PyObject_CallMethodObjArgs(self, _PyIO_str_flush, NULL); |
Martin v. Löwis | 767046a | 2011-10-14 15:35:36 +0200 | [diff] [blame] | 189 | _PyObject_SetAttrId(self, &PyId___IOBase_closed, Py_True); |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 190 | if (res == NULL) { |
Antoine Pitrou | 6be8876 | 2010-05-03 16:48:20 +0000 | [diff] [blame] | 191 | return NULL; |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 192 | } |
| 193 | Py_XDECREF(res); |
| 194 | Py_RETURN_NONE; |
| 195 | } |
| 196 | |
| 197 | /* Finalization and garbage collection support */ |
| 198 | |
| 199 | int |
| 200 | _PyIOBase_finalize(PyObject *self) |
| 201 | { |
| 202 | PyObject *res; |
| 203 | PyObject *tp, *v, *tb; |
| 204 | int closed = 1; |
| 205 | int is_zombie; |
| 206 | |
| 207 | /* If _PyIOBase_finalize() is called from a destructor, we need to |
| 208 | resurrect the object as calling close() can invoke arbitrary code. */ |
| 209 | is_zombie = (Py_REFCNT(self) == 0); |
| 210 | if (is_zombie) { |
| 211 | ++Py_REFCNT(self); |
| 212 | } |
| 213 | PyErr_Fetch(&tp, &v, &tb); |
| 214 | /* If `closed` doesn't exist or can't be evaluated as bool, then the |
| 215 | object is probably in an unusable state, so ignore. */ |
| 216 | res = PyObject_GetAttr(self, _PyIO_str_closed); |
| 217 | if (res == NULL) |
| 218 | PyErr_Clear(); |
| 219 | else { |
| 220 | closed = PyObject_IsTrue(res); |
| 221 | Py_DECREF(res); |
| 222 | if (closed == -1) |
| 223 | PyErr_Clear(); |
| 224 | } |
| 225 | if (closed == 0) { |
| 226 | res = PyObject_CallMethodObjArgs((PyObject *) self, _PyIO_str_close, |
| 227 | NULL); |
| 228 | /* Silencing I/O errors is bad, but printing spurious tracebacks is |
| 229 | equally as bad, and potentially more frequent (because of |
| 230 | shutdown issues). */ |
| 231 | if (res == NULL) |
| 232 | PyErr_Clear(); |
| 233 | else |
| 234 | Py_DECREF(res); |
| 235 | } |
| 236 | PyErr_Restore(tp, v, tb); |
| 237 | if (is_zombie) { |
| 238 | if (--Py_REFCNT(self) != 0) { |
| 239 | /* The object lives again. The following code is taken from |
| 240 | slot_tp_del in typeobject.c. */ |
| 241 | Py_ssize_t refcnt = Py_REFCNT(self); |
| 242 | _Py_NewReference(self); |
| 243 | Py_REFCNT(self) = refcnt; |
| 244 | /* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so |
| 245 | * we need to undo that. */ |
| 246 | _Py_DEC_REFTOTAL; |
| 247 | /* If Py_TRACE_REFS, _Py_NewReference re-added self to the object |
| 248 | * chain, so no more to do there. |
| 249 | * If COUNT_ALLOCS, the original decref bumped tp_frees, and |
| 250 | * _Py_NewReference bumped tp_allocs: both of those need to be |
| 251 | * undone. |
| 252 | */ |
| 253 | #ifdef COUNT_ALLOCS |
| 254 | --Py_TYPE(self)->tp_frees; |
| 255 | --Py_TYPE(self)->tp_allocs; |
| 256 | #endif |
| 257 | return -1; |
| 258 | } |
| 259 | } |
| 260 | return 0; |
| 261 | } |
| 262 | |
| 263 | static int |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 264 | iobase_traverse(iobase *self, visitproc visit, void *arg) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 265 | { |
| 266 | Py_VISIT(self->dict); |
| 267 | return 0; |
| 268 | } |
| 269 | |
| 270 | static int |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 271 | iobase_clear(iobase *self) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 272 | { |
| 273 | if (_PyIOBase_finalize((PyObject *) self) < 0) |
| 274 | return -1; |
| 275 | Py_CLEAR(self->dict); |
| 276 | return 0; |
| 277 | } |
| 278 | |
| 279 | /* Destructor */ |
| 280 | |
| 281 | static void |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 282 | iobase_dealloc(iobase *self) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 283 | { |
| 284 | /* NOTE: since IOBaseObject has its own dict, Python-defined attributes |
| 285 | are still available here for close() to use. |
| 286 | However, if the derived class declares a __slots__, those slots are |
| 287 | already gone. |
| 288 | */ |
| 289 | if (_PyIOBase_finalize((PyObject *) self) < 0) { |
| 290 | /* When called from a heap type's dealloc, the type will be |
| 291 | decref'ed on return (see e.g. subtype_dealloc in typeobject.c). */ |
| 292 | if (PyType_HasFeature(Py_TYPE(self), Py_TPFLAGS_HEAPTYPE)) |
| 293 | Py_INCREF(Py_TYPE(self)); |
| 294 | return; |
| 295 | } |
| 296 | _PyObject_GC_UNTRACK(self); |
| 297 | if (self->weakreflist != NULL) |
| 298 | PyObject_ClearWeakRefs((PyObject *) self); |
| 299 | Py_CLEAR(self->dict); |
| 300 | Py_TYPE(self)->tp_free((PyObject *) self); |
| 301 | } |
| 302 | |
| 303 | /* Inquiry methods */ |
| 304 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 305 | PyDoc_STRVAR(iobase_seekable_doc, |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 306 | "Return whether object supports random access.\n" |
| 307 | "\n" |
Amaury Forgeot d'Arc | 616453c | 2010-09-06 22:31:52 +0000 | [diff] [blame] | 308 | "If False, seek(), tell() and truncate() will raise UnsupportedOperation.\n" |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 309 | "This method may need to do a test seek()."); |
| 310 | |
| 311 | static PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 312 | iobase_seekable(PyObject *self, PyObject *args) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 313 | { |
| 314 | Py_RETURN_FALSE; |
| 315 | } |
| 316 | |
| 317 | PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 318 | _PyIOBase_check_seekable(PyObject *self, PyObject *args) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 319 | { |
| 320 | PyObject *res = PyObject_CallMethodObjArgs(self, _PyIO_str_seekable, NULL); |
| 321 | if (res == NULL) |
| 322 | return NULL; |
| 323 | if (res != Py_True) { |
| 324 | Py_CLEAR(res); |
Antoine Pitrou | 0d739d7 | 2010-09-05 23:01:12 +0000 | [diff] [blame] | 325 | iobase_unsupported("File or stream is not seekable."); |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 326 | return NULL; |
| 327 | } |
| 328 | if (args == Py_True) { |
| 329 | Py_DECREF(res); |
| 330 | } |
| 331 | return res; |
| 332 | } |
| 333 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 334 | PyDoc_STRVAR(iobase_readable_doc, |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 335 | "Return whether object was opened for reading.\n" |
| 336 | "\n" |
Amaury Forgeot d'Arc | 616453c | 2010-09-06 22:31:52 +0000 | [diff] [blame] | 337 | "If False, read() will raise UnsupportedOperation."); |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 338 | |
| 339 | static PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 340 | iobase_readable(PyObject *self, PyObject *args) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 341 | { |
| 342 | Py_RETURN_FALSE; |
| 343 | } |
| 344 | |
| 345 | /* May be called with any object */ |
| 346 | PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 347 | _PyIOBase_check_readable(PyObject *self, PyObject *args) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 348 | { |
| 349 | PyObject *res = PyObject_CallMethodObjArgs(self, _PyIO_str_readable, NULL); |
| 350 | if (res == NULL) |
| 351 | return NULL; |
| 352 | if (res != Py_True) { |
| 353 | Py_CLEAR(res); |
Antoine Pitrou | 0d739d7 | 2010-09-05 23:01:12 +0000 | [diff] [blame] | 354 | iobase_unsupported("File or stream is not readable."); |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 355 | return NULL; |
| 356 | } |
| 357 | if (args == Py_True) { |
| 358 | Py_DECREF(res); |
| 359 | } |
| 360 | return res; |
| 361 | } |
| 362 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 363 | PyDoc_STRVAR(iobase_writable_doc, |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 364 | "Return whether object was opened for writing.\n" |
| 365 | "\n" |
Amaury Forgeot d'Arc | 616453c | 2010-09-06 22:31:52 +0000 | [diff] [blame] | 366 | "If False, write() will raise UnsupportedOperation."); |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 367 | |
| 368 | static PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 369 | iobase_writable(PyObject *self, PyObject *args) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 370 | { |
| 371 | Py_RETURN_FALSE; |
| 372 | } |
| 373 | |
| 374 | /* May be called with any object */ |
| 375 | PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 376 | _PyIOBase_check_writable(PyObject *self, PyObject *args) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 377 | { |
| 378 | PyObject *res = PyObject_CallMethodObjArgs(self, _PyIO_str_writable, NULL); |
| 379 | if (res == NULL) |
| 380 | return NULL; |
| 381 | if (res != Py_True) { |
| 382 | Py_CLEAR(res); |
Antoine Pitrou | 0d739d7 | 2010-09-05 23:01:12 +0000 | [diff] [blame] | 383 | iobase_unsupported("File or stream is not writable."); |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 384 | return NULL; |
| 385 | } |
| 386 | if (args == Py_True) { |
| 387 | Py_DECREF(res); |
| 388 | } |
| 389 | return res; |
| 390 | } |
| 391 | |
| 392 | /* Context manager */ |
| 393 | |
| 394 | static PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 395 | iobase_enter(PyObject *self, PyObject *args) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 396 | { |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 397 | if (_PyIOBase_check_closed(self, Py_True) == NULL) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 398 | return NULL; |
| 399 | |
| 400 | Py_INCREF(self); |
| 401 | return self; |
| 402 | } |
| 403 | |
| 404 | static PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 405 | iobase_exit(PyObject *self, PyObject *args) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 406 | { |
| 407 | return PyObject_CallMethodObjArgs(self, _PyIO_str_close, NULL); |
| 408 | } |
| 409 | |
| 410 | /* Lower-level APIs */ |
| 411 | |
| 412 | /* XXX Should these be present even if unimplemented? */ |
| 413 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 414 | PyDoc_STRVAR(iobase_fileno_doc, |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 415 | "Returns underlying file descriptor if one exists.\n" |
| 416 | "\n" |
| 417 | "An IOError is raised if the IO object does not use a file descriptor.\n"); |
| 418 | |
| 419 | static PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 420 | iobase_fileno(PyObject *self, PyObject *args) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 421 | { |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 422 | return iobase_unsupported("fileno"); |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 423 | } |
| 424 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 425 | PyDoc_STRVAR(iobase_isatty_doc, |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 426 | "Return whether this is an 'interactive' stream.\n" |
| 427 | "\n" |
| 428 | "Return False if it can't be determined.\n"); |
| 429 | |
| 430 | static PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 431 | iobase_isatty(PyObject *self, PyObject *args) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 432 | { |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 433 | if (_PyIOBase_check_closed(self, Py_True) == NULL) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 434 | return NULL; |
| 435 | Py_RETURN_FALSE; |
| 436 | } |
| 437 | |
| 438 | /* Readline(s) and writelines */ |
| 439 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 440 | PyDoc_STRVAR(iobase_readline_doc, |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 441 | "Read and return a line from the stream.\n" |
| 442 | "\n" |
| 443 | "If limit is specified, at most limit bytes will be read.\n" |
| 444 | "\n" |
Ezio Melotti | 16d2b47 | 2012-09-18 07:20:18 +0300 | [diff] [blame] | 445 | "The line terminator is always b'\\n' for binary files; for text\n" |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 446 | "files, the newlines argument to open can be used to select the line\n" |
| 447 | "terminator(s) recognized.\n"); |
| 448 | |
| 449 | static PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 450 | iobase_readline(PyObject *self, PyObject *args) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 451 | { |
| 452 | /* For backwards compatibility, a (slowish) readline(). */ |
| 453 | |
| 454 | Py_ssize_t limit = -1; |
| 455 | int has_peek = 0; |
| 456 | PyObject *buffer, *result; |
| 457 | Py_ssize_t old_size = -1; |
Martin v. Löwis | bd928fe | 2011-10-14 10:20:37 +0200 | [diff] [blame] | 458 | _Py_IDENTIFIER(read); |
Martin v. Löwis | 767046a | 2011-10-14 15:35:36 +0200 | [diff] [blame] | 459 | _Py_IDENTIFIER(peek); |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 460 | |
Benjamin Peterson | bf5ff76 | 2009-12-13 19:25:34 +0000 | [diff] [blame] | 461 | if (!PyArg_ParseTuple(args, "|O&:readline", &_PyIO_ConvertSsize_t, &limit)) { |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 462 | return NULL; |
| 463 | } |
| 464 | |
Martin v. Löwis | 767046a | 2011-10-14 15:35:36 +0200 | [diff] [blame] | 465 | if (_PyObject_HasAttrId(self, &PyId_peek)) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 466 | has_peek = 1; |
| 467 | |
| 468 | buffer = PyByteArray_FromStringAndSize(NULL, 0); |
| 469 | if (buffer == NULL) |
| 470 | return NULL; |
| 471 | |
| 472 | while (limit < 0 || Py_SIZE(buffer) < limit) { |
| 473 | Py_ssize_t nreadahead = 1; |
| 474 | PyObject *b; |
| 475 | |
| 476 | if (has_peek) { |
Martin v. Löwis | afe55bb | 2011-10-09 10:38:36 +0200 | [diff] [blame] | 477 | PyObject *readahead = _PyObject_CallMethodId(self, &PyId_peek, "i", 1); |
Gregory P. Smith | 5135992 | 2012-06-23 23:55:39 -0700 | [diff] [blame] | 478 | if (readahead == NULL) { |
| 479 | /* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals() |
| 480 | when EINTR occurs so we needn't do it ourselves. */ |
| 481 | if (_PyIO_trap_eintr()) { |
| 482 | continue; |
| 483 | } |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 484 | goto fail; |
Gregory P. Smith | 5135992 | 2012-06-23 23:55:39 -0700 | [diff] [blame] | 485 | } |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 486 | if (!PyBytes_Check(readahead)) { |
| 487 | PyErr_Format(PyExc_IOError, |
| 488 | "peek() should have returned a bytes object, " |
| 489 | "not '%.200s'", Py_TYPE(readahead)->tp_name); |
| 490 | Py_DECREF(readahead); |
| 491 | goto fail; |
| 492 | } |
| 493 | if (PyBytes_GET_SIZE(readahead) > 0) { |
| 494 | Py_ssize_t n = 0; |
| 495 | const char *buf = PyBytes_AS_STRING(readahead); |
| 496 | if (limit >= 0) { |
| 497 | do { |
| 498 | if (n >= PyBytes_GET_SIZE(readahead) || n >= limit) |
| 499 | break; |
| 500 | if (buf[n++] == '\n') |
| 501 | break; |
| 502 | } while (1); |
| 503 | } |
| 504 | else { |
| 505 | do { |
| 506 | if (n >= PyBytes_GET_SIZE(readahead)) |
| 507 | break; |
| 508 | if (buf[n++] == '\n') |
| 509 | break; |
| 510 | } while (1); |
| 511 | } |
| 512 | nreadahead = n; |
| 513 | } |
| 514 | Py_DECREF(readahead); |
| 515 | } |
| 516 | |
Martin v. Löwis | afe55bb | 2011-10-09 10:38:36 +0200 | [diff] [blame] | 517 | b = _PyObject_CallMethodId(self, &PyId_read, "n", nreadahead); |
Gregory P. Smith | 5135992 | 2012-06-23 23:55:39 -0700 | [diff] [blame] | 518 | if (b == NULL) { |
| 519 | /* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals() |
| 520 | when EINTR occurs so we needn't do it ourselves. */ |
| 521 | if (_PyIO_trap_eintr()) { |
| 522 | continue; |
| 523 | } |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 524 | goto fail; |
Gregory P. Smith | 5135992 | 2012-06-23 23:55:39 -0700 | [diff] [blame] | 525 | } |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 526 | if (!PyBytes_Check(b)) { |
| 527 | PyErr_Format(PyExc_IOError, |
| 528 | "read() should have returned a bytes object, " |
| 529 | "not '%.200s'", Py_TYPE(b)->tp_name); |
| 530 | Py_DECREF(b); |
| 531 | goto fail; |
| 532 | } |
| 533 | if (PyBytes_GET_SIZE(b) == 0) { |
| 534 | Py_DECREF(b); |
| 535 | break; |
| 536 | } |
| 537 | |
| 538 | old_size = PyByteArray_GET_SIZE(buffer); |
| 539 | PyByteArray_Resize(buffer, old_size + PyBytes_GET_SIZE(b)); |
| 540 | memcpy(PyByteArray_AS_STRING(buffer) + old_size, |
| 541 | PyBytes_AS_STRING(b), PyBytes_GET_SIZE(b)); |
| 542 | |
| 543 | Py_DECREF(b); |
| 544 | |
| 545 | if (PyByteArray_AS_STRING(buffer)[PyByteArray_GET_SIZE(buffer) - 1] == '\n') |
| 546 | break; |
| 547 | } |
| 548 | |
| 549 | result = PyBytes_FromStringAndSize(PyByteArray_AS_STRING(buffer), |
| 550 | PyByteArray_GET_SIZE(buffer)); |
| 551 | Py_DECREF(buffer); |
| 552 | return result; |
| 553 | fail: |
| 554 | Py_DECREF(buffer); |
| 555 | return NULL; |
| 556 | } |
| 557 | |
| 558 | static PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 559 | iobase_iter(PyObject *self) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 560 | { |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 561 | if (_PyIOBase_check_closed(self, Py_True) == NULL) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 562 | return NULL; |
| 563 | |
| 564 | Py_INCREF(self); |
| 565 | return self; |
| 566 | } |
| 567 | |
| 568 | static PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 569 | iobase_iternext(PyObject *self) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 570 | { |
| 571 | PyObject *line = PyObject_CallMethodObjArgs(self, _PyIO_str_readline, NULL); |
| 572 | |
| 573 | if (line == NULL) |
| 574 | return NULL; |
| 575 | |
| 576 | if (PyObject_Size(line) == 0) { |
| 577 | Py_DECREF(line); |
| 578 | return NULL; |
| 579 | } |
| 580 | |
| 581 | return line; |
| 582 | } |
| 583 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 584 | PyDoc_STRVAR(iobase_readlines_doc, |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 585 | "Return a list of lines from the stream.\n" |
| 586 | "\n" |
| 587 | "hint can be specified to control the number of lines read: no more\n" |
| 588 | "lines will be read if the total size (in bytes/characters) of all\n" |
| 589 | "lines so far exceeds hint."); |
| 590 | |
| 591 | static PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 592 | iobase_readlines(PyObject *self, PyObject *args) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 593 | { |
| 594 | Py_ssize_t hint = -1, length = 0; |
Benjamin Peterson | 0551613 | 2009-12-13 19:28:09 +0000 | [diff] [blame] | 595 | PyObject *result; |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 596 | |
Benjamin Peterson | bf5ff76 | 2009-12-13 19:25:34 +0000 | [diff] [blame] | 597 | if (!PyArg_ParseTuple(args, "|O&:readlines", &_PyIO_ConvertSsize_t, &hint)) { |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 598 | return NULL; |
| 599 | } |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 600 | |
| 601 | result = PyList_New(0); |
| 602 | if (result == NULL) |
| 603 | return NULL; |
| 604 | |
| 605 | if (hint <= 0) { |
| 606 | /* XXX special-casing this made sense in the Python version in order |
| 607 | to remove the bytecode interpretation overhead, but it could |
| 608 | probably be removed here. */ |
Martin v. Löwis | bd928fe | 2011-10-14 10:20:37 +0200 | [diff] [blame] | 609 | _Py_IDENTIFIER(extend); |
Martin v. Löwis | afe55bb | 2011-10-09 10:38:36 +0200 | [diff] [blame] | 610 | PyObject *ret = _PyObject_CallMethodId(result, &PyId_extend, "O", self); |
| 611 | |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 612 | if (ret == NULL) { |
| 613 | Py_DECREF(result); |
| 614 | return NULL; |
| 615 | } |
| 616 | Py_DECREF(ret); |
| 617 | return result; |
| 618 | } |
| 619 | |
| 620 | while (1) { |
| 621 | PyObject *line = PyIter_Next(self); |
| 622 | if (line == NULL) { |
| 623 | if (PyErr_Occurred()) { |
| 624 | Py_DECREF(result); |
| 625 | return NULL; |
| 626 | } |
| 627 | else |
| 628 | break; /* StopIteration raised */ |
| 629 | } |
| 630 | |
| 631 | if (PyList_Append(result, line) < 0) { |
| 632 | Py_DECREF(line); |
| 633 | Py_DECREF(result); |
| 634 | return NULL; |
| 635 | } |
| 636 | length += PyObject_Size(line); |
| 637 | Py_DECREF(line); |
| 638 | |
| 639 | if (length > hint) |
| 640 | break; |
| 641 | } |
| 642 | return result; |
| 643 | } |
| 644 | |
| 645 | static PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 646 | iobase_writelines(PyObject *self, PyObject *args) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 647 | { |
| 648 | PyObject *lines, *iter, *res; |
| 649 | |
| 650 | if (!PyArg_ParseTuple(args, "O:writelines", &lines)) { |
| 651 | return NULL; |
| 652 | } |
| 653 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 654 | if (_PyIOBase_check_closed(self, Py_True) == NULL) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 655 | return NULL; |
| 656 | |
| 657 | iter = PyObject_GetIter(lines); |
| 658 | if (iter == NULL) |
| 659 | return NULL; |
| 660 | |
| 661 | while (1) { |
| 662 | PyObject *line = PyIter_Next(iter); |
| 663 | if (line == NULL) { |
| 664 | if (PyErr_Occurred()) { |
| 665 | Py_DECREF(iter); |
| 666 | return NULL; |
| 667 | } |
| 668 | else |
| 669 | break; /* Stop Iteration */ |
| 670 | } |
| 671 | |
Gregory P. Smith | b9817b0 | 2013-02-01 13:03:39 -0800 | [diff] [blame] | 672 | res = NULL; |
| 673 | do { |
| 674 | res = PyObject_CallMethodObjArgs(self, _PyIO_str_write, line, NULL); |
| 675 | } while (res == NULL && _PyIO_trap_eintr()); |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 676 | Py_DECREF(line); |
| 677 | if (res == NULL) { |
| 678 | Py_DECREF(iter); |
| 679 | return NULL; |
| 680 | } |
| 681 | Py_DECREF(res); |
| 682 | } |
| 683 | Py_DECREF(iter); |
| 684 | Py_RETURN_NONE; |
| 685 | } |
| 686 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 687 | static PyMethodDef iobase_methods[] = { |
| 688 | {"seek", iobase_seek, METH_VARARGS, iobase_seek_doc}, |
| 689 | {"tell", iobase_tell, METH_NOARGS, iobase_tell_doc}, |
| 690 | {"truncate", iobase_truncate, METH_VARARGS, iobase_truncate_doc}, |
| 691 | {"flush", iobase_flush, METH_NOARGS, iobase_flush_doc}, |
| 692 | {"close", iobase_close, METH_NOARGS, iobase_close_doc}, |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 693 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 694 | {"seekable", iobase_seekable, METH_NOARGS, iobase_seekable_doc}, |
| 695 | {"readable", iobase_readable, METH_NOARGS, iobase_readable_doc}, |
| 696 | {"writable", iobase_writable, METH_NOARGS, iobase_writable_doc}, |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 697 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 698 | {"_checkClosed", _PyIOBase_check_closed, METH_NOARGS}, |
| 699 | {"_checkSeekable", _PyIOBase_check_seekable, METH_NOARGS}, |
| 700 | {"_checkReadable", _PyIOBase_check_readable, METH_NOARGS}, |
| 701 | {"_checkWritable", _PyIOBase_check_writable, METH_NOARGS}, |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 702 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 703 | {"fileno", iobase_fileno, METH_NOARGS, iobase_fileno_doc}, |
| 704 | {"isatty", iobase_isatty, METH_NOARGS, iobase_isatty_doc}, |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 705 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 706 | {"__enter__", iobase_enter, METH_NOARGS}, |
| 707 | {"__exit__", iobase_exit, METH_VARARGS}, |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 708 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 709 | {"readline", iobase_readline, METH_VARARGS, iobase_readline_doc}, |
| 710 | {"readlines", iobase_readlines, METH_VARARGS, iobase_readlines_doc}, |
| 711 | {"writelines", iobase_writelines, METH_VARARGS}, |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 712 | |
| 713 | {NULL, NULL} |
| 714 | }; |
| 715 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 716 | static PyGetSetDef iobase_getset[] = { |
Benjamin Peterson | 23d7f12 | 2012-02-19 20:02:57 -0500 | [diff] [blame] | 717 | {"__dict__", PyObject_GenericGetDict, NULL, NULL}, |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 718 | {"closed", (getter)iobase_closed_get, NULL, NULL}, |
Benjamin Peterson | 1fea321 | 2009-04-19 03:15:20 +0000 | [diff] [blame] | 719 | {NULL} |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 720 | }; |
| 721 | |
| 722 | |
| 723 | PyTypeObject PyIOBase_Type = { |
| 724 | PyVarObject_HEAD_INIT(NULL, 0) |
| 725 | "_io._IOBase", /*tp_name*/ |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 726 | sizeof(iobase), /*tp_basicsize*/ |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 727 | 0, /*tp_itemsize*/ |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 728 | (destructor)iobase_dealloc, /*tp_dealloc*/ |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 729 | 0, /*tp_print*/ |
| 730 | 0, /*tp_getattr*/ |
| 731 | 0, /*tp_setattr*/ |
| 732 | 0, /*tp_compare */ |
| 733 | 0, /*tp_repr*/ |
| 734 | 0, /*tp_as_number*/ |
| 735 | 0, /*tp_as_sequence*/ |
| 736 | 0, /*tp_as_mapping*/ |
| 737 | 0, /*tp_hash */ |
| 738 | 0, /*tp_call*/ |
| 739 | 0, /*tp_str*/ |
| 740 | 0, /*tp_getattro*/ |
| 741 | 0, /*tp_setattro*/ |
| 742 | 0, /*tp_as_buffer*/ |
| 743 | Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
| 744 | | Py_TPFLAGS_HAVE_GC, /*tp_flags*/ |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 745 | iobase_doc, /* tp_doc */ |
| 746 | (traverseproc)iobase_traverse, /* tp_traverse */ |
| 747 | (inquiry)iobase_clear, /* tp_clear */ |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 748 | 0, /* tp_richcompare */ |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 749 | offsetof(iobase, weakreflist), /* tp_weaklistoffset */ |
| 750 | iobase_iter, /* tp_iter */ |
| 751 | iobase_iternext, /* tp_iternext */ |
| 752 | iobase_methods, /* tp_methods */ |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 753 | 0, /* tp_members */ |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 754 | iobase_getset, /* tp_getset */ |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 755 | 0, /* tp_base */ |
| 756 | 0, /* tp_dict */ |
| 757 | 0, /* tp_descr_get */ |
| 758 | 0, /* tp_descr_set */ |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 759 | offsetof(iobase, dict), /* tp_dictoffset */ |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 760 | 0, /* tp_init */ |
| 761 | 0, /* tp_alloc */ |
| 762 | PyType_GenericNew, /* tp_new */ |
| 763 | }; |
| 764 | |
| 765 | |
| 766 | /* |
| 767 | * RawIOBase class, Inherits from IOBase. |
| 768 | */ |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 769 | PyDoc_STRVAR(rawiobase_doc, |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 770 | "Base class for raw binary I/O."); |
| 771 | |
| 772 | /* |
| 773 | * The read() method is implemented by calling readinto(); derived classes |
| 774 | * that want to support read() only need to implement readinto() as a |
| 775 | * primitive operation. In general, readinto() can be more efficient than |
| 776 | * read(). |
| 777 | * |
| 778 | * (It would be tempting to also provide an implementation of readinto() in |
| 779 | * terms of read(), in case the latter is a more suitable primitive operation, |
| 780 | * but that would lead to nasty recursion in case a subclass doesn't implement |
| 781 | * either.) |
| 782 | */ |
| 783 | |
| 784 | static PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 785 | rawiobase_read(PyObject *self, PyObject *args) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 786 | { |
| 787 | Py_ssize_t n = -1; |
| 788 | PyObject *b, *res; |
| 789 | |
| 790 | if (!PyArg_ParseTuple(args, "|n:read", &n)) { |
| 791 | return NULL; |
| 792 | } |
| 793 | |
Martin v. Löwis | afe55bb | 2011-10-09 10:38:36 +0200 | [diff] [blame] | 794 | if (n < 0) { |
Martin v. Löwis | bd928fe | 2011-10-14 10:20:37 +0200 | [diff] [blame] | 795 | _Py_IDENTIFIER(readall); |
Martin v. Löwis | afe55bb | 2011-10-09 10:38:36 +0200 | [diff] [blame] | 796 | |
| 797 | return _PyObject_CallMethodId(self, &PyId_readall, NULL); |
| 798 | } |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 799 | |
| 800 | /* TODO: allocate a bytes object directly instead and manually construct |
| 801 | a writable memoryview pointing to it. */ |
| 802 | b = PyByteArray_FromStringAndSize(NULL, n); |
| 803 | if (b == NULL) |
| 804 | return NULL; |
| 805 | |
| 806 | res = PyObject_CallMethodObjArgs(self, _PyIO_str_readinto, b, NULL); |
Antoine Pitrou | 328ec74 | 2010-09-14 18:37:24 +0000 | [diff] [blame] | 807 | if (res == NULL || res == Py_None) { |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 808 | Py_DECREF(b); |
Antoine Pitrou | 328ec74 | 2010-09-14 18:37:24 +0000 | [diff] [blame] | 809 | return res; |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 810 | } |
| 811 | |
| 812 | n = PyNumber_AsSsize_t(res, PyExc_ValueError); |
| 813 | Py_DECREF(res); |
| 814 | if (n == -1 && PyErr_Occurred()) { |
| 815 | Py_DECREF(b); |
| 816 | return NULL; |
| 817 | } |
| 818 | |
| 819 | res = PyBytes_FromStringAndSize(PyByteArray_AsString(b), n); |
| 820 | Py_DECREF(b); |
| 821 | return res; |
| 822 | } |
| 823 | |
| 824 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 825 | PyDoc_STRVAR(rawiobase_readall_doc, |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 826 | "Read until EOF, using multiple read() call."); |
| 827 | |
| 828 | static PyObject * |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 829 | rawiobase_readall(PyObject *self, PyObject *args) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 830 | { |
Antoine Pitrou | 00a9b73 | 2009-03-29 19:19:49 +0000 | [diff] [blame] | 831 | int r; |
| 832 | PyObject *chunks = PyList_New(0); |
| 833 | PyObject *result; |
| 834 | |
| 835 | if (chunks == NULL) |
| 836 | return NULL; |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 837 | |
| 838 | while (1) { |
Martin v. Löwis | bd928fe | 2011-10-14 10:20:37 +0200 | [diff] [blame] | 839 | _Py_IDENTIFIER(read); |
Martin v. Löwis | afe55bb | 2011-10-09 10:38:36 +0200 | [diff] [blame] | 840 | PyObject *data = _PyObject_CallMethodId(self, &PyId_read, |
| 841 | "i", DEFAULT_BUFFER_SIZE); |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 842 | if (!data) { |
Gregory P. Smith | 5135992 | 2012-06-23 23:55:39 -0700 | [diff] [blame] | 843 | /* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals() |
| 844 | when EINTR occurs so we needn't do it ourselves. */ |
| 845 | if (_PyIO_trap_eintr()) { |
| 846 | continue; |
| 847 | } |
Antoine Pitrou | 00a9b73 | 2009-03-29 19:19:49 +0000 | [diff] [blame] | 848 | Py_DECREF(chunks); |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 849 | return NULL; |
| 850 | } |
Victor Stinner | a80987f | 2011-05-25 22:47:16 +0200 | [diff] [blame] | 851 | if (data == Py_None) { |
| 852 | if (PyList_GET_SIZE(chunks) == 0) { |
| 853 | Py_DECREF(chunks); |
| 854 | return data; |
| 855 | } |
| 856 | Py_DECREF(data); |
| 857 | break; |
| 858 | } |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 859 | if (!PyBytes_Check(data)) { |
Antoine Pitrou | 00a9b73 | 2009-03-29 19:19:49 +0000 | [diff] [blame] | 860 | Py_DECREF(chunks); |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 861 | Py_DECREF(data); |
| 862 | PyErr_SetString(PyExc_TypeError, "read() should return bytes"); |
| 863 | return NULL; |
| 864 | } |
Antoine Pitrou | 00a9b73 | 2009-03-29 19:19:49 +0000 | [diff] [blame] | 865 | if (PyBytes_GET_SIZE(data) == 0) { |
| 866 | /* EOF */ |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 867 | Py_DECREF(data); |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 868 | break; |
Antoine Pitrou | 00a9b73 | 2009-03-29 19:19:49 +0000 | [diff] [blame] | 869 | } |
| 870 | r = PyList_Append(chunks, data); |
| 871 | Py_DECREF(data); |
| 872 | if (r < 0) { |
| 873 | Py_DECREF(chunks); |
| 874 | return NULL; |
| 875 | } |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 876 | } |
Antoine Pitrou | 00a9b73 | 2009-03-29 19:19:49 +0000 | [diff] [blame] | 877 | result = _PyBytes_Join(_PyIO_empty_bytes, chunks); |
| 878 | Py_DECREF(chunks); |
| 879 | return result; |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 880 | } |
| 881 | |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 882 | static PyMethodDef rawiobase_methods[] = { |
| 883 | {"read", rawiobase_read, METH_VARARGS}, |
| 884 | {"readall", rawiobase_readall, METH_NOARGS, rawiobase_readall_doc}, |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 885 | {NULL, NULL} |
| 886 | }; |
| 887 | |
| 888 | PyTypeObject PyRawIOBase_Type = { |
| 889 | PyVarObject_HEAD_INIT(NULL, 0) |
| 890 | "_io._RawIOBase", /*tp_name*/ |
| 891 | 0, /*tp_basicsize*/ |
| 892 | 0, /*tp_itemsize*/ |
| 893 | 0, /*tp_dealloc*/ |
| 894 | 0, /*tp_print*/ |
| 895 | 0, /*tp_getattr*/ |
| 896 | 0, /*tp_setattr*/ |
| 897 | 0, /*tp_compare */ |
| 898 | 0, /*tp_repr*/ |
| 899 | 0, /*tp_as_number*/ |
| 900 | 0, /*tp_as_sequence*/ |
| 901 | 0, /*tp_as_mapping*/ |
| 902 | 0, /*tp_hash */ |
| 903 | 0, /*tp_call*/ |
| 904 | 0, /*tp_str*/ |
| 905 | 0, /*tp_getattro*/ |
| 906 | 0, /*tp_setattro*/ |
| 907 | 0, /*tp_as_buffer*/ |
| 908 | Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 909 | rawiobase_doc, /* tp_doc */ |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 910 | 0, /* tp_traverse */ |
| 911 | 0, /* tp_clear */ |
| 912 | 0, /* tp_richcompare */ |
| 913 | 0, /* tp_weaklistoffset */ |
| 914 | 0, /* tp_iter */ |
| 915 | 0, /* tp_iternext */ |
Benjamin Peterson | 680bf1a | 2009-06-12 02:07:12 +0000 | [diff] [blame] | 916 | rawiobase_methods, /* tp_methods */ |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 917 | 0, /* tp_members */ |
| 918 | 0, /* tp_getset */ |
| 919 | &PyIOBase_Type, /* tp_base */ |
| 920 | 0, /* tp_dict */ |
| 921 | 0, /* tp_descr_get */ |
| 922 | 0, /* tp_descr_set */ |
| 923 | 0, /* tp_dictoffset */ |
| 924 | 0, /* tp_init */ |
| 925 | 0, /* tp_alloc */ |
| 926 | 0, /* tp_new */ |
| 927 | }; |