?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
The _lsprof module could crash the interpreter if it was given an external
[python.git] / Objects / fileobject.c
blobb2051d79fe45737dce9d19e5b7d63ab179e8aed6
1 /* File object implementation */
2
3 #define PY_SSIZE_T_CLEAN
4 #include "Python.h"
5 #include "structmember.h"
6
7 #ifdef HAVE_SYS_TYPES_H
8 #include <sys/types.h>
9 #endif /* HAVE_SYS_TYPES_H */
10
11 #ifdef MS_WINDOWS
12 #define fileno _fileno
13 /* can simulate truncate with Win32 API functions; see file_truncate */
14 #define HAVE_FTRUNCATE
15 #define WIN32_LEAN_AND_MEAN
16 #include <windows.h>
17 #endif
18
19 #ifdef _MSC_VER
20 /* Need GetVersion to see if on NT so safe to use _wfopen */
21 #define WIN32_LEAN_AND_MEAN
22 #include <windows.h>
23 #endif /* _MSC_VER */
24
25 #if defined(PYOS_OS2) && defined(PYCC_GCC)
26 #include <io.h>
27 #endif
28
29 #define BUF(v) PyString_AS_STRING((PyStringObject *)v)
30
31 #ifndef DONT_HAVE_ERRNO_H
32 #include <errno.h>
33 #endif
34
35 #ifdef HAVE_GETC_UNLOCKED
36 #define GETC(f) getc_unlocked(f)
37 #define FLOCKFILE(f) flockfile(f)
38 #define FUNLOCKFILE(f) funlockfile(f)
39 #else
40 #define GETC(f) getc(f)
41 #define FLOCKFILE(f)
42 #define FUNLOCKFILE(f)
43 #endif
44
45 /* Bits in f_newlinetypes */
46 #define NEWLINE_UNKNOWN 0 /* No newline seen, yet */
47 #define NEWLINE_CR 1 /* \r newline seen */
48 #define NEWLINE_LF 2 /* \n newline seen */
49 #define NEWLINE_CRLF 4 /* \r\n newline seen */
50
51 /*
52 * These macros release the GIL while preventing the f_close() function being
53 * called in the interval between them. For that purpose, a running total of
54 * the number of currently running unlocked code sections is kept in
55 * the unlocked_count field of the PyFileObject. The close() method raises
56 * an IOError if that field is non-zero. See issue #815646, #595601.
57 */
58
59 #define FILE_BEGIN_ALLOW_THREADS(fobj) \
60 { \
61 fobj->unlocked_count++; \
62 Py_BEGIN_ALLOW_THREADS
63
64 #define FILE_END_ALLOW_THREADS(fobj) \
65 Py_END_ALLOW_THREADS \
66 fobj->unlocked_count--; \
67 assert(fobj->unlocked_count >= 0); \
68 }
69
70 #define FILE_ABORT_ALLOW_THREADS(fobj) \
71 Py_BLOCK_THREADS \
72 fobj->unlocked_count--; \
73 assert(fobj->unlocked_count >= 0);
74
75 #ifdef __cplusplus
76 extern "C" {
77 #endif
78
79 FILE *
80 PyFile_AsFile(PyObject *f)
81 {
82 if (f == NULL || !PyFile_Check(f))
83 return NULL;
84 else
85 return ((PyFileObject *)f)->f_fp;
86 }
87
88 void PyFile_IncUseCount(PyFileObject *fobj)
89 {
90 fobj->unlocked_count++;
91 }
92
93 void PyFile_DecUseCount(PyFileObject *fobj)
94 {
95 fobj->unlocked_count--;
96 assert(fobj->unlocked_count >= 0);
97 }
98
99 PyObject *
100 PyFile_Name(PyObject *f)
101 {
102 if (f == NULL || !PyFile_Check(f))
103 return NULL;
104 else
105 return ((PyFileObject *)f)->f_name;
106 }
107
108 /* This is a safe wrapper around PyObject_Print to print to the FILE
109 of a PyFileObject. PyObject_Print releases the GIL but knows nothing
110 about PyFileObject. */
111 static int
112 file_PyObject_Print(PyObject *op, PyFileObject *f, int flags)
113 {
114 int result;
115 PyFile_IncUseCount(f);
116 result = PyObject_Print(op, f->f_fp, flags);
117 PyFile_DecUseCount(f);
118 return result;
119 }
120
121 /* On Unix, fopen will succeed for directories.
122 In Python, there should be no file objects referring to
123 directories, so we need a check. */
124
125 static PyFileObject*
126 dircheck(PyFileObject* f)
127 {
128 #if defined(HAVE_FSTAT) && defined(S_IFDIR) && defined(EISDIR)
129 struct stat buf;
130 if (f->f_fp == NULL)
131 return f;
132 if (fstat(fileno(f->f_fp), &buf) == 0 &&
133 S_ISDIR(buf.st_mode)) {
134 char *msg = strerror(EISDIR);
135 PyObject *exc = PyObject_CallFunction(PyExc_IOError, "(is)",
136 EISDIR, msg);
137 PyErr_SetObject(PyExc_IOError, exc);
138 Py_XDECREF(exc);
139 return NULL;
140 }
141 #endif
142 return f;
143 }
144
145
146 static PyObject *
147 fill_file_fields(PyFileObject *f, FILE *fp, PyObject *name, char *mode,
148 int (*close)(FILE *))
149 {
150 assert(name != NULL);
151 assert(f != NULL);
152 assert(PyFile_Check(f));
153 assert(f->f_fp == NULL);
154
155 Py_DECREF(f->f_name);
156 Py_DECREF(f->f_mode);
157 Py_DECREF(f->f_encoding);
158 Py_DECREF(f->f_errors);
159
160 Py_INCREF(name);
161 f->f_name = name;
162
163 f->f_mode = PyString_FromString(mode);
164
165 f->f_close = close;
166 f->f_softspace = 0;
167 f->f_binary = strchr(mode,'b') != NULL;
168 f->f_buf = NULL;
169 f->f_univ_newline = (strchr(mode, 'U') != NULL);
170 f->f_newlinetypes = NEWLINE_UNKNOWN;
171 f->f_skipnextlf = 0;
172 Py_INCREF(Py_None);
173 f->f_encoding = Py_None;
174 Py_INCREF(Py_None);
175 f->f_errors = Py_None;
176
177 if (f->f_mode == NULL)
178 return NULL;
179 f->f_fp = fp;
180 f = dircheck(f);
181 return (PyObject *) f;
182 }
183
184 /* check for known incorrect mode strings - problem is, platforms are
185 free to accept any mode characters they like and are supposed to
186 ignore stuff they don't understand... write or append mode with
187 universal newline support is expressly forbidden by PEP 278.
188 Additionally, remove the 'U' from the mode string as platforms
189 won't know what it is. Non-zero return signals an exception */
190 int
191 _PyFile_SanitizeMode(char *mode)
192 {
193 char *upos;
194 size_t len = strlen(mode);
195
196 if (!len) {
197 PyErr_SetString(PyExc_ValueError, "empty mode string");
198 return -1;
199 }
200
201 upos = strchr(mode, 'U');
202 if (upos) {
203 memmove(upos, upos+1, len-(upos-mode)); /* incl null char */
204
205 if (mode[0] == 'w' || mode[0] == 'a') {
206 PyErr_Format(PyExc_ValueError, "universal newline "
207 "mode can only be used with modes "
208 "starting with 'r'");
209 return -1;
210 }
211
212 if (mode[0] != 'r') {
213 memmove(mode+1, mode, strlen(mode)+1);
214 mode[0] = 'r';
215 }
216
217 if (!strchr(mode, 'b')) {
218 memmove(mode+2, mode+1, strlen(mode));
219 mode[1] = 'b';
220 }
221 } else if (mode[0] != 'r' && mode[0] != 'w' && mode[0] != 'a') {
222 PyErr_Format(PyExc_ValueError, "mode string must begin with "
223 "one of 'r', 'w', 'a' or 'U', not '%.200s'", mode);
224 return -1;
225 }
226
227 return 0;
228 }
229
230 static PyObject *
231 open_the_file(PyFileObject *f, char *name, char *mode)
232 {
233 char *newmode;
234 assert(f != NULL);
235 assert(PyFile_Check(f));
236 #ifdef MS_WINDOWS
237 /* windows ignores the passed name in order to support Unicode */
238 assert(f->f_name != NULL);
239 #else
240 assert(name != NULL);
241 #endif
242 assert(mode != NULL);
243 assert(f->f_fp == NULL);
244
245 /* probably need to replace 'U' by 'rb' */
246 newmode = PyMem_MALLOC(strlen(mode) + 3);
247 if (!newmode) {
248 PyErr_NoMemory();
249 return NULL;
250 }
251 strcpy(newmode, mode);
252
253 if (_PyFile_SanitizeMode(newmode)) {
254 f = NULL;
255 goto cleanup;
256 }
257
258 /* rexec.py can't stop a user from getting the file() constructor --
259 all they have to do is get *any* file object f, and then do
260 type(f). Here we prevent them from doing damage with it. */
261 if (PyEval_GetRestricted()) {
262 PyErr_SetString(PyExc_IOError,
263 "file() constructor not accessible in restricted mode");
264 f = NULL;
265 goto cleanup;
266 }
267 errno = 0;
268
269 #ifdef MS_WINDOWS
270 if (PyUnicode_Check(f->f_name)) {
271 PyObject *wmode;
272 wmode = PyUnicode_DecodeASCII(newmode, strlen(newmode), NULL);
273 if (f->f_name && wmode) {
274 FILE_BEGIN_ALLOW_THREADS(f)
275 /* PyUnicode_AS_UNICODE OK without thread
276 lock as it is a simple dereference. */
277 f->f_fp = _wfopen(PyUnicode_AS_UNICODE(f->f_name),
278 PyUnicode_AS_UNICODE(wmode));
279 FILE_END_ALLOW_THREADS(f)
280 }
281 Py_XDECREF(wmode);
282 }
283 #endif
284 if (NULL == f->f_fp && NULL != name) {
285 FILE_BEGIN_ALLOW_THREADS(f)
286 f->f_fp = fopen(name, newmode);
287 FILE_END_ALLOW_THREADS(f)
288 }
289
290 if (f->f_fp == NULL) {
291 #if defined _MSC_VER && (_MSC_VER < 1400 || !defined(__STDC_SECURE_LIB__))
292 /* MSVC 6 (Microsoft) leaves errno at 0 for bad mode strings,
293 * across all Windows flavors. When it sets EINVAL varies
294 * across Windows flavors, the exact conditions aren't
295 * documented, and the answer lies in the OS's implementation
296 * of Win32's CreateFile function (whose source is secret).
297 * Seems the best we can do is map EINVAL to ENOENT.
298 * Starting with Visual Studio .NET 2005, EINVAL is correctly
299 * set by our CRT error handler (set in exceptions.c.)
300 */
301 if (errno == 0) /* bad mode string */
302 errno = EINVAL;
303 else if (errno == EINVAL) /* unknown, but not a mode string */
304 errno = ENOENT;
305 #endif
306 /* EINVAL is returned when an invalid filename or
307 * an invalid mode is supplied. */
308 if (errno == EINVAL) {
309 PyObject *v;
310 char message[100];
311 PyOS_snprintf(message, 100,
312 "invalid mode ('%.50s') or filename", mode);
313 v = Py_BuildValue("(isO)", errno, message, f->f_name);
314 if (v != NULL) {
315 PyErr_SetObject(PyExc_IOError, v);
316 Py_DECREF(v);
317 }
318 }
319 else
320 PyErr_SetFromErrnoWithFilenameObject(PyExc_IOError, f->f_name);
321 f = NULL;
322 }
323 if (f != NULL)
324 f = dircheck(f);
325
326 cleanup:
327 PyMem_FREE(newmode);
328
329 return (PyObject *)f;
330 }
331
332 static PyObject *
333 close_the_file(PyFileObject *f)
334 {
335 int sts = 0;
336 int (*local_close)(FILE *);
337 FILE *local_fp = f->f_fp;
338 if (local_fp != NULL) {
339 local_close = f->f_close;
340 if (local_close != NULL && f->unlocked_count > 0) {
341 if (f->ob_refcnt > 0) {
342 PyErr_SetString(PyExc_IOError,
343 "close() called during concurrent "
344 "operation on the same file object.");
345 } else {
346 /* This should not happen unless someone is
347 * carelessly playing with the PyFileObject
348 * struct fields and/or its associated FILE
349 * pointer. */
350 PyErr_SetString(PyExc_SystemError,
351 "PyFileObject locking error in "
352 "destructor (refcnt <= 0 at close).");
353 }
354 return NULL;
355 }
356 /* NULL out the FILE pointer before releasing the GIL, because
357 * it will not be valid anymore after the close() function is
358 * called. */
359 f->f_fp = NULL;
360 if (local_close != NULL) {
361 Py_BEGIN_ALLOW_THREADS
362 errno = 0;
363 sts = (*local_close)(local_fp);
364 Py_END_ALLOW_THREADS
365 if (sts == EOF)
366 return PyErr_SetFromErrno(PyExc_IOError);
367 if (sts != 0)
368 return PyInt_FromLong((long)sts);
369 }
370 }
371 Py_RETURN_NONE;
372 }
373
374 PyObject *
375 PyFile_FromFile(FILE *fp, char *name, char *mode, int (*close)(FILE *))
376 {
377 PyFileObject *f = (PyFileObject *)PyFile_Type.tp_new(&PyFile_Type,
378 NULL, NULL);
379 if (f != NULL) {
380 PyObject *o_name = PyString_FromString(name);
381 if (o_name == NULL)
382 return NULL;
383 if (fill_file_fields(f, fp, o_name, mode, close) == NULL) {
384 Py_DECREF(f);
385 f = NULL;
386 }
387 Py_DECREF(o_name);
388 }
389 return (PyObject *) f;
390 }
391
392 PyObject *
393 PyFile_FromString(char *name, char *mode)
394 {
395 extern int fclose(FILE *);
396 PyFileObject *f;
397
398 f = (PyFileObject *)PyFile_FromFile((FILE *)NULL, name, mode, fclose);
399 if (f != NULL) {
400 if (open_the_file(f, name, mode) == NULL) {
401 Py_DECREF(f);
402 f = NULL;
403 }
404 }
405 return (PyObject *)f;
406 }
407
408 void
409 PyFile_SetBufSize(PyObject *f, int bufsize)
410 {
411 PyFileObject *file = (PyFileObject *)f;
412 if (bufsize >= 0) {
413 int type;
414 switch (bufsize) {
415 case 0:
416 type = _IONBF;
417 break;
418 #ifdef HAVE_SETVBUF
419 case 1:
420 type = _IOLBF;
421 bufsize = BUFSIZ;
422 break;
423 #endif
424 default:
425 type = _IOFBF;
426 #ifndef HAVE_SETVBUF
427 bufsize = BUFSIZ;
428 #endif
429 break;
430 }
431 fflush(file->f_fp);
432 if (type == _IONBF) {
433 PyMem_Free(file->f_setbuf);
434 file->f_setbuf = NULL;
435 } else {
436 file->f_setbuf = (char *)PyMem_Realloc(file->f_setbuf,
437 bufsize);
438 }
439 #ifdef HAVE_SETVBUF
440 setvbuf(file->f_fp, file->f_setbuf, type, bufsize);
441 #else /* !HAVE_SETVBUF */
442 setbuf(file->f_fp, file->f_setbuf);
443 #endif /* !HAVE_SETVBUF */
444 }
445 }
446
447 /* Set the encoding used to output Unicode strings.
448 Return 1 on success, 0 on failure. */
449
450 int
451 PyFile_SetEncoding(PyObject *f, const char *enc)
452 {
453 return PyFile_SetEncodingAndErrors(f, enc, NULL);
454 }
455
456 int
457 PyFile_SetEncodingAndErrors(PyObject *f, const char *enc, char* errors)
458 {
459 PyFileObject *file = (PyFileObject*)f;
460 PyObject *str, *oerrors;
461
462 assert(PyFile_Check(f));
463 str = PyString_FromString(enc);
464 if (!str)
465 return 0;
466 if (errors) {
467 oerrors = PyString_FromString(errors);
468 if (!oerrors) {
469 Py_DECREF(str);
470 return 0;
471 }
472 } else {
473 oerrors = Py_None;
474 Py_INCREF(Py_None);
475 }
476 Py_DECREF(file->f_encoding);
477 file->f_encoding = str;
478 Py_DECREF(file->f_errors);
479 file->f_errors = oerrors;
480 return 1;
481 }
482
483 static PyObject *
484 err_closed(void)
485 {
486 PyErr_SetString(PyExc_ValueError, "I/O operation on closed file");
487 return NULL;
488 }
489
490 /* Refuse regular file I/O if there's data in the iteration-buffer.
491 * Mixing them would cause data to arrive out of order, as the read*
492 * methods don't use the iteration buffer. */
493 static PyObject *
494 err_iterbuffered(void)
495 {
496 PyErr_SetString(PyExc_ValueError,
497 "Mixing iteration and read methods would lose data");
498 return NULL;
499 }
500
501 static void drop_readahead(PyFileObject *);
502
503 /* Methods */
504
505 static void
506 file_dealloc(PyFileObject *f)
507 {
508 PyObject *ret;
509 if (f->weakreflist != NULL)
510 PyObject_ClearWeakRefs((PyObject *) f);
511 ret = close_the_file(f);
512 if (!ret) {
513 PySys_WriteStderr("close failed in file object destructor:\n");
514 PyErr_Print();
515 }
516 else {
517 Py_DECREF(ret);
518 }
519 PyMem_Free(f->f_setbuf);
520 Py_XDECREF(f->f_name);
521 Py_XDECREF(f->f_mode);
522 Py_XDECREF(f->f_encoding);
523 Py_XDECREF(f->f_errors);
524 drop_readahead(f);
525 Py_TYPE(f)->tp_free((PyObject *)f);
526 }
527
528 static PyObject *
529 file_repr(PyFileObject *f)
530 {
531 if (PyUnicode_Check(f->f_name)) {
532 #ifdef Py_USING_UNICODE
533 PyObject *ret = NULL;
534 PyObject *name = PyUnicode_AsUnicodeEscapeString(f->f_name);
535 const char *name_str = name ? PyString_AsString(name) : "?";
536 ret = PyString_FromFormat("<%s file u'%s', mode '%s' at %p>",
537 f->f_fp == NULL ? "closed" : "open",
538 name_str,
539 PyString_AsString(f->f_mode),
540 f);
541 Py_XDECREF(name);
542 return ret;
543 #endif
544 } else {
545 return PyString_FromFormat("<%s file '%s', mode '%s' at %p>",
546 f->f_fp == NULL ? "closed" : "open",
547 PyString_AsString(f->f_name),
548 PyString_AsString(f->f_mode),
549 f);
550 }
551 }
552
553 static PyObject *
554 file_close(PyFileObject *f)
555 {
556 PyObject *sts = close_the_file(f);
557 PyMem_Free(f->f_setbuf);
558 f->f_setbuf = NULL;
559 return sts;
560 }
561
562
563 /* Our very own off_t-like type, 64-bit if possible */
564 #if !defined(HAVE_LARGEFILE_SUPPORT)
565 typedef off_t Py_off_t;
566 #elif SIZEOF_OFF_T >= 8
567 typedef off_t Py_off_t;
568 #elif SIZEOF_FPOS_T >= 8
569 typedef fpos_t Py_off_t;
570 #else
571 #error "Large file support, but neither off_t nor fpos_t is large enough."
572 #endif
573
574
575 /* a portable fseek() function
576 return 0 on success, non-zero on failure (with errno set) */
577 static int
578 _portable_fseek(FILE *fp, Py_off_t offset, int whence)
579 {
580 #if !defined(HAVE_LARGEFILE_SUPPORT)
581 return fseek(fp, offset, whence);
582 #elif defined(HAVE_FSEEKO) && SIZEOF_OFF_T >= 8
583 return fseeko(fp, offset, whence);
584 #elif defined(HAVE_FSEEK64)
585 return fseek64(fp, offset, whence);
586 #elif defined(__BEOS__)
587 return _fseek(fp, offset, whence);
588 #elif SIZEOF_FPOS_T >= 8
589 /* lacking a 64-bit capable fseek(), use a 64-bit capable fsetpos()
590 and fgetpos() to implement fseek()*/
591 fpos_t pos;
592 switch (whence) {
593 case SEEK_END:
594 #ifdef MS_WINDOWS
595 fflush(fp);
596 if (_lseeki64(fileno(fp), 0, 2) == -1)
597 return -1;
598 #else
599 if (fseek(fp, 0, SEEK_END) != 0)
600 return -1;
601 #endif
602 /* fall through */
603 case SEEK_CUR:
604 if (fgetpos(fp, &pos) != 0)
605 return -1;
606 offset += pos;
607 break;
608 /* case SEEK_SET: break; */
609 }
610 return fsetpos(fp, &offset);
611 #else
612 #error "Large file support, but no way to fseek."
613 #endif
614 }
615
616
617 /* a portable ftell() function
618 Return -1 on failure with errno set appropriately, current file
619 position on success */
620 static Py_off_t
621 _portable_ftell(FILE* fp)
622 {
623 #if !defined(HAVE_LARGEFILE_SUPPORT)
624 return ftell(fp);
625 #elif defined(HAVE_FTELLO) && SIZEOF_OFF_T >= 8
626 return ftello(fp);
627 #elif defined(HAVE_FTELL64)
628 return ftell64(fp);
629 #elif SIZEOF_FPOS_T >= 8
630 fpos_t pos;
631 if (fgetpos(fp, &pos) != 0)
632 return -1;
633 return pos;
634 #else
635 #error "Large file support, but no way to ftell."
636 #endif
637 }
638
639
640 static PyObject *
641 file_seek(PyFileObject *f, PyObject *args)
642 {
643 int whence;
644 int ret;
645 Py_off_t offset;
646 PyObject *offobj, *off_index;
647
648 if (f->f_fp == NULL)
649 return err_closed();
650 drop_readahead(f);
651 whence = 0;
652 if (!PyArg_ParseTuple(args, "O|i:seek", &offobj, &whence))
653 return NULL;
654 off_index = PyNumber_Index(offobj);
655 if (!off_index) {
656 if (!PyFloat_Check(offobj))
657 return NULL;
658 /* Deprecated in 2.6 */
659 PyErr_Clear();
660 if (PyErr_WarnEx(PyExc_DeprecationWarning,
661 "integer argument expected, got float",
662 1) < 0)
663 return NULL;
664 off_index = offobj;
665 Py_INCREF(offobj);
666 }
667 #if !defined(HAVE_LARGEFILE_SUPPORT)
668 offset = PyInt_AsLong(off_index);
669 #else
670 offset = PyLong_Check(off_index) ?
671 PyLong_AsLongLong(off_index) : PyInt_AsLong(off_index);
672 #endif
673 Py_DECREF(off_index);
674 if (PyErr_Occurred())
675 return NULL;
676
677 FILE_BEGIN_ALLOW_THREADS(f)
678 errno = 0;
679 ret = _portable_fseek(f->f_fp, offset, whence);
680 FILE_END_ALLOW_THREADS(f)
681
682 if (ret != 0) {
683 PyErr_SetFromErrno(PyExc_IOError);
684 clearerr(f->f_fp);
685 return NULL;
686 }
687 f->f_skipnextlf = 0;
688 Py_INCREF(Py_None);
689 return Py_None;
690 }
691
692
693 #ifdef HAVE_FTRUNCATE
694 static PyObject *
695 file_truncate(PyFileObject *f, PyObject *args)
696 {
697 Py_off_t newsize;
698 PyObject *newsizeobj = NULL;
699 Py_off_t initialpos;
700 int ret;
701
702 if (f->f_fp == NULL)
703 return err_closed();
704 if (!PyArg_UnpackTuple(args, "truncate", 0, 1, &newsizeobj))
705 return NULL;
706
707 /* Get current file position. If the file happens to be open for
708 * update and the last operation was an input operation, C doesn't
709 * define what the later fflush() will do, but we promise truncate()
710 * won't change the current position (and fflush() *does* change it
711 * then at least on Windows). The easiest thing is to capture
712 * current pos now and seek back to it at the end.
713 */
714 FILE_BEGIN_ALLOW_THREADS(f)
715 errno = 0;
716 initialpos = _portable_ftell(f->f_fp);
717 FILE_END_ALLOW_THREADS(f)
718 if (initialpos == -1)
719 goto onioerror;
720
721 /* Set newsize to current postion if newsizeobj NULL, else to the
722 * specified value.
723 */
724 if (newsizeobj != NULL) {
725 #if !defined(HAVE_LARGEFILE_SUPPORT)
726 newsize = PyInt_AsLong(newsizeobj);
727 #else
728 newsize = PyLong_Check(newsizeobj) ?
729 PyLong_AsLongLong(newsizeobj) :
730 PyInt_AsLong(newsizeobj);
731 #endif
732 if (PyErr_Occurred())
733 return NULL;
734 }
735 else /* default to current position */
736 newsize = initialpos;
737
738 /* Flush the stream. We're mixing stream-level I/O with lower-level
739 * I/O, and a flush may be necessary to synch both platform views
740 * of the current file state.
741 */
742 FILE_BEGIN_ALLOW_THREADS(f)
743 errno = 0;
744 ret = fflush(f->f_fp);
745 FILE_END_ALLOW_THREADS(f)
746 if (ret != 0)
747 goto onioerror;
748
749 #ifdef MS_WINDOWS
750 /* MS _chsize doesn't work if newsize doesn't fit in 32 bits,
751 so don't even try using it. */
752 {
753 HANDLE hFile;
754
755 /* Have to move current pos to desired endpoint on Windows. */
756 FILE_BEGIN_ALLOW_THREADS(f)
757 errno = 0;
758 ret = _portable_fseek(f->f_fp, newsize, SEEK_SET) != 0;
759 FILE_END_ALLOW_THREADS(f)
760 if (ret)
761 goto onioerror;
762
763 /* Truncate. Note that this may grow the file! */
764 FILE_BEGIN_ALLOW_THREADS(f)
765 errno = 0;
766 hFile = (HANDLE)_get_osfhandle(fileno(f->f_fp));
767 ret = hFile == (HANDLE)-1;
768 if (ret == 0) {
769 ret = SetEndOfFile(hFile) == 0;
770 if (ret)
771 errno = EACCES;
772 }
773 FILE_END_ALLOW_THREADS(f)
774 if (ret)
775 goto onioerror;
776 }
777 #else
778 FILE_BEGIN_ALLOW_THREADS(f)
779 errno = 0;
780 ret = ftruncate(fileno(f->f_fp), newsize);
781 FILE_END_ALLOW_THREADS(f)
782 if (ret != 0)
783 goto onioerror;
784 #endif /* !MS_WINDOWS */
785
786 /* Restore original file position. */
787 FILE_BEGIN_ALLOW_THREADS(f)
788 errno = 0;
789 ret = _portable_fseek(f->f_fp, initialpos, SEEK_SET) != 0;
790 FILE_END_ALLOW_THREADS(f)
791 if (ret)
792 goto onioerror;
793
794 Py_INCREF(Py_None);
795 return Py_None;
796
797 onioerror:
798 PyErr_SetFromErrno(PyExc_IOError);
799 clearerr(f->f_fp);
800 return NULL;
801 }
802 #endif /* HAVE_FTRUNCATE */
803
804 static PyObject *
805 file_tell(PyFileObject *f)
806 {
807 Py_off_t pos;
808
809 if (f->f_fp == NULL)
810 return err_closed();
811 FILE_BEGIN_ALLOW_THREADS(f)
812 errno = 0;
813 pos = _portable_ftell(f->f_fp);
814 FILE_END_ALLOW_THREADS(f)
815
816 if (pos == -1) {
817 PyErr_SetFromErrno(PyExc_IOError);
818 clearerr(f->f_fp);
819 return NULL;
820 }
821 if (f->f_skipnextlf) {
822 int c;
823 c = GETC(f->f_fp);
824 if (c == '\n') {
825 f->f_newlinetypes |= NEWLINE_CRLF;
826 pos++;
827 f->f_skipnextlf = 0;
828 } else if (c != EOF) ungetc(c, f->f_fp);
829 }
830 #if !defined(HAVE_LARGEFILE_SUPPORT)
831 return PyInt_FromLong(pos);
832 #else
833 return PyLong_FromLongLong(pos);
834 #endif
835 }
836
837 static PyObject *
838 file_fileno(PyFileObject *f)
839 {
840 if (f->f_fp == NULL)
841 return err_closed();
842 return PyInt_FromLong((long) fileno(f->f_fp));
843 }
844
845 static PyObject *
846 file_flush(PyFileObject *f)
847 {
848 int res;
849
850 if (f->f_fp == NULL)
851 return err_closed();
852 FILE_BEGIN_ALLOW_THREADS(f)
853 errno = 0;
854 res = fflush(f->f_fp);
855 FILE_END_ALLOW_THREADS(f)
856 if (res != 0) {
857 PyErr_SetFromErrno(PyExc_IOError);
858 clearerr(f->f_fp);
859 return NULL;
860 }
861 Py_INCREF(Py_None);
862 return Py_None;
863 }
864
865 static PyObject *
866 file_isatty(PyFileObject *f)
867 {
868 long res;
869 if (f->f_fp == NULL)
870 return err_closed();
871 FILE_BEGIN_ALLOW_THREADS(f)
872 res = isatty((int)fileno(f->f_fp));
873 FILE_END_ALLOW_THREADS(f)
874 return PyBool_FromLong(res);
875 }
876
877
878 #if BUFSIZ < 8192
879 #define SMALLCHUNK 8192
880 #else
881 #define SMALLCHUNK BUFSIZ
882 #endif
883
884 #if SIZEOF_INT < 4
885 #define BIGCHUNK (512 * 32)
886 #else
887 #define BIGCHUNK (512 * 1024)
888 #endif
889
890 static size_t
891 new_buffersize(PyFileObject *f, size_t currentsize)
892 {
893 #ifdef HAVE_FSTAT
894 off_t pos, end;
895 struct stat st;
896 if (fstat(fileno(f->f_fp), &st) == 0) {
897 end = st.st_size;
898 /* The following is not a bug: we really need to call lseek()
899 *and* ftell(). The reason is that some stdio libraries
900 mistakenly flush their buffer when ftell() is called and
901 the lseek() call it makes fails, thereby throwing away
902 data that cannot be recovered in any way. To avoid this,
903 we first test lseek(), and only call ftell() if lseek()
904 works. We can't use the lseek() value either, because we
905 need to take the amount of buffered data into account.
906 (Yet another reason why stdio stinks. :-) */
907 pos = lseek(fileno(f->f_fp), 0L, SEEK_CUR);
908 if (pos >= 0) {
909 pos = ftell(f->f_fp);
910 }
911 if (pos < 0)
912 clearerr(f->f_fp);
913 if (end > pos && pos >= 0)
914 return currentsize + end - pos + 1;
915 /* Add 1 so if the file were to grow we'd notice. */
916 }
917 #endif
918 if (currentsize > SMALLCHUNK) {
919 /* Keep doubling until we reach BIGCHUNK;
920 then keep adding BIGCHUNK. */
921 if (currentsize <= BIGCHUNK)
922 return currentsize + currentsize;
923 else
924 return currentsize + BIGCHUNK;
925 }
926 return currentsize + SMALLCHUNK;
927 }
928
929 #if defined(EWOULDBLOCK) && defined(EAGAIN) && EWOULDBLOCK != EAGAIN
930 #define BLOCKED_ERRNO(x) ((x) == EWOULDBLOCK || (x) == EAGAIN)
931 #else
932 #ifdef EWOULDBLOCK
933 #define BLOCKED_ERRNO(x) ((x) == EWOULDBLOCK)
934 #else
935 #ifdef EAGAIN
936 #define BLOCKED_ERRNO(x) ((x) == EAGAIN)
937 #else
938 #define BLOCKED_ERRNO(x) 0
939 #endif
940 #endif
941 #endif
942
943 static PyObject *
944 file_read(PyFileObject *f, PyObject *args)
945 {
946 long bytesrequested = -1;
947 size_t bytesread, buffersize, chunksize;
948 PyObject *v;
949
950 if (f->f_fp == NULL)
951 return err_closed();
952 /* refuse to mix with f.next() */
953 if (f->f_buf != NULL &&
954 (f->f_bufend - f->f_bufptr) > 0 &&
955 f->f_buf[0] != '\0')
956 return err_iterbuffered();
957 if (!PyArg_ParseTuple(args, "|l:read", &bytesrequested))
958 return NULL;
959 if (bytesrequested < 0)
960 buffersize = new_buffersize(f, (size_t)0);
961 else
962 buffersize = bytesrequested;
963 if (buffersize > PY_SSIZE_T_MAX) {
964 PyErr_SetString(PyExc_OverflowError,
965 "requested number of bytes is more than a Python string can hold");
966 return NULL;
967 }
968 v = PyString_FromStringAndSize((char *)NULL, buffersize);
969 if (v == NULL)
970 return NULL;
971 bytesread = 0;
972 for (;;) {
973 FILE_BEGIN_ALLOW_THREADS(f)
974 errno = 0;
975 chunksize = Py_UniversalNewlineFread(BUF(v) + bytesread,
976 buffersize - bytesread, f->f_fp, (PyObject *)f);
977 FILE_END_ALLOW_THREADS(f)
978 if (chunksize == 0) {
979 if (!ferror(f->f_fp))
980 break;
981 clearerr(f->f_fp);
982 /* When in non-blocking mode, data shouldn't
983 * be discarded if a blocking signal was
984 * received. That will also happen if
985 * chunksize != 0, but bytesread < buffersize. */
986 if (bytesread > 0 && BLOCKED_ERRNO(errno))
987 break;
988 PyErr_SetFromErrno(PyExc_IOError);
989 Py_DECREF(v);
990 return NULL;
991 }
992 bytesread += chunksize;
993 if (bytesread < buffersize) {
994 clearerr(f->f_fp);
995 break;
996 }
997 if (bytesrequested < 0) {
998 buffersize = new_buffersize(f, buffersize);
999 if (_PyString_Resize(&v, buffersize) < 0)
1000 return NULL;
1001 } else {
1002 /* Got what was requested. */
1003 break;
1004 }
1005 }
1006 if (bytesread != buffersize)
1007 _PyString_Resize(&v, bytesread);
1008 return v;
1009 }
1010
1011 static PyObject *
1012 file_readinto(PyFileObject *f, PyObject *args)
1013 {
1014 char *ptr;
1015 Py_ssize_t ntodo;
1016 Py_ssize_t ndone, nnow;
1017 Py_buffer pbuf;
1018
1019 if (f->f_fp == NULL)
1020 return err_closed();
1021 /* refuse to mix with f.next() */
1022 if (f->f_buf != NULL &&
1023 (f->f_bufend - f->f_bufptr) > 0 &&
1024 f->f_buf[0] != '\0')
1025 return err_iterbuffered();
1026 if (!PyArg_ParseTuple(args, "w*", &pbuf))
1027 return NULL;
1028 ptr = pbuf.buf;
1029 ntodo = pbuf.len;
1030 ndone = 0;
1031 while (ntodo > 0) {
1032 FILE_BEGIN_ALLOW_THREADS(f)
1033 errno = 0;
1034 nnow = Py_UniversalNewlineFread(ptr+ndone, ntodo, f->f_fp,
1035 (PyObject *)f);
1036 FILE_END_ALLOW_THREADS(f)
1037 if (nnow == 0) {
1038 if (!ferror(f->f_fp))
1039 break;
1040 PyErr_SetFromErrno(PyExc_IOError);
1041 clearerr(f->f_fp);
1042 PyBuffer_Release(&pbuf);
1043 return NULL;
1044 }
1045 ndone += nnow;
1046 ntodo -= nnow;
1047 }
1048 PyBuffer_Release(&pbuf);
1049 return PyInt_FromSsize_t(ndone);
1050 }
1051
1052 /**************************************************************************
1053 Routine to get next line using platform fgets().
1054
1055 Under MSVC 6:
1056
1057 + MS threadsafe getc is very slow (multiple layers of function calls before+
1058 after each character, to lock+unlock the stream).
1059 + The stream-locking functions are MS-internal -- can't access them from user
1060 code.
1061 + There's nothing Tim could find in the MS C or platform SDK libraries that
1062 can worm around this.
1063 + MS fgets locks/unlocks only once per line; it's the only hook we have.
1064
1065 So we use fgets for speed(!), despite that it's painful.
1066
1067 MS realloc is also slow.
1068
1069 Reports from other platforms on this method vs getc_unlocked (which MS doesn't
1070 have):
1071 Linux a wash
1072 Solaris a wash
1073 Tru64 Unix getline_via_fgets significantly faster
1074
1075 CAUTION: The C std isn't clear about this: in those cases where fgets
1076 writes something into the buffer, can it write into any position beyond the
1077 required trailing null byte? MSVC 6 fgets does not, and no platform is (yet)
1078 known on which it does; and it would be a strange way to code fgets. Still,
1079 getline_via_fgets may not work correctly if it does. The std test
1080 test_bufio.py should fail if platform fgets() routinely writes beyond the
1081 trailing null byte. #define DONT_USE_FGETS_IN_GETLINE to disable this code.
1082 **************************************************************************/
1083
1084 /* Use this routine if told to, or by default on non-get_unlocked()
1085 * platforms unless told not to. Yikes! Let's spell that out:
1086 * On a platform with getc_unlocked():
1087 * By default, use getc_unlocked().
1088 * If you want to use fgets() instead, #define USE_FGETS_IN_GETLINE.
1089 * On a platform without getc_unlocked():
1090 * By default, use fgets().
1091 * If you don't want to use fgets(), #define DONT_USE_FGETS_IN_GETLINE.
1092 */
1093 #if !defined(USE_FGETS_IN_GETLINE) && !defined(HAVE_GETC_UNLOCKED)
1094 #define USE_FGETS_IN_GETLINE
1095 #endif
1096
1097 #if defined(DONT_USE_FGETS_IN_GETLINE) && defined(USE_FGETS_IN_GETLINE)
1098 #undef USE_FGETS_IN_GETLINE
1099 #endif
1100
1101 #ifdef USE_FGETS_IN_GETLINE
1102 static PyObject*
1103 getline_via_fgets(PyFileObject *f, FILE *fp)
1104 {
1105 /* INITBUFSIZE is the maximum line length that lets us get away with the fast
1106 * no-realloc, one-fgets()-call path. Boosting it isn't free, because we have
1107 * to fill this much of the buffer with a known value in order to figure out
1108 * how much of the buffer fgets() overwrites. So if INITBUFSIZE is larger
1109 * than "most" lines, we waste time filling unused buffer slots. 100 is
1110 * surely adequate for most peoples' email archives, chewing over source code,
1111 * etc -- "regular old text files".
1112 * MAXBUFSIZE is the maximum line length that lets us get away with the less
1113 * fast (but still zippy) no-realloc, two-fgets()-call path. See above for
1114 * cautions about boosting that. 300 was chosen because the worst real-life
1115 * text-crunching job reported on Python-Dev was a mail-log crawler where over
1116 * half the lines were 254 chars.
1117 */
1118 #define INITBUFSIZE 100
1119 #define MAXBUFSIZE 300
1120 char* p; /* temp */
1121 char buf[MAXBUFSIZE];
1122 PyObject* v; /* the string object result */
1123 char* pvfree; /* address of next free slot */
1124 char* pvend; /* address one beyond last free slot */
1125 size_t nfree; /* # of free buffer slots; pvend-pvfree */
1126 size_t total_v_size; /* total # of slots in buffer */
1127 size_t increment; /* amount to increment the buffer */
1128 size_t prev_v_size;
1129
1130 /* Optimize for normal case: avoid _PyString_Resize if at all
1131 * possible via first reading into stack buffer "buf".
1132 */
1133 total_v_size = INITBUFSIZE; /* start small and pray */
1134 pvfree = buf;
1135 for (;;) {
1136 FILE_BEGIN_ALLOW_THREADS(f)
1137 pvend = buf + total_v_size;
1138 nfree = pvend - pvfree;
1139 memset(pvfree, '\n', nfree);
1140 assert(nfree < INT_MAX); /* Should be atmost MAXBUFSIZE */
1141 p = fgets(pvfree, (int)nfree, fp);
1142 FILE_END_ALLOW_THREADS(f)
1143
1144 if (p == NULL) {
1145 clearerr(fp);
1146 if (PyErr_CheckSignals())
1147 return NULL;
1148 v = PyString_FromStringAndSize(buf, pvfree - buf);
1149 return v;
1150 }
1151 /* fgets read *something* */
1152 p = memchr(pvfree, '\n', nfree);
1153 if (p != NULL) {
1154 /* Did the \n come from fgets or from us?
1155 * Since fgets stops at the first \n, and then writes
1156 * \0, if it's from fgets a \0 must be next. But if
1157 * that's so, it could not have come from us, since
1158 * the \n's we filled the buffer with have only more
1159 * \n's to the right.
1160 */
1161 if (p+1 < pvend && *(p+1) == '\0') {
1162 /* It's from fgets: we win! In particular,
1163 * we haven't done any mallocs yet, and can
1164 * build the final result on the first try.
1165 */
1166 ++p; /* include \n from fgets */
1167 }
1168 else {
1169 /* Must be from us: fgets didn't fill the
1170 * buffer and didn't find a newline, so it
1171 * must be the last and newline-free line of
1172 * the file.
1173 */
1174 assert(p > pvfree && *(p-1) == '\0');
1175 --p; /* don't include \0 from fgets */
1176 }
1177 v = PyString_FromStringAndSize(buf, p - buf);
1178 return v;
1179 }
1180 /* yuck: fgets overwrote all the newlines, i.e. the entire
1181 * buffer. So this line isn't over yet, or maybe it is but
1182 * we're exactly at EOF. If we haven't already, try using the
1183 * rest of the stack buffer.
1184 */
1185 assert(*(pvend-1) == '\0');
1186 if (pvfree == buf) {
1187 pvfree = pvend - 1; /* overwrite trailing null */
1188 total_v_size = MAXBUFSIZE;
1189 }
1190 else
1191 break;
1192 }
1193
1194 /* The stack buffer isn't big enough; malloc a string object and read
1195 * into its buffer.
1196 */
1197 total_v_size = MAXBUFSIZE << 1;
1198 v = PyString_FromStringAndSize((char*)NULL, (int)total_v_size);
1199 if (v == NULL)
1200 return v;
1201 /* copy over everything except the last null byte */
1202 memcpy(BUF(v), buf, MAXBUFSIZE-1);
1203 pvfree = BUF(v) + MAXBUFSIZE - 1;
1204
1205 /* Keep reading stuff into v; if it ever ends successfully, break
1206 * after setting p one beyond the end of the line. The code here is
1207 * very much like the code above, except reads into v's buffer; see
1208 * the code above for detailed comments about the logic.
1209 */
1210 for (;;) {
1211 FILE_BEGIN_ALLOW_THREADS(f)
1212 pvend = BUF(v) + total_v_size;
1213 nfree = pvend - pvfree;
1214 memset(pvfree, '\n', nfree);
1215 assert(nfree < INT_MAX);
1216 p = fgets(pvfree, (int)nfree, fp);
1217 FILE_END_ALLOW_THREADS(f)
1218
1219 if (p == NULL) {
1220 clearerr(fp);
1221 if (PyErr_CheckSignals()) {
1222 Py_DECREF(v);
1223 return NULL;
1224 }
1225 p = pvfree;
1226 break;
1227 }
1228 p = memchr(pvfree, '\n', nfree);
1229 if (p != NULL) {
1230 if (p+1 < pvend && *(p+1) == '\0') {
1231 /* \n came from fgets */
1232 ++p;
1233 break;
1234 }
1235 /* \n came from us; last line of file, no newline */
1236 assert(p > pvfree && *(p-1) == '\0');
1237 --p;
1238 break;
1239 }
1240 /* expand buffer and try again */
1241 assert(*(pvend-1) == '\0');
1242 increment = total_v_size >> 2; /* mild exponential growth */
1243 prev_v_size = total_v_size;
1244 total_v_size += increment;
1245 /* check for overflow */
1246 if (total_v_size <= prev_v_size ||
1247 total_v_size > PY_SSIZE_T_MAX) {
1248 PyErr_SetString(PyExc_OverflowError,
1249 "line is longer than a Python string can hold");
1250 Py_DECREF(v);
1251 return NULL;
1252 }
1253 if (_PyString_Resize(&v, (int)total_v_size) < 0)
1254 return NULL;
1255 /* overwrite the trailing null byte */
1256 pvfree = BUF(v) + (prev_v_size - 1);
1257 }
1258 if (BUF(v) + total_v_size != p)
1259 _PyString_Resize(&v, p - BUF(v));
1260 return v;
1261 #undef INITBUFSIZE
1262 #undef MAXBUFSIZE
1263 }
1264 #endif /* ifdef USE_FGETS_IN_GETLINE */
1265
1266 /* Internal routine to get a line.
1267 Size argument interpretation:
1268 > 0: max length;
1269 <= 0: read arbitrary line
1270 */
1271
1272 static PyObject *
1273 get_line(PyFileObject *f, int n)
1274 {
1275 FILE *fp = f->f_fp;
1276 int c;
1277 char *buf, *end;
1278 size_t total_v_size; /* total # of slots in buffer */
1279 size_t used_v_size; /* # used slots in buffer */
1280 size_t increment; /* amount to increment the buffer */
1281 PyObject *v;
1282 int newlinetypes = f->f_newlinetypes;
1283 int skipnextlf = f->f_skipnextlf;
1284 int univ_newline = f->f_univ_newline;
1285
1286 #if defined(USE_FGETS_IN_GETLINE)
1287 if (n <= 0 && !univ_newline )
1288 return getline_via_fgets(f, fp);
1289 #endif
1290 total_v_size = n > 0 ? n : 100;
1291 v = PyString_FromStringAndSize((char *)NULL, total_v_size);
1292 if (v == NULL)
1293 return NULL;
1294 buf = BUF(v);
1295 end = buf + total_v_size;
1296
1297 for (;;) {
1298 FILE_BEGIN_ALLOW_THREADS(f)
1299 FLOCKFILE(fp);
1300 if (univ_newline) {
1301 c = 'x'; /* Shut up gcc warning */
1302 while ( buf != end && (c = GETC(fp)) != EOF ) {
1303 if (skipnextlf ) {
1304 skipnextlf = 0;
1305 if (c == '\n') {
1306 /* Seeing a \n here with
1307 * skipnextlf true means we
1308 * saw a \r before.
1309 */
1310 newlinetypes |= NEWLINE_CRLF;
1311 c = GETC(fp);
1312 if (c == EOF) break;
1313 } else {
1314 newlinetypes |= NEWLINE_CR;
1315 }
1316 }
1317 if (c == '\r') {
1318 skipnextlf = 1;
1319 c = '\n';
1320 } else if ( c == '\n')
1321 newlinetypes |= NEWLINE_LF;
1322 *buf++ = c;
1323 if (c == '\n') break;
1324 }
1325 if ( c == EOF && skipnextlf )
1326 newlinetypes |= NEWLINE_CR;
1327 } else /* If not universal newlines use the normal loop */
1328 while ((c = GETC(fp)) != EOF &&
1329 (*buf++ = c) != '\n' &&
1330 buf != end)
1331 ;
1332 FUNLOCKFILE(fp);
1333 FILE_END_ALLOW_THREADS(f)
1334 f->f_newlinetypes = newlinetypes;
1335 f->f_skipnextlf = skipnextlf;
1336 if (c == '\n')
1337 break;
1338 if (c == EOF) {
1339 if (ferror(fp)) {
1340 PyErr_SetFromErrno(PyExc_IOError);
1341 clearerr(fp);
1342 Py_DECREF(v);
1343 return NULL;
1344 }
1345 clearerr(fp);
1346 if (PyErr_CheckSignals()) {
1347 Py_DECREF(v);
1348 return NULL;
1349 }
1350 break;
1351 }
1352 /* Must be because buf == end */
1353 if (n > 0)
1354 break;
1355 used_v_size = total_v_size;
1356 increment = total_v_size >> 2; /* mild exponential growth */
1357 total_v_size += increment;
1358 if (total_v_size > PY_SSIZE_T_MAX) {
1359 PyErr_SetString(PyExc_OverflowError,
1360 "line is longer than a Python string can hold");
1361 Py_DECREF(v);
1362 return NULL;
1363 }
1364 if (_PyString_Resize(&v, total_v_size) < 0)
1365 return NULL;
1366 buf = BUF(v) + used_v_size;
1367 end = BUF(v) + total_v_size;
1368 }
1369
1370 used_v_size = buf - BUF(v);
1371 if (used_v_size != total_v_size)
1372 _PyString_Resize(&v, used_v_size);
1373 return v;
1374 }
1375
1376 /* External C interface */
1377
1378 PyObject *
1379 PyFile_GetLine(PyObject *f, int n)
1380 {
1381 PyObject *result;
1382
1383 if (f == NULL) {
1384 PyErr_BadInternalCall();
1385 return NULL;
1386 }
1387
1388 if (PyFile_Check(f)) {
1389 PyFileObject *fo = (PyFileObject *)f;
1390 if (fo->f_fp == NULL)
1391 return err_closed();
1392 /* refuse to mix with f.next() */
1393 if (fo->f_buf != NULL &&
1394 (fo->f_bufend - fo->f_bufptr) > 0 &&
1395 fo->f_buf[0] != '\0')
1396 return err_iterbuffered();
1397 result = get_line(fo, n);
1398 }
1399 else {
1400 PyObject *reader;
1401 PyObject *args;
1402
1403 reader = PyObject_GetAttrString(f, "readline");
1404 if (reader == NULL)
1405 return NULL;
1406 if (n <= 0)
1407 args = PyTuple_New(0);
1408 else
1409 args = Py_BuildValue("(i)", n);
1410 if (args == NULL) {
1411 Py_DECREF(reader);
1412 return NULL;
1413 }
1414 result = PyEval_CallObject(reader, args);
1415 Py_DECREF(reader);
1416 Py_DECREF(args);
1417 if (result != NULL && !PyString_Check(result) &&
1418 !PyUnicode_Check(result)) {
1419 Py_DECREF(result);
1420 result = NULL;
1421 PyErr_SetString(PyExc_TypeError,
1422 "object.readline() returned non-string");
1423 }
1424 }
1425
1426 if (n < 0 && result != NULL && PyString_Check(result)) {
1427 char *s = PyString_AS_STRING(result);
1428 Py_ssize_t len = PyString_GET_SIZE(result);
1429 if (len == 0) {
1430 Py_DECREF(result);
1431 result = NULL;
1432 PyErr_SetString(PyExc_EOFError,
1433 "EOF when reading a line");
1434 }
1435 else if (s[len-1] == '\n') {
1436 if (result->ob_refcnt == 1)
1437 _PyString_Resize(&result, len-1);
1438 else {
1439 PyObject *v;
1440 v = PyString_FromStringAndSize(s, len-1);
1441 Py_DECREF(result);
1442 result = v;
1443 }
1444 }
1445 }
1446 #ifdef Py_USING_UNICODE
1447 if (n < 0 && result != NULL && PyUnicode_Check(result)) {
1448 Py_UNICODE *s = PyUnicode_AS_UNICODE(result);
1449 Py_ssize_t len = PyUnicode_GET_SIZE(result);
1450 if (len == 0) {
1451 Py_DECREF(result);
1452 result = NULL;
1453 PyErr_SetString(PyExc_EOFError,
1454 "EOF when reading a line");
1455 }
1456 else if (s[len-1] == '\n') {
1457 if (result->ob_refcnt == 1)
1458 PyUnicode_Resize(&result, len-1);
1459 else {
1460 PyObject *v;
1461 v = PyUnicode_FromUnicode(s, len-1);
1462 Py_DECREF(result);
1463 result = v;
1464 }
1465 }
1466 }
1467 #endif
1468 return result;
1469 }
1470
1471 /* Python method */
1472
1473 static PyObject *
1474 file_readline(PyFileObject *f, PyObject *args)
1475 {
1476 int n = -1;
1477
1478 if (f->f_fp == NULL)
1479 return err_closed();
1480 /* refuse to mix with f.next() */
1481 if (f->f_buf != NULL &&
1482 (f->f_bufend - f->f_bufptr) > 0 &&
1483 f->f_buf[0] != '\0')
1484 return err_iterbuffered();
1485 if (!PyArg_ParseTuple(args, "|i:readline", &n))
1486 return NULL;
1487 if (n == 0)
1488 return PyString_FromString("");
1489 if (n < 0)
1490 n = 0;
1491 return get_line(f, n);
1492 }
1493
1494 static PyObject *
1495 file_readlines(PyFileObject *f, PyObject *args)
1496 {
1497 long sizehint = 0;
1498 PyObject *list = NULL;
1499 PyObject *line;
1500 char small_buffer[SMALLCHUNK];
1501 char *buffer = small_buffer;
1502 size_t buffersize = SMALLCHUNK;
1503 PyObject *big_buffer = NULL;
1504 size_t nfilled = 0;
1505 size_t nread;
1506 size_t totalread = 0;
1507 char *p, *q, *end;
1508 int err;
1509 int shortread = 0;
1510
1511 if (f->f_fp == NULL)
1512 return err_closed();
1513 /* refuse to mix with f.next() */
1514 if (f->f_buf != NULL &&
1515 (f->f_bufend - f->f_bufptr) > 0 &&
1516 f->f_buf[0] != '\0')
1517 return err_iterbuffered();
1518 if (!PyArg_ParseTuple(args, "|l:readlines", &sizehint))
1519 return NULL;
1520 if ((list = PyList_New(0)) == NULL)
1521 return NULL;
1522 for (;;) {
1523 if (shortread)
1524 nread = 0;
1525 else {
1526 FILE_BEGIN_ALLOW_THREADS(f)
1527 errno = 0;
1528 nread = Py_UniversalNewlineFread(buffer+nfilled,
1529 buffersize-nfilled, f->f_fp, (PyObject *)f);
1530 FILE_END_ALLOW_THREADS(f)
1531 shortread = (nread < buffersize-nfilled);
1532 }
1533 if (nread == 0) {
1534 sizehint = 0;
1535 if (!ferror(f->f_fp))
1536 break;
1537 PyErr_SetFromErrno(PyExc_IOError);
1538 clearerr(f->f_fp);
1539 goto error;
1540 }
1541 totalread += nread;
1542 p = (char *)memchr(buffer+nfilled, '\n', nread);
1543 if (p == NULL) {
1544 /* Need a larger buffer to fit this line */
1545 nfilled += nread;
1546 buffersize *= 2;
1547 if (buffersize > PY_SSIZE_T_MAX) {
1548 PyErr_SetString(PyExc_OverflowError,
1549 "line is longer than a Python string can hold");
1550 goto error;
1551 }
1552 if (big_buffer == NULL) {
1553 /* Create the big buffer */
1554 big_buffer = PyString_FromStringAndSize(
1555 NULL, buffersize);
1556 if (big_buffer == NULL)
1557 goto error;
1558 buffer = PyString_AS_STRING(big_buffer);
1559 memcpy(buffer, small_buffer, nfilled);
1560 }
1561 else {
1562 /* Grow the big buffer */
1563 if ( _PyString_Resize(&big_buffer, buffersize) < 0 )
1564 goto error;
1565 buffer = PyString_AS_STRING(big_buffer);
1566 }
1567 continue;
1568 }
1569 end = buffer+nfilled+nread;
1570 q = buffer;
1571 do {
1572 /* Process complete lines */
1573 p++;
1574 line = PyString_FromStringAndSize(q, p-q);
1575 if (line == NULL)
1576 goto error;
1577 err = PyList_Append(list, line);
1578 Py_DECREF(line);
1579 if (err != 0)
1580 goto error;
1581 q = p;
1582 p = (char *)memchr(q, '\n', end-q);
1583 } while (p != NULL);
1584 /* Move the remaining incomplete line to the start */
1585 nfilled = end-q;
1586 memmove(buffer, q, nfilled);
1587 if (sizehint > 0)
1588 if (totalread >= (size_t)sizehint)
1589 break;
1590 }
1591 if (nfilled != 0) {
1592 /* Partial last line */
1593 line = PyString_FromStringAndSize(buffer, nfilled);
1594 if (line == NULL)
1595 goto error;
1596 if (sizehint > 0) {
1597 /* Need to complete the last line */
1598 PyObject *rest = get_line(f, 0);
1599 if (rest == NULL) {
1600 Py_DECREF(line);
1601 goto error;
1602 }
1603 PyString_Concat(&line, rest);
1604 Py_DECREF(rest);
1605 if (line == NULL)
1606 goto error;
1607 }
1608 err = PyList_Append(list, line);
1609 Py_DECREF(line);
1610 if (err != 0)
1611 goto error;
1612 }
1613
1614 cleanup:
1615 Py_XDECREF(big_buffer);
1616 return list;
1617
1618 error:
1619 Py_CLEAR(list);
1620 goto cleanup;
1621 }
1622
1623 static PyObject *
1624 file_write(PyFileObject *f, PyObject *args)
1625 {
1626 Py_buffer pbuf;
1627 char *s;
1628 Py_ssize_t n, n2;
1629 if (f->f_fp == NULL)
1630 return err_closed();
1631 if (f->f_binary) {
1632 if (!PyArg_ParseTuple(args, "s*", &pbuf))
1633 return NULL;
1634 s = pbuf.buf;
1635 n = pbuf.len;
1636 } else
1637 if (!PyArg_ParseTuple(args, "t#", &s, &n))
1638 return NULL;
1639 f->f_softspace = 0;
1640 FILE_BEGIN_ALLOW_THREADS(f)
1641 errno = 0;
1642 n2 = fwrite(s, 1, n, f->f_fp);
1643 FILE_END_ALLOW_THREADS(f)
1644 if (f->f_binary)
1645 PyBuffer_Release(&pbuf);
1646 if (n2 != n) {
1647 PyErr_SetFromErrno(PyExc_IOError);
1648 clearerr(f->f_fp);
1649 return NULL;
1650 }
1651 Py_INCREF(Py_None);
1652 return Py_None;
1653 }
1654
1655 static PyObject *
1656 file_writelines(PyFileObject *f, PyObject *seq)
1657 {
1658 #define CHUNKSIZE 1000
1659 PyObject *list, *line;
1660 PyObject *it; /* iter(seq) */
1661 PyObject *result;
1662 int index, islist;
1663 Py_ssize_t i, j, nwritten, len;
1664
1665 assert(seq != NULL);
1666 if (f->f_fp == NULL)
1667 return err_closed();
1668
1669 result = NULL;
1670 list = NULL;
1671 islist = PyList_Check(seq);
1672 if (islist)
1673 it = NULL;
1674 else {
1675 it = PyObject_GetIter(seq);
1676 if (it == NULL) {
1677 PyErr_SetString(PyExc_TypeError,
1678 "writelines() requires an iterable argument");
1679 return NULL;
1680 }
1681 /* From here on, fail by going to error, to reclaim "it". */
1682 list = PyList_New(CHUNKSIZE);
1683 if (list == NULL)
1684 goto error;
1685 }
1686
1687 /* Strategy: slurp CHUNKSIZE lines into a private list,
1688 checking that they are all strings, then write that list
1689 without holding the interpreter lock, then come back for more. */
1690 for (index = 0; ; index += CHUNKSIZE) {
1691 if (islist) {
1692 Py_XDECREF(list);
1693 list = PyList_GetSlice(seq, index, index+CHUNKSIZE);
1694 if (list == NULL)
1695 goto error;
1696 j = PyList_GET_SIZE(list);
1697 }
1698 else {
1699 for (j = 0; j < CHUNKSIZE; j++) {
1700 line = PyIter_Next(it);
1701 if (line == NULL) {
1702 if (PyErr_Occurred())
1703 goto error;
1704 break;
1705 }
1706 PyList_SetItem(list, j, line);
1707 }
1708 }
1709 if (j == 0)
1710 break;
1711
1712 /* Check that all entries are indeed strings. If not,
1713 apply the same rules as for file.write() and
1714 convert the results to strings. This is slow, but
1715 seems to be the only way since all conversion APIs
1716 could potentially execute Python code. */
1717 for (i = 0; i < j; i++) {
1718 PyObject *v = PyList_GET_ITEM(list, i);
1719 if (!PyString_Check(v)) {
1720 const char *buffer;
1721 if (((f->f_binary &&
1722 PyObject_AsReadBuffer(v,
1723 (const void**)&buffer,
1724 &len)) ||
1725 PyObject_AsCharBuffer(v,
1726 &buffer,
1727 &len))) {
1728 PyErr_SetString(PyExc_TypeError,
1729 "writelines() argument must be a sequence of strings");
1730 goto error;
1731 }
1732 line = PyString_FromStringAndSize(buffer,
1733 len);
1734 if (line == NULL)
1735 goto error;
1736 Py_DECREF(v);
1737 PyList_SET_ITEM(list, i, line);
1738 }
1739 }
1740
1741 /* Since we are releasing the global lock, the
1742 following code may *not* execute Python code. */
1743 f->f_softspace = 0;
1744 FILE_BEGIN_ALLOW_THREADS(f)
1745 errno = 0;
1746 for (i = 0; i < j; i++) {
1747 line = PyList_GET_ITEM(list, i);
1748 len = PyString_GET_SIZE(line);
1749 nwritten = fwrite(PyString_AS_STRING(line),
1750 1, len, f->f_fp);
1751 if (nwritten != len) {
1752 FILE_ABORT_ALLOW_THREADS(f)
1753 PyErr_SetFromErrno(PyExc_IOError);
1754 clearerr(f->f_fp);
1755 goto error;
1756 }
1757 }
1758 FILE_END_ALLOW_THREADS(f)
1759
1760 if (j < CHUNKSIZE)
1761 break;
1762 }
1763
1764 Py_INCREF(Py_None);
1765 result = Py_None;
1766 error:
1767 Py_XDECREF(list);
1768 Py_XDECREF(it);
1769 return result;
1770 #undef CHUNKSIZE
1771 }
1772
1773 static PyObject *
1774 file_self(PyFileObject *f)
1775 {
1776 if (f->f_fp == NULL)
1777 return err_closed();
1778 Py_INCREF(f);
1779 return (PyObject *)f;
1780 }
1781
1782 static PyObject *
1783 file_xreadlines(PyFileObject *f)
1784 {
1785 if (PyErr_WarnPy3k("f.xreadlines() not supported in 3.x, "
1786 "try 'for line in f' instead", 1) < 0)
1787 return NULL;
1788 return file_self(f);
1789 }
1790
1791 static PyObject *
1792 file_exit(PyObject *f, PyObject *args)
1793 {
1794 PyObject *ret = PyObject_CallMethod(f, "close", NULL);
1795 if (!ret)
1796 /* If error occurred, pass through */
1797 return NULL;
1798 Py_DECREF(ret);
1799 /* We cannot return the result of close since a true
1800 * value will be interpreted as "yes, swallow the
1801 * exception if one was raised inside the with block". */
1802 Py_RETURN_NONE;
1803 }
1804
1805 PyDoc_STRVAR(readline_doc,
1806 "readline([size]) -> next line from the file, as a string.\n"
1807 "\n"
1808 "Retain newline. A non-negative size argument limits the maximum\n"
1809 "number of bytes to return (an incomplete line may be returned then).\n"
1810 "Return an empty string at EOF.");
1811
1812 PyDoc_STRVAR(read_doc,
1813 "read([size]) -> read at most size bytes, returned as a string.\n"
1814 "\n"
1815 "If the size argument is negative or omitted, read until EOF is reached.\n"
1816 "Notice that when in non-blocking mode, less data than what was requested\n"
1817 "may be returned, even if no size parameter was given.");
1818
1819 PyDoc_STRVAR(write_doc,
1820 "write(str) -> None. Write string str to file.\n"
1821 "\n"
1822 "Note that due to buffering, flush() or close() may be needed before\n"
1823 "the file on disk reflects the data written.");
1824
1825 PyDoc_STRVAR(fileno_doc,
1826 "fileno() -> integer \"file descriptor\".\n"
1827 "\n"
1828 "This is needed for lower-level file interfaces, such os.read().");
1829
1830 PyDoc_STRVAR(seek_doc,
1831 "seek(offset[, whence]) -> None. Move to new file position.\n"
1832 "\n"
1833 "Argument offset is a byte count. Optional argument whence defaults to\n"
1834 "0 (offset from start of file, offset should be >= 0); other values are 1\n"
1835 "(move relative to current position, positive or negative), and 2 (move\n"
1836 "relative to end of file, usually negative, although many platforms allow\n"
1837 "seeking beyond the end of a file). If the file is opened in text mode,\n"
1838 "only offsets returned by tell() are legal. Use of other offsets causes\n"
1839 "undefined behavior."
1840 "\n"
1841 "Note that not all file objects are seekable.");
1842
1843 #ifdef HAVE_FTRUNCATE
1844 PyDoc_STRVAR(truncate_doc,
1845 "truncate([size]) -> None. Truncate the file to at most size bytes.\n"
1846 "\n"
1847 "Size defaults to the current file position, as returned by tell().");
1848 #endif
1849
1850 PyDoc_STRVAR(tell_doc,
1851 "tell() -> current file position, an integer (may be a long integer).");
1852
1853 PyDoc_STRVAR(readinto_doc,
1854 "readinto() -> Undocumented. Don't use this; it may go away.");
1855
1856 PyDoc_STRVAR(readlines_doc,
1857 "readlines([size]) -> list of strings, each a line from the file.\n"
1858 "\n"
1859 "Call readline() repeatedly and return a list of the lines so read.\n"
1860 "The optional size argument, if given, is an approximate bound on the\n"
1861 "total number of bytes in the lines returned.");
1862
1863 PyDoc_STRVAR(xreadlines_doc,
1864 "xreadlines() -> returns self.\n"
1865 "\n"
1866 "For backward compatibility. File objects now include the performance\n"
1867 "optimizations previously implemented in the xreadlines module.");
1868
1869 PyDoc_STRVAR(writelines_doc,
1870 "writelines(sequence_of_strings) -> None. Write the strings to the file.\n"
1871 "\n"
1872 "Note that newlines are not added. The sequence can be any iterable object\n"
1873 "producing strings. This is equivalent to calling write() for each string.");
1874
1875 PyDoc_STRVAR(flush_doc,
1876 "flush() -> None. Flush the internal I/O buffer.");
1877
1878 PyDoc_STRVAR(close_doc,
1879 "close() -> None or (perhaps) an integer. Close the file.\n"
1880 "\n"
1881 "Sets data attribute .closed to True. A closed file cannot be used for\n"
1882 "further I/O operations. close() may be called more than once without\n"
1883 "error. Some kinds of file objects (for example, opened by popen())\n"
1884 "may return an exit status upon closing.");
1885
1886 PyDoc_STRVAR(isatty_doc,
1887 "isatty() -> true or false. True if the file is connected to a tty device.");
1888
1889 PyDoc_STRVAR(enter_doc,
1890 "__enter__() -> self.");
1891
1892 PyDoc_STRVAR(exit_doc,
1893 "__exit__(*excinfo) -> None. Closes the file.");
1894
1895 static PyMethodDef file_methods[] = {
1896 {"readline", (PyCFunction)file_readline, METH_VARARGS, readline_doc},
1897 {"read", (PyCFunction)file_read, METH_VARARGS, read_doc},
1898 {"write", (PyCFunction)file_write, METH_VARARGS, write_doc},
1899 {"fileno", (PyCFunction)file_fileno, METH_NOARGS, fileno_doc},
1900 {"seek", (PyCFunction)file_seek, METH_VARARGS, seek_doc},
1901 #ifdef HAVE_FTRUNCATE
1902 {"truncate", (PyCFunction)file_truncate, METH_VARARGS, truncate_doc},
1903 #endif
1904 {"tell", (PyCFunction)file_tell, METH_NOARGS, tell_doc},
1905 {"readinto", (PyCFunction)file_readinto, METH_VARARGS, readinto_doc},
1906 {"readlines", (PyCFunction)file_readlines, METH_VARARGS, readlines_doc},
1907 {"xreadlines",(PyCFunction)file_xreadlines, METH_NOARGS, xreadlines_doc},
1908 {"writelines",(PyCFunction)file_writelines, METH_O, writelines_doc},
1909 {"flush", (PyCFunction)file_flush, METH_NOARGS, flush_doc},
1910 {"close", (PyCFunction)file_close, METH_NOARGS, close_doc},
1911 {"isatty", (PyCFunction)file_isatty, METH_NOARGS, isatty_doc},
1912 {"__enter__", (PyCFunction)file_self, METH_NOARGS, enter_doc},
1913 {"__exit__", (PyCFunction)file_exit, METH_VARARGS, exit_doc},
1914 {NULL, NULL} /* sentinel */
1915 };
1916
1917 #define OFF(x) offsetof(PyFileObject, x)
1918
1919 static PyMemberDef file_memberlist[] = {
1920 {"mode", T_OBJECT, OFF(f_mode), RO,
1921 "file mode ('r', 'U', 'w', 'a', possibly with 'b' or '+' added)"},
1922 {"name", T_OBJECT, OFF(f_name), RO,
1923 "file name"},
1924 {"encoding", T_OBJECT, OFF(f_encoding), RO,
1925 "file encoding"},
1926 {"errors", T_OBJECT, OFF(f_errors), RO,
1927 "Unicode error handler"},
1928 /* getattr(f, "closed") is implemented without this table */
1929 {NULL} /* Sentinel */
1930 };
1931
1932 static PyObject *
1933 get_closed(PyFileObject *f, void *closure)
1934 {
1935 return PyBool_FromLong((long)(f->f_fp == 0));
1936 }
1937 static PyObject *
1938 get_newlines(PyFileObject *f, void *closure)
1939 {
1940 switch (f->f_newlinetypes) {
1941 case NEWLINE_UNKNOWN:
1942 Py_INCREF(Py_None);
1943 return Py_None;
1944 case NEWLINE_CR:
1945 return PyString_FromString("\r");
1946 case NEWLINE_LF:
1947 return PyString_FromString("\n");
1948 case NEWLINE_CR|NEWLINE_LF:
1949 return Py_BuildValue("(ss)", "\r", "\n");
1950 case NEWLINE_CRLF:
1951 return PyString_FromString("\r\n");
1952 case NEWLINE_CR|NEWLINE_CRLF:
1953 return Py_BuildValue("(ss)", "\r", "\r\n");
1954 case NEWLINE_LF|NEWLINE_CRLF:
1955 return Py_BuildValue("(ss)", "\n", "\r\n");
1956 case NEWLINE_CR|NEWLINE_LF|NEWLINE_CRLF:
1957 return Py_BuildValue("(sss)", "\r", "\n", "\r\n");
1958 default:
1959 PyErr_Format(PyExc_SystemError,
1960 "Unknown newlines value 0x%x\n",
1961 f->f_newlinetypes);
1962 return NULL;
1963 }
1964 }
1965
1966 static PyObject *
1967 get_softspace(PyFileObject *f, void *closure)
1968 {
1969 if (PyErr_WarnPy3k("file.softspace not supported in 3.x", 1) < 0)
1970 return NULL;
1971 return PyInt_FromLong(f->f_softspace);
1972 }
1973
1974 static int
1975 set_softspace(PyFileObject *f, PyObject *value)
1976 {
1977 int new;
1978 if (PyErr_WarnPy3k("file.softspace not supported in 3.x", 1) < 0)
1979 return -1;
1980
1981 if (value == NULL) {
1982 PyErr_SetString(PyExc_TypeError,
1983 "can't delete softspace attribute");
1984 return -1;
1985 }
1986
1987 new = PyInt_AsLong(value);
1988 if (new == -1 && PyErr_Occurred())
1989 return -1;
1990 f->f_softspace = new;
1991 return 0;
1992 }
1993
1994 static PyGetSetDef file_getsetlist[] = {
1995 {"closed", (getter)get_closed, NULL, "True if the file is closed"},
1996 {"newlines", (getter)get_newlines, NULL,
1997 "end-of-line convention used in this file"},
1998 {"softspace", (getter)get_softspace, (setter)set_softspace,
1999 "flag indicating that a space needs to be printed; used by print"},
2000 {0},
2001 };
2002
2003 static void
2004 drop_readahead(PyFileObject *f)
2005 {
2006 if (f->f_buf != NULL) {
2007 PyMem_Free(f->f_buf);
2008 f->f_buf = NULL;
2009 }
2010 }
2011
2012 /* Make sure that file has a readahead buffer with at least one byte
2013 (unless at EOF) and no more than bufsize. Returns negative value on
2014 error, will set MemoryError if bufsize bytes cannot be allocated. */
2015 static int
2016 readahead(PyFileObject *f, int bufsize)
2017 {
2018 Py_ssize_t chunksize;
2019
2020 if (f->f_buf != NULL) {
2021 if( (f->f_bufend - f->f_bufptr) >= 1)
2022 return 0;
2023 else
2024 drop_readahead(f);
2025 }
2026 if ((f->f_buf = (char *)PyMem_Malloc(bufsize)) == NULL) {
2027 PyErr_NoMemory();
2028 return -1;
2029 }
2030 FILE_BEGIN_ALLOW_THREADS(f)
2031 errno = 0;
2032 chunksize = Py_UniversalNewlineFread(
2033 f->f_buf, bufsize, f->f_fp, (PyObject *)f);
2034 FILE_END_ALLOW_THREADS(f)
2035 if (chunksize == 0) {
2036 if (ferror(f->f_fp)) {
2037 PyErr_SetFromErrno(PyExc_IOError);
2038 clearerr(f->f_fp);
2039 drop_readahead(f);
2040 return -1;
2041 }
2042 }
2043 f->f_bufptr = f->f_buf;
2044 f->f_bufend = f->f_buf + chunksize;
2045 return 0;
2046 }
2047
2048 /* Used by file_iternext. The returned string will start with 'skip'
2049 uninitialized bytes followed by the remainder of the line. Don't be
2050 horrified by the recursive call: maximum recursion depth is limited by
2051 logarithmic buffer growth to about 50 even when reading a 1gb line. */
2052
2053 static PyStringObject *
2054 readahead_get_line_skip(PyFileObject *f, int skip, int bufsize)
2055 {
2056 PyStringObject* s;
2057 char *bufptr;
2058 char *buf;
2059 Py_ssize_t len;
2060
2061 if (f->f_buf == NULL)
2062 if (readahead(f, bufsize) < 0)
2063 return NULL;
2064
2065 len = f->f_bufend - f->f_bufptr;
2066 if (len == 0)
2067 return (PyStringObject *)
2068 PyString_FromStringAndSize(NULL, skip);
2069 bufptr = (char *)memchr(f->f_bufptr, '\n', len);
2070 if (bufptr != NULL) {
2071 bufptr++; /* Count the '\n' */
2072 len = bufptr - f->f_bufptr;
2073 s = (PyStringObject *)
2074 PyString_FromStringAndSize(NULL, skip+len);
2075 if (s == NULL)
2076 return NULL;
2077 memcpy(PyString_AS_STRING(s)+skip, f->f_bufptr, len);
2078 f->f_bufptr = bufptr;
2079 if (bufptr == f->f_bufend)
2080 drop_readahead(f);
2081 } else {
2082 bufptr = f->f_bufptr;
2083 buf = f->f_buf;
2084 f->f_buf = NULL; /* Force new readahead buffer */
2085 assert(skip+len < INT_MAX);
2086 s = readahead_get_line_skip(
2087 f, (int)(skip+len), bufsize + (bufsize>>2) );
2088 if (s == NULL) {
2089 PyMem_Free(buf);
2090 return NULL;
2091 }
2092 memcpy(PyString_AS_STRING(s)+skip, bufptr, len);
2093 PyMem_Free(buf);
2094 }
2095 return s;
2096 }
2097
2098 /* A larger buffer size may actually decrease performance. */
2099 #define READAHEAD_BUFSIZE 8192
2100
2101 static PyObject *
2102 file_iternext(PyFileObject *f)
2103 {
2104 PyStringObject* l;
2105
2106 if (f->f_fp == NULL)
2107 return err_closed();
2108
2109 l = readahead_get_line_skip(f, 0, READAHEAD_BUFSIZE);
2110 if (l == NULL || PyString_GET_SIZE(l) == 0) {
2111 Py_XDECREF(l);
2112 return NULL;
2113 }
2114 return (PyObject *)l;
2115 }
2116
2117
2118 static PyObject *
2119 file_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
2120 {
2121 PyObject *self;
2122 static PyObject *not_yet_string;
2123
2124 assert(type != NULL && type->tp_alloc != NULL);
2125
2126 if (not_yet_string == NULL) {
2127 not_yet_string = PyString_InternFromString("<uninitialized file>");
2128 if (not_yet_string == NULL)
2129 return NULL;
2130 }
2131
2132 self = type->tp_alloc(type, 0);
2133 if (self != NULL) {
2134 /* Always fill in the name and mode, so that nobody else
2135 needs to special-case NULLs there. */
2136 Py_INCREF(not_yet_string);
2137 ((PyFileObject *)self)->f_name = not_yet_string;
2138 Py_INCREF(not_yet_string);
2139 ((PyFileObject *)self)->f_mode = not_yet_string;
2140 Py_INCREF(Py_None);
2141 ((PyFileObject *)self)->f_encoding = Py_None;
2142 Py_INCREF(Py_None);
2143 ((PyFileObject *)self)->f_errors = Py_None;
2144 ((PyFileObject *)self)->weakreflist = NULL;
2145 ((PyFileObject *)self)->unlocked_count = 0;
2146 }
2147 return self;
2148 }
2149
2150 static int
2151 file_init(PyObject *self, PyObject *args, PyObject *kwds)
2152 {
2153 PyFileObject *foself = (PyFileObject *)self;
2154 int ret = 0;
2155 static char *kwlist[] = {"name", "mode", "buffering", 0};
2156 char *name = NULL;
2157 char *mode = "r";
2158 int bufsize = -1;
2159 int wideargument = 0;
2160
2161 assert(PyFile_Check(self));
2162 if (foself->f_fp != NULL) {
2163 /* Have to close the existing file first. */
2164 PyObject *closeresult = file_close(foself);
2165 if (closeresult == NULL)
2166 return -1;
2167 Py_DECREF(closeresult);
2168 }
2169
2170 #ifdef Py_WIN_WIDE_FILENAMES
2171 if (GetVersion() < 0x80000000) { /* On NT, so wide API available */
2172 PyObject *po;
2173 if (PyArg_ParseTupleAndKeywords(args, kwds, "U|si:file",
2174 kwlist, &po, &mode, &bufsize)) {
2175 wideargument = 1;
2176 if (fill_file_fields(foself, NULL, po, mode,
2177 fclose) == NULL)
2178 goto Error;
2179 } else {
2180 /* Drop the argument parsing error as narrow
2181 strings are also valid. */
2182 PyErr_Clear();
2183 }
2184 }
2185 #endif
2186
2187 if (!wideargument) {
2188 PyObject *o_name;
2189
2190 if (!PyArg_ParseTupleAndKeywords(args, kwds, "et|si:file", kwlist,
2191 Py_FileSystemDefaultEncoding,
2192 &name,
2193 &mode, &bufsize))
2194 return -1;
2195
2196 /* We parse again to get the name as a PyObject */
2197 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|si:file",
2198 kwlist, &o_name, &mode,
2199 &bufsize))
2200 goto Error;
2201
2202 if (fill_file_fields(foself, NULL, o_name, mode,
2203 fclose) == NULL)
2204 goto Error;
2205 }
2206 if (open_the_file(foself, name, mode) == NULL)
2207 goto Error;
2208 foself->f_setbuf = NULL;
2209 PyFile_SetBufSize(self, bufsize);
2210 goto Done;
2211
2212 Error:
2213 ret = -1;
2214 /* fall through */
2215 Done:
2216 PyMem_Free(name); /* free the encoded string */
2217 return ret;
2218 }
2219
2220 PyDoc_VAR(file_doc) =
2221 PyDoc_STR(
2222 "file(name[, mode[, buffering]]) -> file object\n"
2223 "\n"
2224 "Open a file. The mode can be 'r', 'w' or 'a' for reading (default),\n"
2225 "writing or appending. The file will be created if it doesn't exist\n"
2226 "when opened for writing or appending; it will be truncated when\n"
2227 "opened for writing. Add a 'b' to the mode for binary files.\n"
2228 "Add a '+' to the mode to allow simultaneous reading and writing.\n"
2229 "If the buffering argument is given, 0 means unbuffered, 1 means line\n"
2230 "buffered, and larger numbers specify the buffer size. The preferred way\n"
2231 "to open a file is with the builtin open() function.\n"
2232 )
2233 PyDoc_STR(
2234 "Add a 'U' to mode to open the file for input with universal newline\n"
2235 "support. Any line ending in the input file will be seen as a '\\n'\n"
2236 "in Python. Also, a file so opened gains the attribute 'newlines';\n"
2237 "the value for this attribute is one of None (no newline read yet),\n"
2238 "'\\r', '\\n', '\\r\\n' or a tuple containing all the newline types seen.\n"
2239 "\n"
2240 "'U' cannot be combined with 'w' or '+' mode.\n"
2241 );
2242
2243 PyTypeObject PyFile_Type = {
2244 PyVarObject_HEAD_INIT(&PyType_Type, 0)
2245 "file",
2246 sizeof(PyFileObject),
2247 0,
2248 (destructor)file_dealloc, /* tp_dealloc */
2249 0, /* tp_print */
2250 0, /* tp_getattr */
2251 0, /* tp_setattr */
2252 0, /* tp_compare */
2253 (reprfunc)file_repr, /* tp_repr */
2254 0, /* tp_as_number */
2255 0, /* tp_as_sequence */
2256 0, /* tp_as_mapping */
2257 0, /* tp_hash */
2258 0, /* tp_call */
2259 0, /* tp_str */
2260 PyObject_GenericGetAttr, /* tp_getattro */
2261 /* softspace is writable: we must supply tp_setattro */
2262 PyObject_GenericSetAttr, /* tp_setattro */
2263 0, /* tp_as_buffer */
2264 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */
2265 file_doc, /* tp_doc */
2266 0, /* tp_traverse */
2267 0, /* tp_clear */
2268 0, /* tp_richcompare */
2269 offsetof(PyFileObject, weakreflist), /* tp_weaklistoffset */
2270 (getiterfunc)file_self, /* tp_iter */
2271 (iternextfunc)file_iternext, /* tp_iternext */
2272 file_methods, /* tp_methods */
2273 file_memberlist, /* tp_members */
2274 file_getsetlist, /* tp_getset */
2275 0, /* tp_base */
2276 0, /* tp_dict */
2277 0, /* tp_descr_get */
2278 0, /* tp_descr_set */
2279 0, /* tp_dictoffset */
2280 file_init, /* tp_init */
2281 PyType_GenericAlloc, /* tp_alloc */
2282 file_new, /* tp_new */
2283 PyObject_Del, /* tp_free */
2284 };
2285
2286 /* Interface for the 'soft space' between print items. */
2287
2288 int
2289 PyFile_SoftSpace(PyObject *f, int newflag)
2290 {
2291 long oldflag = 0;
2292 if (f == NULL) {
2293 /* Do nothing */
2294 }
2295 else if (PyFile_Check(f)) {
2296 oldflag = ((PyFileObject *)f)->f_softspace;
2297 ((PyFileObject *)f)->f_softspace = newflag;
2298 }
2299 else {
2300 PyObject *v;
2301 v = PyObject_GetAttrString(f, "softspace");
2302 if (v == NULL)
2303 PyErr_Clear();
2304 else {
2305 if (PyInt_Check(v))
2306 oldflag = PyInt_AsLong(v);
2307 assert(oldflag < INT_MAX);
2308 Py_DECREF(v);
2309 }
2310 v = PyInt_FromLong((long)newflag);
2311 if (v == NULL)
2312 PyErr_Clear();
2313 else {
2314 if (PyObject_SetAttrString(f, "softspace", v) != 0)
2315 PyErr_Clear();
2316 Py_DECREF(v);
2317 }
2318 }
2319 return (int)oldflag;
2320 }
2321
2322 /* Interfaces to write objects/strings to file-like objects */
2323
2324 int
2325 PyFile_WriteObject(PyObject *v, PyObject *f, int flags)
2326 {
2327 PyObject *writer, *value, *args, *result;
2328 if (f == NULL) {
2329 PyErr_SetString(PyExc_TypeError, "writeobject with NULL file");
2330 return -1;
2331 }
2332 else if (PyFile_Check(f)) {
2333 PyFileObject *fobj = (PyFileObject *) f;
2334 #ifdef Py_USING_UNICODE
2335 PyObject *enc = fobj->f_encoding;
2336 int result;
2337 #endif
2338 if (fobj->f_fp == NULL) {
2339 err_closed();
2340 return -1;
2341 }
2342 #ifdef Py_USING_UNICODE
2343 if ((flags & Py_PRINT_RAW) &&
2344 PyUnicode_Check(v) && enc != Py_None) {
2345 char *cenc = PyString_AS_STRING(enc);
2346 char *errors = fobj->f_errors == Py_None ?
2347 "strict" : PyString_AS_STRING(fobj->f_errors);
2348 value = PyUnicode_AsEncodedString(v, cenc, errors);
2349 if (value == NULL)
2350 return -1;
2351 } else {
2352 value = v;
2353 Py_INCREF(value);
2354 }
2355 result = file_PyObject_Print(value, fobj, flags);
2356 Py_DECREF(value);
2357 return result;
2358 #else
2359 return file_PyObject_Print(v, fobj, flags);
2360 #endif
2361 }
2362 writer = PyObject_GetAttrString(f, "write");
2363 if (writer == NULL)
2364 return -1;
2365 if (flags & Py_PRINT_RAW) {
2366 if (PyUnicode_Check(v)) {
2367 value = v;
2368 Py_INCREF(value);
2369 } else
2370 value = PyObject_Str(v);
2371 }
2372 else
2373 value = PyObject_Repr(v);
2374 if (value == NULL) {
2375 Py_DECREF(writer);
2376 return -1;
2377 }
2378 args = PyTuple_Pack(1, value);
2379 if (args == NULL) {
2380 Py_DECREF(value);
2381 Py_DECREF(writer);
2382 return -1;
2383 }
2384 result = PyEval_CallObject(writer, args);
2385 Py_DECREF(args);
2386 Py_DECREF(value);
2387 Py_DECREF(writer);
2388 if (result == NULL)
2389 return -1;
2390 Py_DECREF(result);
2391 return 0;
2392 }
2393
2394 int
2395 PyFile_WriteString(const char *s, PyObject *f)
2396 {
2397
2398 if (f == NULL) {
2399 /* Should be caused by a pre-existing error */
2400 if (!PyErr_Occurred())
2401 PyErr_SetString(PyExc_SystemError,
2402 "null file for PyFile_WriteString");
2403 return -1;
2404 }
2405 else if (PyFile_Check(f)) {
2406 PyFileObject *fobj = (PyFileObject *) f;
2407 FILE *fp = PyFile_AsFile(f);
2408 if (fp == NULL) {
2409 err_closed();
2410 return -1;
2411 }
2412 FILE_BEGIN_ALLOW_THREADS(fobj)
2413 fputs(s, fp);
2414 FILE_END_ALLOW_THREADS(fobj)
2415 return 0;
2416 }
2417 else if (!PyErr_Occurred()) {
2418 PyObject *v = PyString_FromString(s);
2419 int err;
2420 if (v == NULL)
2421 return -1;
2422 err = PyFile_WriteObject(v, f, Py_PRINT_RAW);
2423 Py_DECREF(v);
2424 return err;
2425 }
2426 else
2427 return -1;
2428 }
2429
2430 /* Try to get a file-descriptor from a Python object. If the object
2431 is an integer or long integer, its value is returned. If not, the
2432 object's fileno() method is called if it exists; the method must return
2433 an integer or long integer, which is returned as the file descriptor value.
2434 -1 is returned on failure.
2435 */
2436
2437 int PyObject_AsFileDescriptor(PyObject *o)
2438 {
2439 int fd;
2440 PyObject *meth;
2441
2442 if (PyInt_Check(o)) {
2443 fd = PyInt_AsLong(o);
2444 }
2445 else if (PyLong_Check(o)) {
2446 fd = PyLong_AsLong(o);
2447 }
2448 else if ((meth = PyObject_GetAttrString(o, "fileno")) != NULL)
2449 {
2450 PyObject *fno = PyEval_CallObject(meth, NULL);
2451 Py_DECREF(meth);
2452 if (fno == NULL)
2453 return -1;
2454
2455 if (PyInt_Check(fno)) {
2456 fd = PyInt_AsLong(fno);
2457 Py_DECREF(fno);
2458 }
2459 else if (PyLong_Check(fno)) {
2460 fd = PyLong_AsLong(fno);
2461 Py_DECREF(fno);
2462 }
2463 else {
2464 PyErr_SetString(PyExc_TypeError,
2465 "fileno() returned a non-integer");
2466 Py_DECREF(fno);
2467 return -1;
2468 }
2469 }
2470 else {
2471 PyErr_SetString(PyExc_TypeError,
2472 "argument must be an int, or have a fileno() method.");
2473 return -1;
2474 }
2475
2476 if (fd < 0) {
2477 PyErr_Format(PyExc_ValueError,
2478 "file descriptor cannot be a negative integer (%i)",
2479 fd);
2480 return -1;
2481 }
2482 return fd;
2483 }
2484
2485 /* From here on we need access to the real fgets and fread */
2486 #undef fgets
2487 #undef fread
2488
2489 /*
2490 ** Py_UniversalNewlineFgets is an fgets variation that understands
2491 ** all of \r, \n and \r\n conventions.
2492 ** The stream should be opened in binary mode.
2493 ** If fobj is NULL the routine always does newline conversion, and
2494 ** it may peek one char ahead to gobble the second char in \r\n.
2495 ** If fobj is non-NULL it must be a PyFileObject. In this case there
2496 ** is no readahead but in stead a flag is used to skip a following
2497 ** \n on the next read. Also, if the file is open in binary mode
2498 ** the whole conversion is skipped. Finally, the routine keeps track of
2499 ** the different types of newlines seen.
2500 ** Note that we need no error handling: fgets() treats error and eof
2501 ** identically.
2502 */
2503 char *
2504 Py_UniversalNewlineFgets(char *buf, int n, FILE *stream, PyObject *fobj)
2505 {
2506 char *p = buf;
2507 int c;
2508 int newlinetypes = 0;
2509 int skipnextlf = 0;
2510 int univ_newline = 1;
2511
2512 if (fobj) {
2513 if (!PyFile_Check(fobj)) {
2514 errno = ENXIO; /* What can you do... */
2515 return NULL;
2516 }
2517 univ_newline = ((PyFileObject *)fobj)->f_univ_newline;
2518 if ( !univ_newline )
2519 return fgets(buf, n, stream);
2520 newlinetypes = ((PyFileObject *)fobj)->f_newlinetypes;
2521 skipnextlf = ((PyFileObject *)fobj)->f_skipnextlf;
2522 }
2523 FLOCKFILE(stream);
2524 c = 'x'; /* Shut up gcc warning */
2525 while (--n > 0 && (c = GETC(stream)) != EOF ) {
2526 if (skipnextlf ) {
2527 skipnextlf = 0;
2528 if (c == '\n') {
2529 /* Seeing a \n here with skipnextlf true
2530 ** means we saw a \r before.
2531 */
2532 newlinetypes |= NEWLINE_CRLF;
2533 c = GETC(stream);
2534 if (c == EOF) break;
2535 } else {
2536 /*
2537 ** Note that c == EOF also brings us here,
2538 ** so we're okay if the last char in the file
2539 ** is a CR.
2540 */
2541 newlinetypes |= NEWLINE_CR;
2542 }
2543 }
2544 if (c == '\r') {
2545 /* A \r is translated into a \n, and we skip
2546 ** an adjacent \n, if any. We don't set the
2547 ** newlinetypes flag until we've seen the next char.
2548 */
2549 skipnextlf = 1;
2550 c = '\n';
2551 } else if ( c == '\n') {
2552 newlinetypes |= NEWLINE_LF;
2553 }
2554 *p++ = c;
2555 if (c == '\n') break;
2556 }
2557 if ( c == EOF && skipnextlf )
2558 newlinetypes |= NEWLINE_CR;
2559 FUNLOCKFILE(stream);
2560 *p = '\0';
2561 if (fobj) {
2562 ((PyFileObject *)fobj)->f_newlinetypes = newlinetypes;
2563 ((PyFileObject *)fobj)->f_skipnextlf = skipnextlf;
2564 } else if ( skipnextlf ) {
2565 /* If we have no file object we cannot save the
2566 ** skipnextlf flag. We have to readahead, which
2567 ** will cause a pause if we're reading from an
2568 ** interactive stream, but that is very unlikely
2569 ** unless we're doing something silly like
2570 ** execfile("/dev/tty").
2571 */
2572 c = GETC(stream);
2573 if ( c != '\n' )
2574 ungetc(c, stream);
2575 }
2576 if (p == buf)
2577 return NULL;
2578 return buf;
2579 }
2580
2581 /*
2582 ** Py_UniversalNewlineFread is an fread variation that understands
2583 ** all of \r, \n and \r\n conventions.
2584 ** The stream should be opened in binary mode.
2585 ** fobj must be a PyFileObject. In this case there
2586 ** is no readahead but in stead a flag is used to skip a following
2587 ** \n on the next read. Also, if the file is open in binary mode
2588 ** the whole conversion is skipped. Finally, the routine keeps track of
2589 ** the different types of newlines seen.
2590 */
2591 size_t
2592 Py_UniversalNewlineFread(char *buf, size_t n,
2593 FILE *stream, PyObject *fobj)
2594 {
2595 char *dst = buf;
2596 PyFileObject *f = (PyFileObject *)fobj;
2597 int newlinetypes, skipnextlf;
2598
2599 assert(buf != NULL);
2600 assert(stream != NULL);
2601
2602 if (!fobj || !PyFile_Check(fobj)) {
2603 errno = ENXIO; /* What can you do... */
2604 return 0;
2605 }
2606 if (!f->f_univ_newline)
2607 return fread(buf, 1, n, stream);
2608 newlinetypes = f->f_newlinetypes;
2609 skipnextlf = f->f_skipnextlf;
2610 /* Invariant: n is the number of bytes remaining to be filled
2611 * in the buffer.
2612 */
2613 while (n) {
2614 size_t nread;
2615 int shortread;
2616 char *src = dst;
2617
2618 nread = fread(dst, 1, n, stream);
2619 assert(nread <= n);
2620 if (nread == 0)
2621 break;
2622
2623 n -= nread; /* assuming 1 byte out for each in; will adjust */
2624 shortread = n != 0; /* true iff EOF or error */
2625 while (nread--) {
2626 char c = *src++;
2627 if (c == '\r') {
2628 /* Save as LF and set flag to skip next LF. */
2629 *dst++ = '\n';
2630 skipnextlf = 1;
2631 }
2632 else if (skipnextlf && c == '\n') {
2633 /* Skip LF, and remember we saw CR LF. */
2634 skipnextlf = 0;
2635 newlinetypes |= NEWLINE_CRLF;
2636 ++n;
2637 }
2638 else {
2639 /* Normal char to be stored in buffer. Also
2640 * update the newlinetypes flag if either this
2641 * is an LF or the previous char was a CR.
2642 */
2643 if (c == '\n')
2644 newlinetypes |= NEWLINE_LF;
2645 else if (skipnextlf)
2646 newlinetypes |= NEWLINE_CR;
2647 *dst++ = c;
2648 skipnextlf = 0;
2649 }
2650 }
2651 if (shortread) {
2652 /* If this is EOF, update type flags. */
2653 if (skipnextlf && feof(stream))
2654 newlinetypes |= NEWLINE_CR;
2655 break;
2656 }
2657 }
2658 f->f_newlinetypes = newlinetypes;
2659 f->f_skipnextlf = skipnextlf;
2660 return dst - buf;
2661 }
2662
2663 #ifdef __cplusplus
2664 }
2665 #endif
python git mirror