Changeset 388 for python/vendor/current/Modules/cStringIO.c
- Timestamp:
- Mar 19, 2014, 11:11:30 AM (11 years ago)
- File:
-
- 1 edited
-
python/vendor/current/Modules/cStringIO.c (modified) (30 diffs)
Legend:
- Unmodified
- Added
- Removed
-
python/vendor/current/Modules/cStringIO.c
r2 r388 34 34 "cStringIO.c,v 1.29 1999/06/15 14:10:27 jim Exp\n"); 35 35 36 /* Declaration for file-like objects that manage data as strings 36 /* Declaration for file-like objects that manage data as strings 37 37 38 38 The IOobject type should be though of as a common base type for … … 67 67 char *buf; 68 68 Py_ssize_t pos, string_size; 69 /* We store a reference to the object here in order to keep 70 the buffer alive during the lifetime of the Iobject. */ 71 PyObject *pbuf; 69 Py_buffer pbuf; 72 70 } Iobject; 73 71 … … 78 76 static int 79 77 IO__opencheck(IOobject *self) { 80 81 82 83 84 85 78 if (!self->buf) { 79 PyErr_SetString(PyExc_ValueError, 80 "I/O operation on closed file"); 81 return 0; 82 } 83 return 1; 86 84 } 87 85 … … 89 87 IO_get_closed(IOobject *self, void *closure) 90 88 { 91 92 93 94 95 96 89 PyObject *result = Py_False; 90 91 if (self->buf == NULL) 92 result = Py_True; 93 Py_INCREF(result); 94 return result; 97 95 } 98 96 99 97 static PyGetSetDef file_getsetlist[] = { 100 101 98 {"closed", (getter)IO_get_closed, NULL, "True if the file is closed"}, 99 {0}, 102 100 }; 103 101 … … 105 103 IO_flush(IOobject *self, PyObject *unused) { 106 104 107 108 109 110 105 if (!IO__opencheck(self)) return NULL; 106 107 Py_INCREF(Py_None); 108 return Py_None; 111 109 } 112 110 … … 119 117 static PyObject * 120 118 IO_cgetval(PyObject *self) { 121 122 123 124 119 if (!IO__opencheck(IOOOBJECT(self))) return NULL; 120 assert(IOOOBJECT(self)->pos >= 0); 121 return PyString_FromStringAndSize(((IOobject*)self)->buf, 122 ((IOobject*)self)->pos); 125 123 } 126 124 127 125 static PyObject * 128 126 IO_getval(IOobject *self, PyObject *args) { 129 PyObject *use_pos=Py_None; 130 Py_ssize_t s; 131 132 if (!IO__opencheck(self)) return NULL; 133 if (!PyArg_UnpackTuple(args,"getval", 0, 1,&use_pos)) return NULL; 134 135 if (PyObject_IsTrue(use_pos)) { 136 s=self->pos; 137 if (s > self->string_size) s=self->string_size; 138 } 139 else 140 s=self->string_size; 141 assert(self->pos >= 0); 142 return PyString_FromStringAndSize(self->buf, s); 127 PyObject *use_pos=Py_None; 128 int b; 129 Py_ssize_t s; 130 131 if (!IO__opencheck(self)) return NULL; 132 if (!PyArg_UnpackTuple(args,"getval", 0, 1,&use_pos)) return NULL; 133 134 b = PyObject_IsTrue(use_pos); 135 if (b < 0) 136 return NULL; 137 if (b) { 138 s=self->pos; 139 if (s > self->string_size) s=self->string_size; 140 } 141 else 142 s=self->string_size; 143 assert(self->pos >= 0); 144 return PyString_FromStringAndSize(self->buf, s); 143 145 } 144 146 … … 147 149 static PyObject * 148 150 IO_isatty(IOobject *self, PyObject *unused) { 149 150 151 151 if (!IO__opencheck(self)) return NULL; 152 Py_INCREF(Py_False); 153 return Py_False; 152 154 } 153 155 … … 157 159 static int 158 160 IO_cread(PyObject *self, char **output, Py_ssize_t n) { 159 Py_ssize_t l; 160 161 if (!IO__opencheck(IOOOBJECT(self))) return -1; 162 assert(IOOOBJECT(self)->pos >= 0); 163 assert(IOOOBJECT(self)->string_size >= 0); 164 l = ((IOobject*)self)->string_size - ((IOobject*)self)->pos; 165 if (n < 0 || n > l) { 166 n = l; 167 if (n < 0) n=0; 168 } 169 170 *output=((IOobject*)self)->buf + ((IOobject*)self)->pos; 171 ((IOobject*)self)->pos += n; 172 return n; 161 Py_ssize_t l; 162 163 if (!IO__opencheck(IOOOBJECT(self))) return -1; 164 assert(IOOOBJECT(self)->pos >= 0); 165 assert(IOOOBJECT(self)->string_size >= 0); 166 l = ((IOobject*)self)->string_size - ((IOobject*)self)->pos; 167 if (n < 0 || n > l) { 168 n = l; 169 if (n < 0) n=0; 170 } 171 if (n > INT_MAX) { 172 PyErr_SetString(PyExc_OverflowError, 173 "length too large"); 174 return -1; 175 } 176 177 *output=((IOobject*)self)->buf + ((IOobject*)self)->pos; 178 ((IOobject*)self)->pos += n; 179 return (int)n; 173 180 } 174 181 175 182 static PyObject * 176 183 IO_read(IOobject *self, PyObject *args) { 177 178 179 180 181 182 183 184 184 Py_ssize_t n = -1; 185 char *output = NULL; 186 187 if (!PyArg_ParseTuple(args, "|n:read", &n)) return NULL; 188 189 if ( (n=IO_cread((PyObject*)self,&output,n)) < 0) return NULL; 190 191 return PyString_FromStringAndSize(output, n); 185 192 } 186 193 … … 189 196 static int 190 197 IO_creadline(PyObject *self, char **output) { 191 char *n, *s; 192 Py_ssize_t l; 193 194 if (!IO__opencheck(IOOOBJECT(self))) return -1; 195 196 for (n = ((IOobject*)self)->buf + ((IOobject*)self)->pos, 197 s = ((IOobject*)self)->buf + ((IOobject*)self)->string_size; 198 n < s && *n != '\n'; n++); 199 200 if (n < s) n++; 201 202 *output=((IOobject*)self)->buf + ((IOobject*)self)->pos; 203 l = n - ((IOobject*)self)->buf - ((IOobject*)self)->pos; 204 205 assert(IOOOBJECT(self)->pos <= PY_SSIZE_T_MAX - l); 206 assert(IOOOBJECT(self)->pos >= 0); 207 assert(IOOOBJECT(self)->string_size >= 0); 208 209 ((IOobject*)self)->pos += l; 210 return (int)l; 198 char *n, *start, *end; 199 Py_ssize_t len; 200 201 if (!IO__opencheck(IOOOBJECT(self))) return -1; 202 203 n = start = ((IOobject*)self)->buf + ((IOobject*)self)->pos; 204 end = ((IOobject*)self)->buf + ((IOobject*)self)->string_size; 205 while (n < end && *n != '\n') 206 n++; 207 208 if (n < end) n++; 209 210 len = n - start; 211 if (len > INT_MAX) 212 len = INT_MAX; 213 214 *output=start; 215 216 assert(IOOOBJECT(self)->pos <= PY_SSIZE_T_MAX - len); 217 assert(IOOOBJECT(self)->pos >= 0); 218 assert(IOOOBJECT(self)->string_size >= 0); 219 220 ((IOobject*)self)->pos += len; 221 return (int)len; 211 222 } 212 223 213 224 static PyObject * 214 225 IO_readline(IOobject *self, PyObject *args) { 215 int n, m=-1; 216 char *output; 217 218 if (args) 219 if (!PyArg_ParseTuple(args, "|i:readline", &m)) return NULL; 220 221 if( (n=IO_creadline((PyObject*)self,&output)) < 0) return NULL; 222 if (m >= 0 && m < n) { 223 m = n - m; 224 n -= m; 225 self->pos -= m; 226 int n, m=-1; 227 char *output; 228 229 if (args) 230 if (!PyArg_ParseTuple(args, "|i:readline", &m)) return NULL; 231 232 if( (n=IO_creadline((PyObject*)self,&output)) < 0) return NULL; 233 if (m >= 0 && m < n) { 234 m = n - m; 235 n -= m; 236 self->pos -= m; 237 } 238 assert(IOOOBJECT(self)->pos >= 0); 239 return PyString_FromStringAndSize(output, n); 240 } 241 242 PyDoc_STRVAR(IO_readlines__doc__, "readlines() -- Read all lines"); 243 244 static PyObject * 245 IO_readlines(IOobject *self, PyObject *args) { 246 int n; 247 char *output; 248 PyObject *result, *line; 249 Py_ssize_t hint = 0, length = 0; 250 251 if (!PyArg_ParseTuple(args, "|n:readlines", &hint)) return NULL; 252 253 result = PyList_New(0); 254 if (!result) 255 return NULL; 256 257 while (1){ 258 if ( (n = IO_creadline((PyObject*)self,&output)) < 0) 259 goto err; 260 if (n == 0) 261 break; 262 line = PyString_FromStringAndSize (output, n); 263 if (!line) 264 goto err; 265 if (PyList_Append (result, line) == -1) { 266 Py_DECREF (line); 267 goto err; 226 268 } 227 assert(IOOOBJECT(self)->pos >= 0); 228 return PyString_FromStringAndSize(output, n); 229 } 230 231 PyDoc_STRVAR(IO_readlines__doc__, "readlines() -- Read all lines"); 232 233 static PyObject * 234 IO_readlines(IOobject *self, PyObject *args) { 235 int n; 236 char *output; 237 PyObject *result, *line; 238 int hint = 0, length = 0; 239 240 if (!PyArg_ParseTuple(args, "|i:readlines", &hint)) return NULL; 241 242 result = PyList_New(0); 243 if (!result) 244 return NULL; 245 246 while (1){ 247 if ( (n = IO_creadline((PyObject*)self,&output)) < 0) 248 goto err; 249 if (n == 0) 250 break; 251 line = PyString_FromStringAndSize (output, n); 252 if (!line) 253 goto err; 254 if (PyList_Append (result, line) == -1) { 255 Py_DECREF (line); 256 goto err; 257 } 258 Py_DECREF (line); 259 length += n; 260 if (hint > 0 && length >= hint) 261 break; 262 } 263 return result; 269 Py_DECREF (line); 270 length += n; 271 if (hint > 0 && length >= hint) 272 break; 273 } 274 return result; 264 275 err: 265 266 276 Py_DECREF(result); 277 return NULL; 267 278 } 268 279 … … 273 284 IO_reset(IOobject *self, PyObject *unused) { 274 285 275 276 277 278 279 280 286 if (!IO__opencheck(self)) return NULL; 287 288 self->pos = 0; 289 290 Py_INCREF(Py_None); 291 return Py_None; 281 292 } 282 293 … … 286 297 IO_tell(IOobject *self, PyObject *unused) { 287 298 288 289 290 291 299 if (!IO__opencheck(self)) return NULL; 300 301 assert(self->pos >= 0); 302 return PyInt_FromSsize_t(self->pos); 292 303 } 293 304 … … 297 308 static PyObject * 298 309 IO_truncate(IOobject *self, PyObject *args) { 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 310 Py_ssize_t pos = -1; 311 312 if (!IO__opencheck(self)) return NULL; 313 if (!PyArg_ParseTuple(args, "|n:truncate", &pos)) return NULL; 314 315 if (PyTuple_Size(args) == 0) { 316 /* No argument passed, truncate to current position */ 317 pos = self->pos; 318 } 319 320 if (pos < 0) { 321 errno = EINVAL; 322 PyErr_SetFromErrno(PyExc_IOError); 323 return NULL; 324 } 325 326 if (self->string_size > pos) self->string_size = pos; 327 self->pos = self->string_size; 328 329 Py_INCREF(Py_None); 330 return Py_None; 320 331 } 321 332 … … 323 334 IO_iternext(Iobject *self) 324 335 { 325 326 327 328 329 330 331 332 333 334 336 PyObject *next; 337 next = IO_readline((IOobject *)self, NULL); 338 if (!next) 339 return NULL; 340 if (!PyString_GET_SIZE(next)) { 341 Py_DECREF(next); 342 PyErr_SetNone(PyExc_StopIteration); 343 return NULL; 344 } 345 return next; 335 346 } 336 347 … … 340 351 /* Read-write object methods */ 341 352 342 PyDoc_STRVAR( O_seek__doc__,353 PyDoc_STRVAR(IO_seek__doc__, 343 354 "seek(position) -- set the current position\n" 344 355 "seek(position, mode) -- mode 0: absolute; 1: relative; 2: relative to EOF"); 345 356 346 357 static PyObject * 347 O_seek(Oobject *self, PyObject *args) { 348 Py_ssize_t position; 349 int mode = 0; 350 351 if (!IO__opencheck(IOOOBJECT(self))) return NULL; 352 if (!PyArg_ParseTuple(args, "n|i:seek", &position, &mode)) 353 return NULL; 354 355 if (mode == 2) { 356 position += self->string_size; 357 } 358 else if (mode == 1) { 359 position += self->pos; 360 } 361 362 if (position > self->buf_size) { 363 char *newbuf; 364 self->buf_size*=2; 365 if (self->buf_size <= position) self->buf_size=position+1; 366 newbuf = (char*) realloc(self->buf,self->buf_size); 367 if (!newbuf) { 368 free(self->buf); 369 self->buf = 0; 370 self->buf_size=self->pos=0; 371 return PyErr_NoMemory(); 372 } 373 self->buf = newbuf; 374 } 375 else if (position < 0) position=0; 376 377 self->pos=position; 378 379 while (--position >= self->string_size) self->buf[position]=0; 380 381 Py_INCREF(Py_None); 382 return Py_None; 358 IO_seek(Iobject *self, PyObject *args) { 359 Py_ssize_t position; 360 int mode = 0; 361 362 if (!IO__opencheck(IOOOBJECT(self))) return NULL; 363 if (!PyArg_ParseTuple(args, "n|i:seek", &position, &mode)) 364 return NULL; 365 366 if (mode == 2) { 367 position += self->string_size; 368 } 369 else if (mode == 1) { 370 position += self->pos; 371 } 372 373 if (position < 0) position=0; 374 375 self->pos=position; 376 377 Py_INCREF(Py_None); 378 return Py_None; 383 379 } 384 380 … … 389 385 390 386 static int 391 O_cwrite(PyObject *self, const char *c, Py_ssize_t l) { 392 Py_ssize_t newl; 393 Oobject *oself; 394 char *newbuf; 395 396 if (!IO__opencheck(IOOOBJECT(self))) return -1; 397 oself = (Oobject *)self; 398 399 newl = oself->pos+l; 400 if (newl >= oself->buf_size) { 401 oself->buf_size *= 2; 402 if (oself->buf_size <= newl) { 403 assert(newl + 1 < INT_MAX); 404 oself->buf_size = (int)(newl+1); 405 } 406 newbuf = (char*)realloc(oself->buf, oself->buf_size); 407 if (!newbuf) { 408 PyErr_SetString(PyExc_MemoryError,"out of memory"); 409 free(oself->buf); 410 oself->buf = 0; 411 oself->buf_size = oself->pos = 0; 412 return -1; 413 } 414 oself->buf = newbuf; 415 } 416 417 memcpy(oself->buf+oself->pos,c,l); 418 419 assert(oself->pos + l < INT_MAX); 420 oself->pos += (int)l; 421 422 if (oself->string_size < oself->pos) { 423 oself->string_size = oself->pos; 387 O_cwrite(PyObject *self, const char *c, Py_ssize_t len) { 388 Py_ssize_t newpos; 389 Oobject *oself; 390 char *newbuf; 391 392 if (!IO__opencheck(IOOOBJECT(self))) return -1; 393 oself = (Oobject *)self; 394 395 if (len > INT_MAX) { 396 PyErr_SetString(PyExc_OverflowError, 397 "length too large"); 398 return -1; 399 } 400 assert(len >= 0); 401 if (oself->pos >= PY_SSIZE_T_MAX - len) { 402 PyErr_SetString(PyExc_OverflowError, 403 "new position too large"); 404 return -1; 405 } 406 newpos = oself->pos + len; 407 if (newpos >= oself->buf_size) { 408 size_t newsize = oself->buf_size; 409 newsize *= 2; 410 if (newsize <= (size_t)newpos || newsize > PY_SSIZE_T_MAX) { 411 assert(newpos < PY_SSIZE_T_MAX - 1); 412 newsize = newpos + 1; 424 413 } 425 426 return (int)l; 414 newbuf = (char*)realloc(oself->buf, newsize); 415 if (!newbuf) { 416 PyErr_SetString(PyExc_MemoryError,"out of memory"); 417 return -1; 418 } 419 oself->buf_size = (Py_ssize_t)newsize; 420 oself->buf = newbuf; 421 } 422 423 if (oself->string_size < oself->pos) { 424 /* In case of overseek, pad with null bytes the buffer region between 425 the end of stream and the current position. 426 427 0 lo string_size hi 428 | |<---used--->|<----------available----------->| 429 | | <--to pad-->|<---to write---> | 430 0 buf position 431 */ 432 memset(oself->buf + oself->string_size, '\0', 433 (oself->pos - oself->string_size) * sizeof(char)); 434 } 435 436 memcpy(oself->buf + oself->pos, c, len); 437 438 oself->pos = newpos; 439 440 if (oself->string_size < oself->pos) { 441 oself->string_size = oself->pos; 442 } 443 444 return (int)len; 427 445 } 428 446 429 447 static PyObject * 430 448 O_write(Oobject *self, PyObject *args) { 431 char *c; 432 int l; 433 434 if (!PyArg_ParseTuple(args, "t#:write", &c, &l)) return NULL; 435 436 if (O_cwrite((PyObject*)self,c,l) < 0) return NULL; 437 438 Py_INCREF(Py_None); 439 return Py_None; 449 Py_buffer buf; 450 int result; 451 452 if (!PyArg_ParseTuple(args, "s*:write", &buf)) return NULL; 453 454 result = O_cwrite((PyObject*)self, buf.buf, buf.len); 455 PyBuffer_Release(&buf); 456 if (result < 0) return NULL; 457 458 Py_INCREF(Py_None); 459 return Py_None; 440 460 } 441 461 … … 444 464 static PyObject * 445 465 O_close(Oobject *self, PyObject *unused) { 446 447 448 449 450 451 452 466 if (self->buf != NULL) free(self->buf); 467 self->buf = NULL; 468 469 self->pos = self->string_size = self->buf_size = 0; 470 471 Py_INCREF(Py_None); 472 return Py_None; 453 473 } 454 474 … … 460 480 static PyObject * 461 481 O_writelines(Oobject *self, PyObject *args) { 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 482 PyObject *it, *s; 483 484 it = PyObject_GetIter(args); 485 if (it == NULL) 486 return NULL; 487 while ((s = PyIter_Next(it)) != NULL) { 488 Py_ssize_t n; 489 char *c; 490 if (PyString_AsStringAndSize(s, &c, &n) == -1) { 491 Py_DECREF(it); 492 Py_DECREF(s); 493 return NULL; 494 } 495 if (O_cwrite((PyObject *)self, c, n) == -1) { 496 Py_DECREF(it); 497 Py_DECREF(s); 498 return NULL; 499 } 500 Py_DECREF(s); 481 501 } 482 502 … … 485 505 /* See if PyIter_Next failed */ 486 506 if (PyErr_Occurred()) 487 507 return NULL; 488 508 489 509 Py_RETURN_NONE; … … 494 514 {"getvalue", (PyCFunction)IO_getval, METH_VARARGS, IO_getval__doc__}, 495 515 {"isatty", (PyCFunction)IO_isatty, METH_NOARGS, IO_isatty__doc__}, 496 {"read", (PyCFunction)IO_read, METH_VARARGS, IO_read__doc__}, 497 {"readline", (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__}, 498 {"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__}, 499 {"reset", (PyCFunction)IO_reset, METH_NOARGS, IO_reset__doc__}, 516 {"read", (PyCFunction)IO_read, METH_VARARGS, IO_read__doc__}, 517 {"readline", (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__}, 518 {"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__}, 519 {"reset", (PyCFunction)IO_reset, METH_NOARGS, IO_reset__doc__}, 520 {"seek", (PyCFunction)IO_seek, METH_VARARGS, IO_seek__doc__}, 500 521 {"tell", (PyCFunction)IO_tell, METH_NOARGS, IO_tell__doc__}, 501 522 {"truncate", (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__}, … … 503 524 /* Read-write StringIO specific methods: */ 504 525 {"close", (PyCFunction)O_close, METH_NOARGS, O_close__doc__}, 505 {"seek", (PyCFunction)O_seek, METH_VARARGS, O_seek__doc__}, 506 {"write", (PyCFunction)O_write, METH_VARARGS, O_write__doc__}, 507 {"writelines", (PyCFunction)O_writelines, METH_O, O_writelines__doc__}, 508 {NULL, NULL} /* sentinel */ 526 {"write", (PyCFunction)O_write, METH_VARARGS, O_write__doc__}, 527 {"writelines", (PyCFunction)O_writelines, METH_O, O_writelines__doc__}, 528 {NULL, NULL} /* sentinel */ 509 529 }; 510 530 511 531 static PyMemberDef O_memberlist[] = { 512 {"softspace", T_INT, offsetof(Oobject, softspace),0,513 514 515 532 {"softspace", T_INT, offsetof(Oobject, softspace), 0, 533 "flag indicating that a space needs to be printed; used by print"}, 534 /* getattr(f, "closed") is implemented without this table */ 535 {NULL} /* Sentinel */ 516 536 }; 517 537 518 538 static void 519 539 O_dealloc(Oobject *self) { 520 521 522 540 if (self->buf != NULL) 541 free(self->buf); 542 PyObject_Del(self); 523 543 } 524 544 … … 527 547 static PyTypeObject Otype = { 528 548 PyVarObject_HEAD_INIT(NULL, 0) 529 "cStringIO.StringO", 530 sizeof(Oobject), 531 0, 549 "cStringIO.StringO", /*tp_name*/ 550 sizeof(Oobject), /*tp_basicsize*/ 551 0, /*tp_itemsize*/ 532 552 /* methods */ 533 (destructor)O_dealloc, 534 0, 535 0, 536 0, 537 0, 538 0, 539 0, 540 0, 541 0, 542 0, 543 0 ,/*tp_call*/544 0, 545 0, 546 0, 547 0, 548 Py_TPFLAGS_DEFAULT, 549 Otype__doc__, 550 0, 551 0, 552 0, 553 0, 554 PyObject_SelfIter, 555 (iternextfunc)IO_iternext, 556 O_methods, 557 O_memberlist, 558 file_getsetlist, 553 (destructor)O_dealloc, /*tp_dealloc*/ 554 0, /*tp_print*/ 555 0, /*tp_getattr */ 556 0, /*tp_setattr */ 557 0, /*tp_compare*/ 558 0, /*tp_repr*/ 559 0, /*tp_as_number*/ 560 0, /*tp_as_sequence*/ 561 0, /*tp_as_mapping*/ 562 0, /*tp_hash*/ 563 0 , /*tp_call*/ 564 0, /*tp_str*/ 565 0, /*tp_getattro */ 566 0, /*tp_setattro */ 567 0, /*tp_as_buffer */ 568 Py_TPFLAGS_DEFAULT, /*tp_flags*/ 569 Otype__doc__, /*tp_doc */ 570 0, /*tp_traverse */ 571 0, /*tp_clear */ 572 0, /*tp_richcompare */ 573 0, /*tp_weaklistoffset */ 574 PyObject_SelfIter, /*tp_iter */ 575 (iternextfunc)IO_iternext, /*tp_iternext */ 576 O_methods, /*tp_methods */ 577 O_memberlist, /*tp_members */ 578 file_getsetlist, /*tp_getset */ 559 579 }; 560 580 561 581 static PyObject * 562 582 newOobject(int size) { 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 583 Oobject *self; 584 585 self = PyObject_New(Oobject, &Otype); 586 if (self == NULL) 587 return NULL; 588 self->pos=0; 589 self->string_size = 0; 590 self->softspace = 0; 591 592 self->buf = (char *)malloc(size); 593 if (!self->buf) { 594 PyErr_SetString(PyExc_MemoryError,"out of memory"); 595 self->buf_size = 0; 596 Py_DECREF(self); 597 return NULL; 598 } 599 600 self->buf_size=size; 601 return (PyObject*)self; 582 602 } 583 603 … … 587 607 static PyObject * 588 608 I_close(Iobject *self, PyObject *unused) { 589 Py_CLEAR(self->pbuf); 590 self->buf = NULL; 591 592 self->pos = self->string_size = 0; 593 594 Py_INCREF(Py_None); 595 return Py_None; 596 } 597 598 static PyObject * 599 I_seek(Iobject *self, PyObject *args) { 600 Py_ssize_t position; 601 int mode = 0; 602 603 if (!IO__opencheck(IOOOBJECT(self))) return NULL; 604 if (!PyArg_ParseTuple(args, "n|i:seek", &position, &mode)) 605 return NULL; 606 607 if (mode == 2) position += self->string_size; 608 else if (mode == 1) position += self->pos; 609 610 if (position < 0) position=0; 611 612 self->pos=position; 613 614 Py_INCREF(Py_None); 615 return Py_None; 609 PyBuffer_Release(&self->pbuf); 610 self->buf = NULL; 611 612 self->pos = self->string_size = 0; 613 614 Py_INCREF(Py_None); 615 return Py_None; 616 616 } 617 617 … … 621 621 {"getvalue", (PyCFunction)IO_getval, METH_VARARGS, IO_getval__doc__}, 622 622 {"isatty", (PyCFunction)IO_isatty, METH_NOARGS, IO_isatty__doc__}, 623 {"read", (PyCFunction)IO_read, METH_VARARGS, IO_read__doc__}, 624 {"readline", (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__}, 625 {"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__}, 626 {"reset", (PyCFunction)IO_reset, METH_NOARGS, IO_reset__doc__}, 623 {"read", (PyCFunction)IO_read, METH_VARARGS, IO_read__doc__}, 624 {"readline", (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__}, 625 {"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__}, 626 {"reset", (PyCFunction)IO_reset, METH_NOARGS, IO_reset__doc__}, 627 {"seek", (PyCFunction)IO_seek, METH_VARARGS, IO_seek__doc__}, 627 628 {"tell", (PyCFunction)IO_tell, METH_NOARGS, IO_tell__doc__}, 628 629 {"truncate", (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__}, … … 630 631 /* Read-only StringIO specific methods: */ 631 632 {"close", (PyCFunction)I_close, METH_NOARGS, O_close__doc__}, 632 {"seek", (PyCFunction)I_seek, METH_VARARGS, O_seek__doc__}, 633 {NULL, NULL} 633 {NULL, NULL} 634 634 }; 635 635 636 636 static void 637 637 I_dealloc(Iobject *self) { 638 Py _XDECREF(self->pbuf);638 PyBuffer_Release(&self->pbuf); 639 639 PyObject_Del(self); 640 640 } … … 646 646 static PyTypeObject Itype = { 647 647 PyVarObject_HEAD_INIT(NULL, 0) 648 "cStringIO.StringI", 649 sizeof(Iobject), 650 0, 648 "cStringIO.StringI", /*tp_name*/ 649 sizeof(Iobject), /*tp_basicsize*/ 650 0, /*tp_itemsize*/ 651 651 /* methods */ 652 (destructor)I_dealloc, 653 0, 654 0, 655 0, 656 0, 657 0, 658 0, 659 0, 660 0, 661 0, 662 0, 663 0, 664 0, 665 0, 666 0, 667 Py_TPFLAGS_DEFAULT, 668 Itype__doc__, 669 0, 670 0, 671 0, 672 0, 673 PyObject_SelfIter, 674 (iternextfunc)IO_iternext, 675 I_methods, 676 0, 677 file_getsetlist, 652 (destructor)I_dealloc, /*tp_dealloc*/ 653 0, /*tp_print*/ 654 0, /* tp_getattr */ 655 0, /*tp_setattr*/ 656 0, /*tp_compare*/ 657 0, /*tp_repr*/ 658 0, /*tp_as_number*/ 659 0, /*tp_as_sequence*/ 660 0, /*tp_as_mapping*/ 661 0, /*tp_hash*/ 662 0, /*tp_call*/ 663 0, /*tp_str*/ 664 0, /* tp_getattro */ 665 0, /* tp_setattro */ 666 0, /* tp_as_buffer */ 667 Py_TPFLAGS_DEFAULT, /* tp_flags */ 668 Itype__doc__, /* tp_doc */ 669 0, /* tp_traverse */ 670 0, /* tp_clear */ 671 0, /* tp_richcompare */ 672 0, /* tp_weaklistoffset */ 673 PyObject_SelfIter, /* tp_iter */ 674 (iternextfunc)IO_iternext, /* tp_iternext */ 675 I_methods, /* tp_methods */ 676 0, /* tp_members */ 677 file_getsetlist, /* tp_getset */ 678 678 }; 679 679 … … 681 681 newIobject(PyObject *s) { 682 682 Iobject *self; 683 char *buf; 684 Py_ssize_t size; 685 686 if (PyObject_AsReadBuffer(s, (const void **)&buf, &size)) { 687 PyErr_Format(PyExc_TypeError, "expected read buffer, %.200s found", 688 s->ob_type->tp_name); 689 return NULL; 683 Py_buffer buf; 684 PyObject *args; 685 int result; 686 687 args = Py_BuildValue("(O)", s); 688 if (args == NULL) 689 return NULL; 690 result = PyArg_ParseTuple(args, "s*:StringIO", &buf); 691 Py_DECREF(args); 692 if (!result) 693 return NULL; 694 695 self = PyObject_New(Iobject, &Itype); 696 if (!self) { 697 PyBuffer_Release(&buf); 698 return NULL; 690 699 } 691 692 self = PyObject_New(Iobject, &Itype); 693 if (!self) return NULL; 694 Py_INCREF(s); 695 self->buf=buf; 696 self->string_size=size; 697 self->pbuf=s; 700 self->buf=buf.buf; 701 self->string_size=buf.len; 702 self->pbuf=buf; 698 703 self->pos=0; 699 704 700 705 return (PyObject*)self; 701 706 } … … 721 726 722 727 static struct PyMethodDef IO_methods[] = { 723 {"StringIO", (PyCFunction)IO_StringIO,724 METH_VARARGS, 725 {NULL, NULL}/* sentinel */728 {"StringIO", (PyCFunction)IO_StringIO, 729 METH_VARARGS, IO_StringIO__doc__}, 730 {NULL, NULL} /* sentinel */ 726 731 }; 727 732 … … 740 745 }; 741 746 742 #ifndef PyMODINIT_FUNC 747 #ifndef PyMODINIT_FUNC /* declarations for DLL import/export */ 743 748 #define PyMODINIT_FUNC void 744 749 #endif … … 750 755 /* Create the module and add the functions */ 751 756 m = Py_InitModule4("cStringIO", IO_methods, 752 753 757 cStringIO_module_documentation, 758 (PyObject*)NULL,PYTHON_API_VERSION); 754 759 if (m == NULL) return; 755 760 756 761 /* Add some symbolic constants to the module */ 757 762 d = PyModule_GetDict(m); 758 763 759 764 /* Export C API */ 760 765 Py_TYPE(&Itype)=&PyType_Type; … … 762 767 if (PyType_Ready(&Otype) < 0) return; 763 768 if (PyType_Ready(&Itype) < 0) return; 764 PyDict_SetItemString(d,"cStringIO_CAPI",765 v = PyCObject_FromVoidPtr(&CAPI,NULL));769 v = PyCapsule_New(&CAPI, PycStringIO_CAPSULE_NAME, NULL); 770 PyDict_SetItemString(d,"cStringIO_CAPI", v); 766 771 Py_XDECREF(v); 767 772
Note:
See TracChangeset
for help on using the changeset viewer.
