cpython-lru_cache-weakref: Objects/fileobject.c annotate

annotate Objects/fileobject.c @ 25838:8540887bcec6 2.2

Backport of 2.183: Fix memory leak in add_subclass() found by NealN with valgrind.

author	Guido van Rossum <guido@python.org>
date	Fri, 18 Oct 2002 13:42:21 +0000
parents	91b4f7abeba8
children	43c7d8a084fb

rev	line source
145 853b736a6a9e Added copyright notice. Guido van Rossum <guido@python.org> parents: 138 diff changeset	1
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2 /* File object implementation */
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	3
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	4 #include "Python.h"
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	5 #include "structmember.h"
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	6
11243 6aac31cd2102 Patch by Mark Hammond to avoid certain header files on Windows/CE. Guido van Rossum <guido@python.org> parents: 10562 diff changeset	7 #ifndef DONT_HAVE_SYS_TYPES_H
9809 93d70308be17 Need to include <sys/types.h> for off_t. Guido van Rossum <guido@python.org> parents: 9789 diff changeset	8 #include <sys/types.h>
11243 6aac31cd2102 Patch by Mark Hammond to avoid certain header files on Windows/CE. Guido van Rossum <guido@python.org> parents: 10562 diff changeset	9 #endif /* DONT_HAVE_SYS_TYPES_H */
9809 93d70308be17 Need to include <sys/types.h> for off_t. Guido van Rossum <guido@python.org> parents: 9789 diff changeset	10
5414 013ff6951909 Fix by Mark Hammond to enable truncate() on Windows. Guido van Rossum <guido@python.org> parents: 5410 diff changeset	11 #ifdef MS_WIN32
013ff6951909 Fix by Mark Hammond to enable truncate() on Windows. Guido van Rossum <guido@python.org> parents: 5410 diff changeset	12 #define fileno _fileno
22340 7ecc49117d7e Take Tim's work on file.truncate out of 2.2.1 again. Michael W. Hudson <mwh@python.net> parents: 22337 diff changeset	13 /* can (almost fully) duplicate with _chsize, see file_truncate */
5414 013ff6951909 Fix by Mark Hammond to enable truncate() on Windows. Guido van Rossum <guido@python.org> parents: 5410 diff changeset	14 #define HAVE_FTRUNCATE
013ff6951909 Fix by Mark Hammond to enable truncate() on Windows. Guido van Rossum <guido@python.org> parents: 5410 diff changeset	15 #endif
013ff6951909 Fix by Mark Hammond to enable truncate() on Windows. Guido van Rossum <guido@python.org> parents: 5410 diff changeset	16
8180 68ee8abd9782 Enable ftruncate() on the Mac. Guido van Rossum <guido@python.org> parents: 8160 diff changeset	17 #ifdef macintosh
68ee8abd9782 Enable ftruncate() on the Mac. Guido van Rossum <guido@python.org> parents: 8160 diff changeset	18 #ifdef USE_GUSI
68ee8abd9782 Enable ftruncate() on the Mac. Guido van Rossum <guido@python.org> parents: 8160 diff changeset	19 #define HAVE_FTRUNCATE
68ee8abd9782 Enable ftruncate() on the Mac. Guido van Rossum <guido@python.org> parents: 8160 diff changeset	20 #endif
68ee8abd9782 Enable ftruncate() on the Mac. Guido van Rossum <guido@python.org> parents: 8160 diff changeset	21 #endif
68ee8abd9782 Enable ftruncate() on the Mac. Guido van Rossum <guido@python.org> parents: 8160 diff changeset	22
2667 0b7e14bb54ae MW does not always set errno on failing fopen() Jack Jansen <jack.jansen@cwi.nl> parents: 2397 diff changeset	23 #ifdef __MWERKS__
0b7e14bb54ae MW does not always set errno on failing fopen() Jack Jansen <jack.jansen@cwi.nl> parents: 2397 diff changeset	24 /* Mwerks fopen() doesn't always set errno */
0b7e14bb54ae MW does not always set errno on failing fopen() Jack Jansen <jack.jansen@cwi.nl> parents: 2397 diff changeset	25 #define NO_FOPEN_ERRNO
0b7e14bb54ae MW does not always set errno on failing fopen() Jack Jansen <jack.jansen@cwi.nl> parents: 2397 diff changeset	26 #endif
2397 0736a7ec2f28 explicitly init flags in methodlists Guido van Rossum <guido@python.org> parents: 2059 diff changeset	27
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	28 #define BUF(v) PyString_AS_STRING((PyStringObject *)v)
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	29
11243 6aac31cd2102 Patch by Mark Hammond to avoid certain header files on Windows/CE. Guido van Rossum <guido@python.org> parents: 10562 diff changeset	30 #ifndef DONT_HAVE_ERRNO_H
1319 cd397266dc1c * Makefile: added all: and default: targets. Guido van Rossum <guido@python.org> parents: 1313 diff changeset	31 #include <errno.h>
11243 6aac31cd2102 Patch by Mark Hammond to avoid certain header files on Windows/CE. Guido van Rossum <guido@python.org> parents: 10562 diff changeset	32 #endif
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	33
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	34
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	35 typedef struct {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	36 PyObject_HEAD
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	37 FILE *f_fp;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	38 PyObject *f_name;
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	39 PyObject *f_mode;
13447 a89f7f268de4 Nuke all remaining occurrences of Py_PROTO and Py_FPROTO. Tim Peters <tim.peters@gmail.com> parents: 13360 diff changeset	40 int (f_close)(FILE );
177 bd49ca6c4add Added 'softspace' interface to replace 'needspace' printing hack. Guido van Rossum <guido@python.org> parents: 154 diff changeset	41 int f_softspace; /* Flag used by 'print' command */
11969 74b7213fb609 Many changes for Unicode, by Marc-Andre Lemburg. Guido van Rossum <guido@python.org> parents: 11882 diff changeset	42 int f_binary; /* Flag which indicates whether the file is open
74b7213fb609 Many changes for Unicode, by Marc-Andre Lemburg. Guido van Rossum <guido@python.org> parents: 11882 diff changeset	43 open in binary (1) or test (0) mode */
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	44 } PyFileObject;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	45
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	46 FILE *
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	47 PyFile_AsFile(PyObject *f)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	48 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	49 if (f == NULL \|\| !PyFile_Check(f))
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	50 return NULL;
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	51 else
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	52 return ((PyFileObject *)f)->f_fp;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	53 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	54
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	55 PyObject *
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	56 PyFile_Name(PyObject *f)
1354 fccd415e2eb8 * bltinmodule.c: removed exec() built-in function. Guido van Rossum <guido@python.org> parents: 1319 diff changeset	57 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	58 if (f == NULL \|\| !PyFile_Check(f))
1354 fccd415e2eb8 * bltinmodule.c: removed exec() built-in function. Guido van Rossum <guido@python.org> parents: 1319 diff changeset	59 return NULL;
fccd415e2eb8 * bltinmodule.c: removed exec() built-in function. Guido van Rossum <guido@python.org> parents: 1319 diff changeset	60 else
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	61 return ((PyFileObject *)f)->f_name;
1354 fccd415e2eb8 * bltinmodule.c: removed exec() built-in function. Guido van Rossum <guido@python.org> parents: 1319 diff changeset	62 }
fccd415e2eb8 * bltinmodule.c: removed exec() built-in function. Guido van Rossum <guido@python.org> parents: 1319 diff changeset	63
19894 51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	64
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	65 static PyObject *
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	66 fill_file_fields(PyFileObject f, FILE fp, char name, char mode,
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	67 int (close)(FILE ))
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	68 {
19894 51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	69 assert(f != NULL);
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	70 assert(PyFile_Check(f));
19905 a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	71 assert(f->f_fp == NULL);
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	72
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	73 Py_DECREF(f->f_name);
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	74 Py_DECREF(f->f_mode);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	75 f->f_name = PyString_FromString(name);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	76 f->f_mode = PyString_FromString(mode);
19905 a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	77
261 f4a944e9835f In support of popen(), file objects are now parametrized with a close Guido van Rossum <guido@python.org> parents: 251 diff changeset	78 f->f_close = close;
177 bd49ca6c4add Added 'softspace' interface to replace 'needspace' printing hack. Guido van Rossum <guido@python.org> parents: 154 diff changeset	79 f->f_softspace = 0;
19894 51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	80 f->f_binary = strchr(mode,'b') != NULL;
19905 a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	81
19894 51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	82 if (f->f_name == NULL \|\| f->f_mode == NULL)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	83 return NULL;
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	84 f->f_fp = fp;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	85 return (PyObject *) f;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	86 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	87
19894 51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	88 static PyObject *
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	89 open_the_file(PyFileObject f, char name, char *mode)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	90 {
19894 51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	91 assert(f != NULL);
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	92 assert(PyFile_Check(f));
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	93 assert(name != NULL);
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	94 assert(mode != NULL);
19905 a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	95 assert(f->f_fp == NULL);
19894 51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	96
19901 07818cbcd302 Now that file objects are subclassable, you can get at the file constructor Tim Peters <tim.peters@gmail.com> parents: 19894 diff changeset	97 /* rexec.py can't stop a user from getting the file() constructor --
07818cbcd302 Now that file objects are subclassable, you can get at the file constructor Tim Peters <tim.peters@gmail.com> parents: 19894 diff changeset	98 all they have to do is get any file object f, and then do
07818cbcd302 Now that file objects are subclassable, you can get at the file constructor Tim Peters <tim.peters@gmail.com> parents: 19894 diff changeset	99 type(f). Here we prevent them from doing damage with it. */
07818cbcd302 Now that file objects are subclassable, you can get at the file constructor Tim Peters <tim.peters@gmail.com> parents: 19894 diff changeset	100 if (PyEval_GetRestricted()) {
07818cbcd302 Now that file objects are subclassable, you can get at the file constructor Tim Peters <tim.peters@gmail.com> parents: 19894 diff changeset	101 PyErr_SetString(PyExc_IOError,
07818cbcd302 Now that file objects are subclassable, you can get at the file constructor Tim Peters <tim.peters@gmail.com> parents: 19894 diff changeset	102 "file() constructor not accessible in restricted mode");
07818cbcd302 Now that file objects are subclassable, you can get at the file constructor Tim Peters <tim.peters@gmail.com> parents: 19894 diff changeset	103 return NULL;
07818cbcd302 Now that file objects are subclassable, you can get at the file constructor Tim Peters <tim.peters@gmail.com> parents: 19894 diff changeset	104 }
20942 d3dd0c2a1771 open_the_file(): Explicitly set errno to 0 before calling fopen(). Tim Peters <tim.peters@gmail.com> parents: 20935 diff changeset	105 errno = 0;
2053 de49d49044d7 Lots of minor changes. Note for mappingobject.c: the hash table pointer Guido van Rossum <guido@python.org> parents: 1746 diff changeset	106 #ifdef HAVE_FOPENRF
138 bb24948957e3 Hack to open resource fork on the Mac: open(filename, 'rb'). Guido van Rossum <guido@python.org>* parents: 109 diff changeset	107 if (mode == '') {
bb24948957e3 Hack to open resource fork on the Mac: open(filename, 'rb'). Guido van Rossum <guido@python.org>* parents: 109 diff changeset	108 FILE *fopenRF();
bb24948957e3 Hack to open resource fork on the Mac: open(filename, 'rb'). Guido van Rossum <guido@python.org>* parents: 109 diff changeset	109 f->f_fp = fopenRF(name, mode+1);
bb24948957e3 Hack to open resource fork on the Mac: open(filename, 'rb'). Guido van Rossum <guido@python.org>* parents: 109 diff changeset	110 }
bb24948957e3 Hack to open resource fork on the Mac: open(filename, 'rb'). Guido van Rossum <guido@python.org>* parents: 109 diff changeset	111 else
bb24948957e3 Hack to open resource fork on the Mac: open(filename, 'rb'). Guido van Rossum <guido@python.org>* parents: 109 diff changeset	112 #endif
926 c156d4960c2b * Makefile: cosmetics Guido van Rossum <guido@python.org> parents: 923 diff changeset	113 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	114 Py_BEGIN_ALLOW_THREADS
926 c156d4960c2b * Makefile: cosmetics Guido van Rossum <guido@python.org> parents: 923 diff changeset	115 f->f_fp = fopen(name, mode);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	116 Py_END_ALLOW_THREADS
926 c156d4960c2b * Makefile: cosmetics Guido van Rossum <guido@python.org> parents: 923 diff changeset	117 }
138 bb24948957e3 Hack to open resource fork on the Mac: open(filename, 'rb'). Guido van Rossum <guido@python.org>* parents: 109 diff changeset	118 if (f->f_fp == NULL) {
2667 0b7e14bb54ae MW does not always set errno on failing fopen() Jack Jansen <jack.jansen@cwi.nl> parents: 2397 diff changeset	119 #ifdef NO_FOPEN_ERRNO
21113 ed3dce17fc79 Merged changes made on r22b2-branch between r22b2 and r22b2-mac (the Jack Jansen <jack.jansen@cwi.nl> parents: 21095 diff changeset	120 /* Metroworks only, wich does not always sets errno */
20924 21fa75790822 Fix SF buf #476953: Bad more for opening file gives bad msg. Jeremy Hylton <jeremy@alum.mit.edu> parents: 20793 diff changeset	121 if (errno == 0) {
21113 ed3dce17fc79 Merged changes made on r22b2-branch between r22b2 and r22b2-mac (the Jack Jansen <jack.jansen@cwi.nl> parents: 21095 diff changeset	122 PyObject *v;
ed3dce17fc79 Merged changes made on r22b2-branch between r22b2 and r22b2-mac (the Jack Jansen <jack.jansen@cwi.nl> parents: 21095 diff changeset	123 v = Py_BuildValue("(is)", 0, "Cannot open file");
ed3dce17fc79 Merged changes made on r22b2-branch between r22b2 and r22b2-mac (the Jack Jansen <jack.jansen@cwi.nl> parents: 21095 diff changeset	124 if (v != NULL) {
ed3dce17fc79 Merged changes made on r22b2-branch between r22b2 and r22b2-mac (the Jack Jansen <jack.jansen@cwi.nl> parents: 21095 diff changeset	125 PyErr_SetObject(PyExc_IOError, v);
ed3dce17fc79 Merged changes made on r22b2-branch between r22b2 and r22b2-mac (the Jack Jansen <jack.jansen@cwi.nl> parents: 21095 diff changeset	126 Py_DECREF(v);
ed3dce17fc79 Merged changes made on r22b2-branch between r22b2 and r22b2-mac (the Jack Jansen <jack.jansen@cwi.nl> parents: 21095 diff changeset	127 }
2667 0b7e14bb54ae MW does not always set errno on failing fopen() Jack Jansen <jack.jansen@cwi.nl> parents: 2397 diff changeset	128 return NULL;
0b7e14bb54ae MW does not always set errno on failing fopen() Jack Jansen <jack.jansen@cwi.nl> parents: 2397 diff changeset	129 }
0b7e14bb54ae MW does not always set errno on failing fopen() Jack Jansen <jack.jansen@cwi.nl> parents: 2397 diff changeset	130 #endif
22874 c3e9a052e268 SF bug 538827: Python open w/ MSVC6: bad error msgs. Tim Peters <tim.peters@gmail.com> parents: 22340 diff changeset	131 #ifdef _MSC_VER
c3e9a052e268 SF bug 538827: Python open w/ MSVC6: bad error msgs. Tim Peters <tim.peters@gmail.com> parents: 22340 diff changeset	132 /* MSVC 6 (Microsoft) leaves errno at 0 for bad mode strings,
c3e9a052e268 SF bug 538827: Python open w/ MSVC6: bad error msgs. Tim Peters <tim.peters@gmail.com> parents: 22340 diff changeset	133 * across all Windows flavors. When it sets EINVAL varies
c3e9a052e268 SF bug 538827: Python open w/ MSVC6: bad error msgs. Tim Peters <tim.peters@gmail.com> parents: 22340 diff changeset	134 * across Windows flavors, the exact conditions aren't
c3e9a052e268 SF bug 538827: Python open w/ MSVC6: bad error msgs. Tim Peters <tim.peters@gmail.com> parents: 22340 diff changeset	135 * documented, and the answer lies in the OS's implementation
c3e9a052e268 SF bug 538827: Python open w/ MSVC6: bad error msgs. Tim Peters <tim.peters@gmail.com> parents: 22340 diff changeset	136 * of Win32's CreateFile function (whose source is secret).
c3e9a052e268 SF bug 538827: Python open w/ MSVC6: bad error msgs. Tim Peters <tim.peters@gmail.com> parents: 22340 diff changeset	137 * Seems the best we can do is map EINVAL to ENOENT.
c3e9a052e268 SF bug 538827: Python open w/ MSVC6: bad error msgs. Tim Peters <tim.peters@gmail.com> parents: 22340 diff changeset	138 */
c3e9a052e268 SF bug 538827: Python open w/ MSVC6: bad error msgs. Tim Peters <tim.peters@gmail.com> parents: 22340 diff changeset	139 if (errno == 0) /* bad mode string */
c3e9a052e268 SF bug 538827: Python open w/ MSVC6: bad error msgs. Tim Peters <tim.peters@gmail.com> parents: 22340 diff changeset	140 errno = EINVAL;
c3e9a052e268 SF bug 538827: Python open w/ MSVC6: bad error msgs. Tim Peters <tim.peters@gmail.com> parents: 22340 diff changeset	141 else if (errno == EINVAL) /* unknown, but not a mode string */
c3e9a052e268 SF bug 538827: Python open w/ MSVC6: bad error msgs. Tim Peters <tim.peters@gmail.com> parents: 22340 diff changeset	142 errno = ENOENT;
c3e9a052e268 SF bug 538827: Python open w/ MSVC6: bad error msgs. Tim Peters <tim.peters@gmail.com> parents: 22340 diff changeset	143 #endif
20924 21fa75790822 Fix SF buf #476953: Bad more for opening file gives bad msg. Jeremy Hylton <jeremy@alum.mit.edu> parents: 20793 diff changeset	144 if (errno == EINVAL)
22874 c3e9a052e268 SF bug 538827: Python open w/ MSVC6: bad error msgs. Tim Peters <tim.peters@gmail.com> parents: 22340 diff changeset	145 PyErr_Format(PyExc_IOError, "invalid mode: %s",
20924 21fa75790822 Fix SF buf #476953: Bad more for opening file gives bad msg. Jeremy Hylton <jeremy@alum.mit.edu> parents: 20793 diff changeset	146 mode);
21fa75790822 Fix SF buf #476953: Bad more for opening file gives bad msg. Jeremy Hylton <jeremy@alum.mit.edu> parents: 20793 diff changeset	147 else
21fa75790822 Fix SF buf #476953: Bad more for opening file gives bad msg. Jeremy Hylton <jeremy@alum.mit.edu> parents: 20793 diff changeset	148 PyErr_SetFromErrnoWithFilename(PyExc_IOError, name);
19894 51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	149 f = NULL;
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	150 }
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	151 return (PyObject *)f;
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	152 }
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	153
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	154 PyObject *
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	155 PyFile_FromFile(FILE fp, char name, char mode, int (close)(FILE *))
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	156 {
19905 a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	157 PyFileObject f = (PyFileObject )PyFile_Type.tp_new(&PyFile_Type,
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	158 NULL, NULL);
19894 51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	159 if (f != NULL) {
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	160 if (fill_file_fields(f, fp, name, mode, close) == NULL) {
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	161 Py_DECREF(f);
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	162 f = NULL;
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	163 }
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	164 }
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	165 return (PyObject *) f;
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	166 }
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	167
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	168 PyObject *
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	169 PyFile_FromString(char name, char mode)
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	170 {
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	171 extern int fclose(FILE *);
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	172 PyFileObject *f;
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	173
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	174 f = (PyFileObject )PyFile_FromFile((FILE )NULL, name, mode, fclose);
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	175 if (f != NULL) {
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	176 if (open_the_file(f, name, mode) == NULL) {
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	177 Py_DECREF(f);
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	178 f = NULL;
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	179 }
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	180 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	181 return (PyObject *)f;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	182 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	183
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	184 void
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	185 PyFile_SetBufSize(PyObject *f, int bufsize)
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	186 {
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	187 if (bufsize >= 0) {
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	188 #ifdef HAVE_SETVBUF
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	189 int type;
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	190 switch (bufsize) {
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	191 case 0:
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	192 type = _IONBF;
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	193 break;
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	194 case 1:
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	195 type = _IOLBF;
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	196 bufsize = BUFSIZ;
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	197 break;
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	198 default:
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	199 type = _IOFBF;
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	200 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	201 setvbuf(((PyFileObject )f)->f_fp, (char )NULL,
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	202 type, bufsize);
7572 c9f417124e0f When we have no setvbuf(), make the file totally unbuffered using Guido van Rossum <guido@python.org> parents: 7536 diff changeset	203 #else /* !HAVE_SETVBUF */
c9f417124e0f When we have no setvbuf(), make the file totally unbuffered using Guido van Rossum <guido@python.org> parents: 7536 diff changeset	204 if (bufsize <= 1)
c9f417124e0f When we have no setvbuf(), make the file totally unbuffered using Guido van Rossum <guido@python.org> parents: 7536 diff changeset	205 setbuf(((PyFileObject )f)->f_fp, (char )NULL);
c9f417124e0f When we have no setvbuf(), make the file totally unbuffered using Guido van Rossum <guido@python.org> parents: 7536 diff changeset	206 #endif /* !HAVE_SETVBUF */
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	207 }
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	208 }
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	209
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	210 static PyObject *
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	211 err_closed(void)
908 424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	212 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	213 PyErr_SetString(PyExc_ValueError, "I/O operation on closed file");
908 424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	214 return NULL;
424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	215 }
424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	216
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	217 /* Methods */
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	218
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	219 static void
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	220 file_dealloc(PyFileObject *f)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	221 {
926 c156d4960c2b * Makefile: cosmetics Guido van Rossum <guido@python.org> parents: 923 diff changeset	222 if (f->f_fp != NULL && f->f_close != NULL) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	223 Py_BEGIN_ALLOW_THREADS
261 f4a944e9835f In support of popen(), file objects are now parametrized with a close Guido van Rossum <guido@python.org> parents: 251 diff changeset	224 (*f->f_close)(f->f_fp);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	225 Py_END_ALLOW_THREADS
926 c156d4960c2b * Makefile: cosmetics Guido van Rossum <guido@python.org> parents: 923 diff changeset	226 }
19905 a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	227 Py_XDECREF(f->f_name);
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	228 Py_XDECREF(f->f_mode);
20277 2983b54256c7 Enable GC for new-style instances. This touches lots of files, since Guido van Rossum <guido@python.org> parents: 20045 diff changeset	229 f->ob_type->tp_free((PyObject *)f);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	230 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	231
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	232 static PyObject *
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	233 file_repr(PyFileObject *f)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	234 {
19476 0e70df98424e repr's converted to using PyString_FromFormat() instead of sprintf'ing Barry Warsaw <barry@python.org> parents: 19301 diff changeset	235 return PyString_FromFormat("<%s file '%s', mode '%s' at %p>",
0e70df98424e repr's converted to using PyString_FromFormat() instead of sprintf'ing Barry Warsaw <barry@python.org> parents: 19301 diff changeset	236 f->f_fp == NULL ? "closed" : "open",
0e70df98424e repr's converted to using PyString_FromFormat() instead of sprintf'ing Barry Warsaw <barry@python.org> parents: 19301 diff changeset	237 PyString_AsString(f->f_name),
0e70df98424e repr's converted to using PyString_FromFormat() instead of sprintf'ing Barry Warsaw <barry@python.org> parents: 19301 diff changeset	238 PyString_AsString(f->f_mode),
0e70df98424e repr's converted to using PyString_FromFormat() instead of sprintf'ing Barry Warsaw <barry@python.org> parents: 19301 diff changeset	239 f);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	240 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	241
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	242 static PyObject *
19301 b9701538f827 Patch #427190: Implement and use METH_NOARGS and METH_O. Martin v. Löwis <martin@v.loewis.de> parents: 19105 diff changeset	243 file_close(PyFileObject *f)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	244 {
261 f4a944e9835f In support of popen(), file objects are now parametrized with a close Guido van Rossum <guido@python.org> parents: 251 diff changeset	245 int sts = 0;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	246 if (f->f_fp != NULL) {
926 c156d4960c2b * Makefile: cosmetics Guido van Rossum <guido@python.org> parents: 923 diff changeset	247 if (f->f_close != NULL) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	248 Py_BEGIN_ALLOW_THREADS
926 c156d4960c2b * Makefile: cosmetics Guido van Rossum <guido@python.org> parents: 923 diff changeset	249 errno = 0;
261 f4a944e9835f In support of popen(), file objects are now parametrized with a close Guido van Rossum <guido@python.org> parents: 251 diff changeset	250 sts = (*f->f_close)(f->f_fp);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	251 Py_END_ALLOW_THREADS
926 c156d4960c2b * Makefile: cosmetics Guido van Rossum <guido@python.org> parents: 923 diff changeset	252 }
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	253 f->f_fp = NULL;
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	254 }
689 90ea50786095 Change error handling. Call clearerr() more often. Guido van Rossum <guido@python.org> parents: 645 diff changeset	255 if (sts == EOF)
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	256 return PyErr_SetFromErrno(PyExc_IOError);
261 f4a944e9835f In support of popen(), file objects are now parametrized with a close Guido van Rossum <guido@python.org> parents: 251 diff changeset	257 if (sts != 0)
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	258 return PyInt_FromLong((long)sts);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	259 Py_INCREF(Py_None);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	260 return Py_None;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	261 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	262
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	263
19732 b7dc5159448f Changes to automatically enable large file support on some systems. Guido van Rossum <guido@python.org> parents: 19476 diff changeset	264 /* Our very own off_t-like type, 64-bit if possible */
b7dc5159448f Changes to automatically enable large file support on some systems. Guido van Rossum <guido@python.org> parents: 19476 diff changeset	265 #if !defined(HAVE_LARGEFILE_SUPPORT)
b7dc5159448f Changes to automatically enable large file support on some systems. Guido van Rossum <guido@python.org> parents: 19476 diff changeset	266 typedef off_t Py_off_t;
b7dc5159448f Changes to automatically enable large file support on some systems. Guido van Rossum <guido@python.org> parents: 19476 diff changeset	267 #elif SIZEOF_OFF_T >= 8
b7dc5159448f Changes to automatically enable large file support on some systems. Guido van Rossum <guido@python.org> parents: 19476 diff changeset	268 typedef off_t Py_off_t;
b7dc5159448f Changes to automatically enable large file support on some systems. Guido van Rossum <guido@python.org> parents: 19476 diff changeset	269 #elif SIZEOF_FPOS_T >= 8
16903 e86875f069b1 Two improvements to large file support: Guido van Rossum <guido@python.org> parents: 15978 diff changeset	270 typedef fpos_t Py_off_t;
e86875f069b1 Two improvements to large file support: Guido van Rossum <guido@python.org> parents: 15978 diff changeset	271 #else
19732 b7dc5159448f Changes to automatically enable large file support on some systems. Guido van Rossum <guido@python.org> parents: 19476 diff changeset	272 #error "Large file support, but neither off_t nor fpos_t is large enough."
16903 e86875f069b1 Two improvements to large file support: Guido van Rossum <guido@python.org> parents: 15978 diff changeset	273 #endif
e86875f069b1 Two improvements to large file support: Guido van Rossum <guido@python.org> parents: 15978 diff changeset	274
e86875f069b1 Two improvements to large file support: Guido van Rossum <guido@python.org> parents: 15978 diff changeset	275
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	276 /* a portable fseek() function
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	277 return 0 on success, non-zero on failure (with errno set) */
17518 f939ce52a734 Make some private symbols static. Guido van Rossum <guido@python.org> parents: 16903 diff changeset	278 static int
16903 e86875f069b1 Two improvements to large file support: Guido van Rossum <guido@python.org> parents: 15978 diff changeset	279 _portable_fseek(FILE *fp, Py_off_t offset, int whence)
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	280 {
19732 b7dc5159448f Changes to automatically enable large file support on some systems. Guido van Rossum <guido@python.org> parents: 19476 diff changeset	281 #if !defined(HAVE_LARGEFILE_SUPPORT)
b7dc5159448f Changes to automatically enable large file support on some systems. Guido van Rossum <guido@python.org> parents: 19476 diff changeset	282 return fseek(fp, offset, whence);
b7dc5159448f Changes to automatically enable large file support on some systems. Guido van Rossum <guido@python.org> parents: 19476 diff changeset	283 #elif defined(HAVE_FSEEKO) && SIZEOF_OFF_T >= 8
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	284 return fseeko(fp, offset, whence);
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	285 #elif defined(HAVE_FSEEK64)
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	286 return fseek64(fp, offset, whence);
15068 a53f16b20f1d Donn Cave <donn@oz.net>: Fred Drake <fdrake@acm.org> parents: 14869 diff changeset	287 #elif defined(__BEOS__)
a53f16b20f1d Donn Cave <donn@oz.net>: Fred Drake <fdrake@acm.org> parents: 14869 diff changeset	288 return _fseek(fp, offset, whence);
19732 b7dc5159448f Changes to automatically enable large file support on some systems. Guido van Rossum <guido@python.org> parents: 19476 diff changeset	289 #elif SIZEOF_FPOS_T >= 8
15925 9d5beed0b93f Rationalizing the fallback code for portable fseek -- this is all much Guido van Rossum <guido@python.org> parents: 15876 diff changeset	290 /* lacking a 64-bit capable fseek(), use a 64-bit capable fsetpos()
9d5beed0b93f Rationalizing the fallback code for portable fseek -- this is all much Guido van Rossum <guido@python.org> parents: 15876 diff changeset	291 and fgetpos() to implement fseek()*/
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	292 fpos_t pos;
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	293 switch (whence) {
15925 9d5beed0b93f Rationalizing the fallback code for portable fseek -- this is all much Guido van Rossum <guido@python.org> parents: 15876 diff changeset	294 case SEEK_END:
19836 5420e7d348a4 _portable_fseek(): Guido van Rossum <guido@python.org> parents: 19754 diff changeset	295 #ifdef MS_WINDOWS
5420e7d348a4 _portable_fseek(): Guido van Rossum <guido@python.org> parents: 19754 diff changeset	296 fflush(fp);
5420e7d348a4 _portable_fseek(): Guido van Rossum <guido@python.org> parents: 19754 diff changeset	297 if (_lseeki64(fileno(fp), 0, 2) == -1)
5420e7d348a4 _portable_fseek(): Guido van Rossum <guido@python.org> parents: 19754 diff changeset	298 return -1;
5420e7d348a4 _portable_fseek(): Guido van Rossum <guido@python.org> parents: 19754 diff changeset	299 #else
15925 9d5beed0b93f Rationalizing the fallback code for portable fseek -- this is all much Guido van Rossum <guido@python.org> parents: 15876 diff changeset	300 if (fseek(fp, 0, SEEK_END) != 0)
9d5beed0b93f Rationalizing the fallback code for portable fseek -- this is all much Guido van Rossum <guido@python.org> parents: 15876 diff changeset	301 return -1;
19836 5420e7d348a4 _portable_fseek(): Guido van Rossum <guido@python.org> parents: 19754 diff changeset	302 #endif
15925 9d5beed0b93f Rationalizing the fallback code for portable fseek -- this is all much Guido van Rossum <guido@python.org> parents: 15876 diff changeset	303 /* fall through */
9d5beed0b93f Rationalizing the fallback code for portable fseek -- this is all much Guido van Rossum <guido@python.org> parents: 15876 diff changeset	304 case SEEK_CUR:
9d5beed0b93f Rationalizing the fallback code for portable fseek -- this is all much Guido van Rossum <guido@python.org> parents: 15876 diff changeset	305 if (fgetpos(fp, &pos) != 0)
9d5beed0b93f Rationalizing the fallback code for portable fseek -- this is all much Guido van Rossum <guido@python.org> parents: 15876 diff changeset	306 return -1;
9d5beed0b93f Rationalizing the fallback code for portable fseek -- this is all much Guido van Rossum <guido@python.org> parents: 15876 diff changeset	307 offset += pos;
9d5beed0b93f Rationalizing the fallback code for portable fseek -- this is all much Guido van Rossum <guido@python.org> parents: 15876 diff changeset	308 break;
9d5beed0b93f Rationalizing the fallback code for portable fseek -- this is all much Guido van Rossum <guido@python.org> parents: 15876 diff changeset	309 /* case SEEK_SET: break; */
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	310 }
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	311 return fsetpos(fp, &offset);
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	312 #else
19732 b7dc5159448f Changes to automatically enable large file support on some systems. Guido van Rossum <guido@python.org> parents: 19476 diff changeset	313 #error "Large file support, but no way to fseek."
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	314 #endif
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	315 }
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	316
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	317
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	318 /* a portable ftell() function
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	319 Return -1 on failure with errno set appropriately, current file
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	320 position on success */
17518 f939ce52a734 Make some private symbols static. Guido van Rossum <guido@python.org> parents: 16903 diff changeset	321 static Py_off_t
14277 984abd20eec2 Peter Schneider-Kamp <nowonder@nowonder.de>: Fred Drake <fdrake@acm.org> parents: 14215 diff changeset	322 _portable_ftell(FILE* fp)
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	323 {
19732 b7dc5159448f Changes to automatically enable large file support on some systems. Guido van Rossum <guido@python.org> parents: 19476 diff changeset	324 #if !defined(HAVE_LARGEFILE_SUPPORT)
b7dc5159448f Changes to automatically enable large file support on some systems. Guido van Rossum <guido@python.org> parents: 19476 diff changeset	325 return ftell(fp);
b7dc5159448f Changes to automatically enable large file support on some systems. Guido van Rossum <guido@python.org> parents: 19476 diff changeset	326 #elif defined(HAVE_FTELLO) && SIZEOF_OFF_T >= 8
b7dc5159448f Changes to automatically enable large file support on some systems. Guido van Rossum <guido@python.org> parents: 19476 diff changeset	327 return ftello(fp);
b7dc5159448f Changes to automatically enable large file support on some systems. Guido van Rossum <guido@python.org> parents: 19476 diff changeset	328 #elif defined(HAVE_FTELL64)
b7dc5159448f Changes to automatically enable large file support on some systems. Guido van Rossum <guido@python.org> parents: 19476 diff changeset	329 return ftell64(fp);
b7dc5159448f Changes to automatically enable large file support on some systems. Guido van Rossum <guido@python.org> parents: 19476 diff changeset	330 #elif SIZEOF_FPOS_T >= 8
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	331 fpos_t pos;
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	332 if (fgetpos(fp, &pos) != 0)
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	333 return -1;
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	334 return pos;
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	335 #else
19732 b7dc5159448f Changes to automatically enable large file support on some systems. Guido van Rossum <guido@python.org> parents: 19476 diff changeset	336 #error "Large file support, but no way to ftell."
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	337 #endif
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	338 }
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	339
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	340
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	341 static PyObject *
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	342 file_seek(PyFileObject f, PyObject args)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	343 {
908 424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	344 int whence;
926 c156d4960c2b * Makefile: cosmetics Guido van Rossum <guido@python.org> parents: 923 diff changeset	345 int ret;
16903 e86875f069b1 Two improvements to large file support: Guido van Rossum <guido@python.org> parents: 15978 diff changeset	346 Py_off_t offset;
9789 08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	347 PyObject *offobj;
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	348
908 424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	349 if (f->f_fp == NULL)
424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	350 return err_closed();
424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	351 whence = 0;
11882 dc65c5f6ad7c Massive patch by Skip Montanaro to add ":name" to as many Guido van Rossum <guido@python.org> parents: 11243 diff changeset	352 if (!PyArg_ParseTuple(args, "O\|i:seek", &offobj, &whence))
9789 08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	353 return NULL;
08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	354 #if !defined(HAVE_LARGEFILE_SUPPORT)
08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	355 offset = PyInt_AsLong(offobj);
08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	356 #else
08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	357 offset = PyLong_Check(offobj) ?
08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	358 PyLong_AsLongLong(offobj) : PyInt_AsLong(offobj);
08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	359 #endif
08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	360 if (PyErr_Occurred())
9762 ed523ea073db Fix two places (seek and truncate) where a cascade of PyArg_Parse Guido van Rossum <guido@python.org> parents: 9633 diff changeset	361 return NULL;
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	362
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	363 Py_BEGIN_ALLOW_THREADS
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	364 errno = 0;
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	365 ret = _portable_fseek(f->f_fp, offset, whence);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	366 Py_END_ALLOW_THREADS
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	367
926 c156d4960c2b * Makefile: cosmetics Guido van Rossum <guido@python.org> parents: 923 diff changeset	368 if (ret != 0) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	369 PyErr_SetFromErrno(PyExc_IOError);
689 90ea50786095 Change error handling. Call clearerr() more often. Guido van Rossum <guido@python.org> parents: 645 diff changeset	370 clearerr(f->f_fp);
90ea50786095 Change error handling. Call clearerr() more often. Guido van Rossum <guido@python.org> parents: 645 diff changeset	371 return NULL;
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	372 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	373 Py_INCREF(Py_None);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	374 return Py_None;
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	375 }
f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	376
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	377
2053 de49d49044d7 Lots of minor changes. Note for mappingobject.c: the hash table pointer Guido van Rossum <guido@python.org> parents: 1746 diff changeset	378 #ifdef HAVE_FTRUNCATE
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	379 static PyObject *
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	380 file_truncate(PyFileObject f, PyObject args)
2053 de49d49044d7 Lots of minor changes. Note for mappingobject.c: the hash table pointer Guido van Rossum <guido@python.org> parents: 1746 diff changeset	381 {
de49d49044d7 Lots of minor changes. Note for mappingobject.c: the hash table pointer Guido van Rossum <guido@python.org> parents: 1746 diff changeset	382 int ret;
16903 e86875f069b1 Two improvements to large file support: Guido van Rossum <guido@python.org> parents: 15978 diff changeset	383 Py_off_t newsize;
9789 08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	384 PyObject *newsizeobj;
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	385
2053 de49d49044d7 Lots of minor changes. Note for mappingobject.c: the hash table pointer Guido van Rossum <guido@python.org> parents: 1746 diff changeset	386 if (f->f_fp == NULL)
de49d49044d7 Lots of minor changes. Note for mappingobject.c: the hash table pointer Guido van Rossum <guido@python.org> parents: 1746 diff changeset	387 return err_closed();
9789 08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	388 newsizeobj = NULL;
11882 dc65c5f6ad7c Massive patch by Skip Montanaro to add ":name" to as many Guido van Rossum <guido@python.org> parents: 11243 diff changeset	389 if (!PyArg_ParseTuple(args, "\|O:truncate", &newsizeobj))
9762 ed523ea073db Fix two places (seek and truncate) where a cascade of PyArg_Parse Guido van Rossum <guido@python.org> parents: 9633 diff changeset	390 return NULL;
9789 08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	391 if (newsizeobj != NULL) {
08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	392 #if !defined(HAVE_LARGEFILE_SUPPORT)
08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	393 newsize = PyInt_AsLong(newsizeobj);
08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	394 #else
08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	395 newsize = PyLong_Check(newsizeobj) ?
08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	396 PyLong_AsLongLong(newsizeobj) :
08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	397 PyInt_AsLong(newsizeobj);
08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	398 #endif
08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	399 if (PyErr_Occurred())
08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	400 return NULL;
22340 7ecc49117d7e Take Tim's work on file.truncate out of 2.2.1 again. Michael W. Hudson <mwh@python.net> parents: 22337 diff changeset	401 } else {
7ecc49117d7e Take Tim's work on file.truncate out of 2.2.1 again. Michael W. Hudson <mwh@python.net> parents: 22337 diff changeset	402 /* Default to current position*/
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	403 Py_BEGIN_ALLOW_THREADS
2053 de49d49044d7 Lots of minor changes. Note for mappingobject.c: the hash table pointer Guido van Rossum <guido@python.org> parents: 1746 diff changeset	404 errno = 0;
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	405 newsize = _portable_ftell(f->f_fp);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	406 Py_END_ALLOW_THREADS
22340 7ecc49117d7e Take Tim's work on file.truncate out of 2.2.1 again. Michael W. Hudson <mwh@python.net> parents: 22337 diff changeset	407 if (newsize == -1) {
7ecc49117d7e Take Tim's work on file.truncate out of 2.2.1 again. Michael W. Hudson <mwh@python.net> parents: 22337 diff changeset	408 PyErr_SetFromErrno(PyExc_IOError);
7ecc49117d7e Take Tim's work on file.truncate out of 2.2.1 again. Michael W. Hudson <mwh@python.net> parents: 22337 diff changeset	409 clearerr(f->f_fp);
7ecc49117d7e Take Tim's work on file.truncate out of 2.2.1 again. Michael W. Hudson <mwh@python.net> parents: 22337 diff changeset	410 return NULL;
7ecc49117d7e Take Tim's work on file.truncate out of 2.2.1 again. Michael W. Hudson <mwh@python.net> parents: 22337 diff changeset	411 }
2053 de49d49044d7 Lots of minor changes. Note for mappingobject.c: the hash table pointer Guido van Rossum <guido@python.org> parents: 1746 diff changeset	412 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	413 Py_BEGIN_ALLOW_THREADS
2053 de49d49044d7 Lots of minor changes. Note for mappingobject.c: the hash table pointer Guido van Rossum <guido@python.org> parents: 1746 diff changeset	414 errno = 0;
de49d49044d7 Lots of minor changes. Note for mappingobject.c: the hash table pointer Guido van Rossum <guido@python.org> parents: 1746 diff changeset	415 ret = fflush(f->f_fp);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	416 Py_END_ALLOW_THREADS
22340 7ecc49117d7e Take Tim's work on file.truncate out of 2.2.1 again. Michael W. Hudson <mwh@python.net> parents: 22337 diff changeset	417 if (ret != 0) goto onioerror;
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	418
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	419 #ifdef MS_WIN32
22340 7ecc49117d7e Take Tim's work on file.truncate out of 2.2.1 again. Michael W. Hudson <mwh@python.net> parents: 22337 diff changeset	420 /* can use _chsize; if, however, the newsize overflows 32-bits then
7ecc49117d7e Take Tim's work on file.truncate out of 2.2.1 again. Michael W. Hudson <mwh@python.net> parents: 22337 diff changeset	421 _chsize is not adequate; in this case, an OverflowError is raised */
7ecc49117d7e Take Tim's work on file.truncate out of 2.2.1 again. Michael W. Hudson <mwh@python.net> parents: 22337 diff changeset	422 if (newsize > LONG_MAX) {
7ecc49117d7e Take Tim's work on file.truncate out of 2.2.1 again. Michael W. Hudson <mwh@python.net> parents: 22337 diff changeset	423 PyErr_SetString(PyExc_OverflowError,
7ecc49117d7e Take Tim's work on file.truncate out of 2.2.1 again. Michael W. Hudson <mwh@python.net> parents: 22337 diff changeset	424 "the new size is too long for _chsize (it is limited to 32-bit values)");
7ecc49117d7e Take Tim's work on file.truncate out of 2.2.1 again. Michael W. Hudson <mwh@python.net> parents: 22337 diff changeset	425 return NULL;
7ecc49117d7e Take Tim's work on file.truncate out of 2.2.1 again. Michael W. Hudson <mwh@python.net> parents: 22337 diff changeset	426 } else {
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	427 Py_BEGIN_ALLOW_THREADS
2053 de49d49044d7 Lots of minor changes. Note for mappingobject.c: the hash table pointer Guido van Rossum <guido@python.org> parents: 1746 diff changeset	428 errno = 0;
22340 7ecc49117d7e Take Tim's work on file.truncate out of 2.2.1 again. Michael W. Hudson <mwh@python.net> parents: 22337 diff changeset	429 ret = _chsize(fileno(f->f_fp), (long)newsize);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	430 Py_END_ALLOW_THREADS
22340 7ecc49117d7e Take Tim's work on file.truncate out of 2.2.1 again. Michael W. Hudson <mwh@python.net> parents: 22337 diff changeset	431 if (ret != 0) goto onioerror;
2053 de49d49044d7 Lots of minor changes. Note for mappingobject.c: the hash table pointer Guido van Rossum <guido@python.org> parents: 1746 diff changeset	432 }
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	433 #else
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	434 Py_BEGIN_ALLOW_THREADS
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	435 errno = 0;
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	436 ret = ftruncate(fileno(f->f_fp), newsize);
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	437 Py_END_ALLOW_THREADS
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	438 if (ret != 0) goto onioerror;
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	439 #endif /* !MS_WIN32 */
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	440
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	441 Py_INCREF(Py_None);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	442 return Py_None;
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	443
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	444 onioerror:
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	445 PyErr_SetFromErrno(PyExc_IOError);
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	446 clearerr(f->f_fp);
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	447 return NULL;
2053 de49d49044d7 Lots of minor changes. Note for mappingobject.c: the hash table pointer Guido van Rossum <guido@python.org> parents: 1746 diff changeset	448 }
de49d49044d7 Lots of minor changes. Note for mappingobject.c: the hash table pointer Guido van Rossum <guido@python.org> parents: 1746 diff changeset	449 #endif /* HAVE_FTRUNCATE */
de49d49044d7 Lots of minor changes. Note for mappingobject.c: the hash table pointer Guido van Rossum <guido@python.org> parents: 1746 diff changeset	450
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	451 static PyObject *
19301 b9701538f827 Patch #427190: Implement and use METH_NOARGS and METH_O. Martin v. Löwis <martin@v.loewis.de> parents: 19105 diff changeset	452 file_tell(PyFileObject *f)
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	453 {
16903 e86875f069b1 Two improvements to large file support: Guido van Rossum <guido@python.org> parents: 15978 diff changeset	454 Py_off_t pos;
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	455
908 424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	456 if (f->f_fp == NULL)
424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	457 return err_closed();
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	458 Py_BEGIN_ALLOW_THREADS
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	459 errno = 0;
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	460 pos = _portable_ftell(f->f_fp);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	461 Py_END_ALLOW_THREADS
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	462 if (pos == -1) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	463 PyErr_SetFromErrno(PyExc_IOError);
689 90ea50786095 Change error handling. Call clearerr() more often. Guido van Rossum <guido@python.org> parents: 645 diff changeset	464 clearerr(f->f_fp);
90ea50786095 Change error handling. Call clearerr() more often. Guido van Rossum <guido@python.org> parents: 645 diff changeset	465 return NULL;
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	466 }
9789 08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	467 #if !defined(HAVE_LARGEFILE_SUPPORT)
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	468 return PyInt_FromLong(pos);
9789 08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	469 #else
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	470 return PyLong_FromLongLong(pos);
9789 08dfbee0a32a Changes for long file support by Steve Clift. Guido van Rossum <guido@python.org> parents: 9762 diff changeset	471 #endif
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	472 }
f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	473
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	474 static PyObject *
19301 b9701538f827 Patch #427190: Implement and use METH_NOARGS and METH_O. Martin v. Löwis <martin@v.loewis.de> parents: 19105 diff changeset	475 file_fileno(PyFileObject *f)
902 a4793ae26682 Changes for new UNIX-specific built-in module 'select' and new header for Guido van Rossum <guido@python.org> parents: 795 diff changeset	476 {
908 424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	477 if (f->f_fp == NULL)
424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	478 return err_closed();
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	479 return PyInt_FromLong((long) fileno(f->f_fp));
902 a4793ae26682 Changes for new UNIX-specific built-in module 'select' and new header for Guido van Rossum <guido@python.org> parents: 795 diff changeset	480 }
a4793ae26682 Changes for new UNIX-specific built-in module 'select' and new header for Guido van Rossum <guido@python.org> parents: 795 diff changeset	481
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	482 static PyObject *
19301 b9701538f827 Patch #427190: Implement and use METH_NOARGS and METH_O. Martin v. Löwis <martin@v.loewis.de> parents: 19105 diff changeset	483 file_flush(PyFileObject *f)
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	484 {
926 c156d4960c2b * Makefile: cosmetics Guido van Rossum <guido@python.org> parents: 923 diff changeset	485 int res;
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	486
908 424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	487 if (f->f_fp == NULL)
424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	488 return err_closed();
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	489 Py_BEGIN_ALLOW_THREADS
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	490 errno = 0;
926 c156d4960c2b * Makefile: cosmetics Guido van Rossum <guido@python.org> parents: 923 diff changeset	491 res = fflush(f->f_fp);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	492 Py_END_ALLOW_THREADS
926 c156d4960c2b * Makefile: cosmetics Guido van Rossum <guido@python.org> parents: 923 diff changeset	493 if (res != 0) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	494 PyErr_SetFromErrno(PyExc_IOError);
689 90ea50786095 Change error handling. Call clearerr() more often. Guido van Rossum <guido@python.org> parents: 645 diff changeset	495 clearerr(f->f_fp);
90ea50786095 Change error handling. Call clearerr() more often. Guido van Rossum <guido@python.org> parents: 645 diff changeset	496 return NULL;
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	497 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	498 Py_INCREF(Py_None);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	499 return Py_None;
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	500 }
f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	501
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	502 static PyObject *
19301 b9701538f827 Patch #427190: Implement and use METH_NOARGS and METH_O. Martin v. Löwis <martin@v.loewis.de> parents: 19105 diff changeset	503 file_isatty(PyFileObject *f)
261 f4a944e9835f In support of popen(), file objects are now parametrized with a close Guido van Rossum <guido@python.org> parents: 251 diff changeset	504 {
926 c156d4960c2b * Makefile: cosmetics Guido van Rossum <guido@python.org> parents: 923 diff changeset	505 long res;
908 424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	506 if (f->f_fp == NULL)
424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	507 return err_closed();
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	508 Py_BEGIN_ALLOW_THREADS
926 c156d4960c2b * Makefile: cosmetics Guido van Rossum <guido@python.org> parents: 923 diff changeset	509 res = isatty((int)fileno(f->f_fp));
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	510 Py_END_ALLOW_THREADS
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	511 return PyInt_FromLong(res);
261 f4a944e9835f In support of popen(), file objects are now parametrized with a close Guido van Rossum <guido@python.org> parents: 251 diff changeset	512 }
f4a944e9835f In support of popen(), file objects are now parametrized with a close Guido van Rossum <guido@python.org> parents: 251 diff changeset	513
5477 f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	514
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	515 #if BUFSIZ < 8192
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	516 #define SMALLCHUNK 8192
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	517 #else
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	518 #define SMALLCHUNK BUFSIZ
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	519 #endif
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	520
9883 7195ec296b3d Jim Ahlstrom patch: BIGCHUNK is too large for 16-bit int. Guido van Rossum <guido@python.org> parents: 9809 diff changeset	521 #if SIZEOF_INT < 4
7195ec296b3d Jim Ahlstrom patch: BIGCHUNK is too large for 16-bit int. Guido van Rossum <guido@python.org> parents: 9809 diff changeset	522 #define BIGCHUNK (512 * 32)
7195ec296b3d Jim Ahlstrom patch: BIGCHUNK is too large for 16-bit int. Guido van Rossum <guido@python.org> parents: 9809 diff changeset	523 #else
7195ec296b3d Jim Ahlstrom patch: BIGCHUNK is too large for 16-bit int. Guido van Rossum <guido@python.org> parents: 9809 diff changeset	524 #define BIGCHUNK (512 * 1024)
7195ec296b3d Jim Ahlstrom patch: BIGCHUNK is too large for 16-bit int. Guido van Rossum <guido@python.org> parents: 9809 diff changeset	525 #endif
5477 f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	526
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	527 static size_t
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	528 new_buffersize(PyFileObject *f, size_t currentsize)
5477 f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	529 {
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	530 #ifdef HAVE_FSTAT
18755 f8bd14aef4d6 Kill more warnings from the SGI compiler. Fred Drake <fdrake@acm.org> parents: 17911 diff changeset	531 off_t pos, end;
5477 f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	532 struct stat st;
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	533 if (fstat(fileno(f->f_fp), &st) == 0) {
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	534 end = st.st_size;
9633 e2dc3cb08c60 As noted by Per Cederqvist, new_buffersize() sometimes returns the Guido van Rossum <guido@python.org> parents: 8707 diff changeset	535 /* The following is not a bug: we really need to call lseek()
e2dc3cb08c60 As noted by Per Cederqvist, new_buffersize() sometimes returns the Guido van Rossum <guido@python.org> parents: 8707 diff changeset	536 and ftell(). The reason is that some stdio libraries
e2dc3cb08c60 As noted by Per Cederqvist, new_buffersize() sometimes returns the Guido van Rossum <guido@python.org> parents: 8707 diff changeset	537 mistakenly flush their buffer when ftell() is called and
e2dc3cb08c60 As noted by Per Cederqvist, new_buffersize() sometimes returns the Guido van Rossum <guido@python.org> parents: 8707 diff changeset	538 the lseek() call it makes fails, thereby throwing away
e2dc3cb08c60 As noted by Per Cederqvist, new_buffersize() sometimes returns the Guido van Rossum <guido@python.org> parents: 8707 diff changeset	539 data that cannot be recovered in any way. To avoid this,
e2dc3cb08c60 As noted by Per Cederqvist, new_buffersize() sometimes returns the Guido van Rossum <guido@python.org> parents: 8707 diff changeset	540 we first test lseek(), and only call ftell() if lseek()
e2dc3cb08c60 As noted by Per Cederqvist, new_buffersize() sometimes returns the Guido van Rossum <guido@python.org> parents: 8707 diff changeset	541 works. We can't use the lseek() value either, because we
e2dc3cb08c60 As noted by Per Cederqvist, new_buffersize() sometimes returns the Guido van Rossum <guido@python.org> parents: 8707 diff changeset	542 need to take the amount of buffered data into account.
e2dc3cb08c60 As noted by Per Cederqvist, new_buffersize() sometimes returns the Guido van Rossum <guido@python.org> parents: 8707 diff changeset	543 (Yet another reason why stdio stinks. :-) */
20365 e46f69f5798b Rather gross workaround for a bug in the mac GUSI I/O library: Jack Jansen <jack.jansen@cwi.nl> parents: 20277 diff changeset	544 #ifdef USE_GUSI2
e46f69f5798b Rather gross workaround for a bug in the mac GUSI I/O library: Jack Jansen <jack.jansen@cwi.nl> parents: 20277 diff changeset	545 pos = lseek(fileno(f->f_fp), 1L, SEEK_CUR);
e46f69f5798b Rather gross workaround for a bug in the mac GUSI I/O library: Jack Jansen <jack.jansen@cwi.nl> parents: 20277 diff changeset	546 pos = lseek(fileno(f->f_fp), -1L, SEEK_CUR);
e46f69f5798b Rather gross workaround for a bug in the mac GUSI I/O library: Jack Jansen <jack.jansen@cwi.nl> parents: 20277 diff changeset	547 #else
8217 a19661076529 Ugly band-aid to work around a bug in Linux ftell(). Guido van Rossum <guido@python.org> parents: 8180 diff changeset	548 pos = lseek(fileno(f->f_fp), 0L, SEEK_CUR);
20365 e46f69f5798b Rather gross workaround for a bug in the mac GUSI I/O library: Jack Jansen <jack.jansen@cwi.nl> parents: 20277 diff changeset	549 #endif
e46f69f5798b Rather gross workaround for a bug in the mac GUSI I/O library: Jack Jansen <jack.jansen@cwi.nl> parents: 20277 diff changeset	550 if (pos >= 0) {
8217 a19661076529 Ugly band-aid to work around a bug in Linux ftell(). Guido van Rossum <guido@python.org> parents: 8180 diff changeset	551 pos = ftell(f->f_fp);
20365 e46f69f5798b Rather gross workaround for a bug in the mac GUSI I/O library: Jack Jansen <jack.jansen@cwi.nl> parents: 20277 diff changeset	552 }
8160 ce9fc64528a7 Clear the error condition set by ftell(). Guido van Rossum <guido@python.org> parents: 7981 diff changeset	553 if (pos < 0)
ce9fc64528a7 Clear the error condition set by ftell(). Guido van Rossum <guido@python.org> parents: 7981 diff changeset	554 clearerr(f->f_fp);
5477 f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	555 if (end > pos && pos >= 0)
9633 e2dc3cb08c60 As noted by Per Cederqvist, new_buffersize() sometimes returns the Guido van Rossum <guido@python.org> parents: 8707 diff changeset	556 return currentsize + end - pos + 1;
7536 eedac50d7744 Of course, I shouldn't have used lseek() to find out the file's Guido van Rossum <guido@python.org> parents: 7398 diff changeset	557 /* Add 1 so if the file were to grow we'd notice. */
5477 f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	558 }
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	559 #endif
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	560 if (currentsize > SMALLCHUNK) {
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	561 /* Keep doubling until we reach BIGCHUNK;
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	562 then keep adding BIGCHUNK. */
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	563 if (currentsize <= BIGCHUNK)
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	564 return currentsize + currentsize;
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	565 else
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	566 return currentsize + BIGCHUNK;
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	567 }
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	568 return currentsize + SMALLCHUNK;
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	569 }
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	570
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	571 static PyObject *
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	572 file_read(PyFileObject f, PyObject args)
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	573 {
5479 6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	574 long bytesrequested = -1;
5477 f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	575 size_t bytesread, buffersize, chunksize;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	576 PyObject *v;
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	577
908 424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	578 if (f->f_fp == NULL)
424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	579 return err_closed();
11882 dc65c5f6ad7c Massive patch by Skip Montanaro to add ":name" to as many Guido van Rossum <guido@python.org> parents: 11243 diff changeset	580 if (!PyArg_ParseTuple(args, "\|l:read", &bytesrequested))
5479 6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	581 return NULL;
5477 f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	582 if (bytesrequested < 0)
10562 a42824cf0b18 casts for picky compilers. Guido van Rossum <guido@python.org> parents: 9883 diff changeset	583 buffersize = new_buffersize(f, (size_t)0);
5477 f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	584 else
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	585 buffersize = bytesrequested;
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	586 if (buffersize > INT_MAX) {
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	587 PyErr_SetString(PyExc_OverflowError,
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	588 "requested number of bytes is more than a Python string can hold");
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	589 return NULL;
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	590 }
5477 f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	591 v = PyString_FromStringAndSize((char *)NULL, buffersize);
86 a6934380c6e7 "Compiling" version Guido van Rossum <guido@python.org> parents: 38 diff changeset	592 if (v == NULL)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	593 return NULL;
5477 f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	594 bytesread = 0;
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	595 for (;;) {
5478 266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	596 Py_BEGIN_ALLOW_THREADS
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	597 errno = 0;
5477 f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	598 chunksize = fread(BUF(v) + bytesread, 1,
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	599 buffersize - bytesread, f->f_fp);
5478 266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	600 Py_END_ALLOW_THREADS
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	601 if (chunksize == 0) {
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	602 if (!ferror(f->f_fp))
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	603 break;
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	604 PyErr_SetFromErrno(PyExc_IOError);
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	605 clearerr(f->f_fp);
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	606 Py_DECREF(v);
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	607 return NULL;
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	608 }
5477 f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	609 bytesread += chunksize;
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	610 if (bytesread < buffersize)
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	611 break;
5477 f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	612 if (bytesrequested < 0) {
9633 e2dc3cb08c60 As noted by Per Cederqvist, new_buffersize() sometimes returns the Guido van Rossum <guido@python.org> parents: 8707 diff changeset	613 buffersize = new_buffersize(f, buffersize);
5477 f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	614 if (_PyString_Resize(&v, buffersize) < 0)
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	615 return NULL;
f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	616 }
f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	617 }
5477 f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	618 if (bytesread != buffersize)
f44a56e697fb Speed up read() (i.e. read till EOF) considerably by doing a stat() to Guido van Rossum <guido@python.org> parents: 5414 diff changeset	619 _PyString_Resize(&v, bytesread);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	620 return v;
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	621 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	622
5410 3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	623 static PyObject *
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	624 file_readinto(PyFileObject f, PyObject args)
5410 3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	625 {
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	626 char *ptr;
20635 04f2801d9977 SF patch #474175 (Jay T Miller): file.readinto arg parsing bug Guido van Rossum <guido@python.org> parents: 20392 diff changeset	627 int ntodo;
04f2801d9977 SF patch #474175 (Jay T Miller): file.readinto arg parsing bug Guido van Rossum <guido@python.org> parents: 20392 diff changeset	628 size_t ndone, nnow;
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	629
5410 3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	630 if (f->f_fp == NULL)
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	631 return err_closed();
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	632 if (!PyArg_Parse(args, "w#", &ptr, &ntodo))
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	633 return NULL;
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	634 ndone = 0;
5478 266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	635 while (ntodo > 0) {
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	636 Py_BEGIN_ALLOW_THREADS
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	637 errno = 0;
5410 3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	638 nnow = fread(ptr+ndone, 1, ntodo, f->f_fp);
5478 266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	639 Py_END_ALLOW_THREADS
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	640 if (nnow == 0) {
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	641 if (!ferror(f->f_fp))
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	642 break;
5410 3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	643 PyErr_SetFromErrno(PyExc_IOError);
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	644 clearerr(f->f_fp);
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	645 return NULL;
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	646 }
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	647 ndone += nnow;
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	648 ntodo -= nnow;
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	649 }
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	650 return PyInt_FromLong((long)ndone);
5410 3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	651 }
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	652
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	653 /**************************************************************************
15875 195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	654 Routine to get next line using platform fgets().
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	655
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	656 Under MSVC 6:
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	657
15758 a1d88ab023a0 A few reformats; no logic changes. Tim Peters <tim.peters@gmail.com> parents: 15757 diff changeset	658 + MS threadsafe getc is very slow (multiple layers of function calls before+
a1d88ab023a0 A few reformats; no logic changes. Tim Peters <tim.peters@gmail.com> parents: 15757 diff changeset	659 after each character, to lock+unlock the stream).
a1d88ab023a0 A few reformats; no logic changes. Tim Peters <tim.peters@gmail.com> parents: 15757 diff changeset	660 + The stream-locking functions are MS-internal -- can't access them from user
a1d88ab023a0 A few reformats; no logic changes. Tim Peters <tim.peters@gmail.com> parents: 15757 diff changeset	661 code.
a1d88ab023a0 A few reformats; no logic changes. Tim Peters <tim.peters@gmail.com> parents: 15757 diff changeset	662 + There's nothing Tim could find in the MS C or platform SDK libraries that
a1d88ab023a0 A few reformats; no logic changes. Tim Peters <tim.peters@gmail.com> parents: 15757 diff changeset	663 can worm around this.
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	664 + MS fgets locks/unlocks only once per line; it's the only hook we have.
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	665
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	666 So we use fgets for speed(!), despite that it's painful.
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	667
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	668 MS realloc is also slow.
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	669
15875 195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	670 Reports from other platforms on this method vs getc_unlocked (which MS doesn't
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	671 have):
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	672 Linux a wash
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	673 Solaris a wash
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	674 Tru64 Unix getline_via_fgets significantly faster
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	675
15875 195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	676 CAUTION: The C std isn't clear about this: in those cases where fgets
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	677 writes something into the buffer, can it write into any position beyond the
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	678 required trailing null byte? MSVC 6 fgets does not, and no platform is (yet)
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	679 known on which it does; and it would be a strange way to code fgets. Still,
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	680 getline_via_fgets may not work correctly if it does. The std test
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	681 test_bufio.py should fail if platform fgets() routinely writes beyond the
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	682 trailing null byte. #define DONT_USE_FGETS_IN_GETLINE to disable this code.
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	683 **************************************************************************/
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	684
15875 195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	685 /* Use this routine if told to, or by default on non-get_unlocked()
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	686 * platforms unless told not to. Yikes! Let's spell that out:
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	687 * On a platform with getc_unlocked():
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	688 * By default, use getc_unlocked().
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	689 * If you want to use fgets() instead, #define USE_FGETS_IN_GETLINE.
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	690 * On a platform without getc_unlocked():
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	691 * By default, use fgets().
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	692 * If you don't want to use fgets(), #define DONT_USE_FGETS_IN_GETLINE.
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	693 */
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	694 #if !defined(USE_FGETS_IN_GETLINE) && !defined(HAVE_GETC_UNLOCKED)
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	695 #define USE_FGETS_IN_GETLINE
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	696 #endif
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	697
15875 195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	698 #if defined(DONT_USE_FGETS_IN_GETLINE) && defined(USE_FGETS_IN_GETLINE)
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	699 #undef USE_FGETS_IN_GETLINE
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	700 #endif
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	701
195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	702 #ifdef USE_FGETS_IN_GETLINE
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	703 static PyObject*
15875 195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	704 getline_via_fgets(FILE *fp)
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	705 {
15755 a43a8a1f46ee Fiddled ms_getline_hack after talking w/ Guido: made clearer that the Tim Peters <tim.peters@gmail.com> parents: 15754 diff changeset	706 /* INITBUFSIZE is the maximum line length that lets us get away with the fast
15876 a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	707 * no-realloc, one-fgets()-call path. Boosting it isn't free, because we have
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	708 * to fill this much of the buffer with a known value in order to figure out
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	709 * how much of the buffer fgets() overwrites. So if INITBUFSIZE is larger
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	710 * than "most" lines, we waste time filling unused buffer slots. 100 is
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	711 * surely adequate for most peoples' email archives, chewing over source code,
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	712 * etc -- "regular old text files".
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	713 * MAXBUFSIZE is the maximum line length that lets us get away with the less
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	714 * fast (but still zippy) no-realloc, two-fgets()-call path. See above for
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	715 * cautions about boosting that. 300 was chosen because the worst real-life
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	716 * text-crunching job reported on Python-Dev was a mail-log crawler where over
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	717 * half the lines were 254 chars.
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	718 * INCBUFSIZE is the amount by which we grow the buffer, if MAXBUFSIZE isn't
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	719 * enough. It doesn't much matter what this is set to: we only get here for
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	720 * absurdly long lines anyway.
15755 a43a8a1f46ee Fiddled ms_getline_hack after talking w/ Guido: made clearer that the Tim Peters <tim.peters@gmail.com> parents: 15754 diff changeset	721 */
15876 a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	722 #define INITBUFSIZE 100
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	723 #define MAXBUFSIZE 300
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	724 #define INCBUFSIZE 1000
15876 a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	725 char* p; /* temp */
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	726 char buf[MAXBUFSIZE];
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	727 PyObject* v; /* the string object result */
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	728 char* pvfree; /* address of next free slot */
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	729 char* pvend; /* address one beyond last free slot */
15876 a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	730 size_t nfree; /* # of free buffer slots; pvend-pvfree */
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	731 size_t total_v_size; /* total # of slots in buffer */
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	732
15755 a43a8a1f46ee Fiddled ms_getline_hack after talking w/ Guido: made clearer that the Tim Peters <tim.peters@gmail.com> parents: 15754 diff changeset	733 /* Optimize for normal case: avoid _PyString_Resize if at all
15876 a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	734 * possible via first reading into stack buffer "buf".
15755 a43a8a1f46ee Fiddled ms_getline_hack after talking w/ Guido: made clearer that the Tim Peters <tim.peters@gmail.com> parents: 15754 diff changeset	735 */
15876 a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	736 total_v_size = INITBUFSIZE; /* start small and pray */
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	737 pvfree = buf;
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	738 for (;;) {
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	739 Py_BEGIN_ALLOW_THREADS
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	740 pvend = buf + total_v_size;
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	741 nfree = pvend - pvfree;
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	742 memset(pvfree, '\n', nfree);
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	743 p = fgets(pvfree, nfree, fp);
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	744 Py_END_ALLOW_THREADS
15755 a43a8a1f46ee Fiddled ms_getline_hack after talking w/ Guido: made clearer that the Tim Peters <tim.peters@gmail.com> parents: 15754 diff changeset	745
15876 a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	746 if (p == NULL) {
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	747 clearerr(fp);
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	748 if (PyErr_CheckSignals())
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	749 return NULL;
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	750 v = PyString_FromStringAndSize(buf, pvfree - buf);
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	751 return v;
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	752 }
15876 a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	753 /* fgets read something */
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	754 p = memchr(pvfree, '\n', nfree);
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	755 if (p != NULL) {
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	756 /* Did the \n come from fgets or from us?
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	757 * Since fgets stops at the first \n, and then writes
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	758 * \0, if it's from fgets a \0 must be next. But if
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	759 * that's so, it could not have come from us, since
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	760 * the \n's we filled the buffer with have only more
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	761 * \n's to the right.
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	762 */
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	763 if (p+1 < pvend && *(p+1) == '\0') {
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	764 /* It's from fgets: we win! In particular,
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	765 * we haven't done any mallocs yet, and can
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	766 * build the final result on the first try.
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	767 */
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	768 ++p; /* include \n from fgets */
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	769 }
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	770 else {
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	771 /* Must be from us: fgets didn't fill the
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	772 * buffer and didn't find a newline, so it
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	773 * must be the last and newline-free line of
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	774 * the file.
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	775 */
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	776 assert(p > pvfree && *(p-1) == '\0');
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	777 --p; /* don't include \0 from fgets */
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	778 }
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	779 v = PyString_FromStringAndSize(buf, p - buf);
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	780 return v;
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	781 }
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	782 /* yuck: fgets overwrote all the newlines, i.e. the entire
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	783 * buffer. So this line isn't over yet, or maybe it is but
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	784 * we're exactly at EOF. If we haven't already, try using the
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	785 * rest of the stack buffer.
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	786 */
15876 a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	787 assert(*(pvend-1) == '\0');
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	788 if (pvfree == buf) {
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	789 pvfree = pvend - 1; /* overwrite trailing null */
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	790 total_v_size = MAXBUFSIZE;
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	791 }
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	792 else
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	793 break;
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	794 }
15876 a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	795
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	796 /* The stack buffer isn't big enough; malloc a string object and read
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	797 * into its buffer.
15755 a43a8a1f46ee Fiddled ms_getline_hack after talking w/ Guido: made clearer that the Tim Peters <tim.peters@gmail.com> parents: 15754 diff changeset	798 */
15876 a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	799 total_v_size = MAXBUFSIZE + INCBUFSIZE;
15758 a1d88ab023a0 A few reformats; no logic changes. Tim Peters <tim.peters@gmail.com> parents: 15757 diff changeset	800 v = PyString_FromStringAndSize((char*)NULL, (int)total_v_size);
15755 a43a8a1f46ee Fiddled ms_getline_hack after talking w/ Guido: made clearer that the Tim Peters <tim.peters@gmail.com> parents: 15754 diff changeset	801 if (v == NULL)
a43a8a1f46ee Fiddled ms_getline_hack after talking w/ Guido: made clearer that the Tim Peters <tim.peters@gmail.com> parents: 15754 diff changeset	802 return v;
a43a8a1f46ee Fiddled ms_getline_hack after talking w/ Guido: made clearer that the Tim Peters <tim.peters@gmail.com> parents: 15754 diff changeset	803 /* copy over everything except the last null byte */
15876 a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	804 memcpy(BUF(v), buf, MAXBUFSIZE-1);
a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	805 pvfree = BUF(v) + MAXBUFSIZE - 1;
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	806
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	807 /* Keep reading stuff into v; if it ever ends successfully, break
15755 a43a8a1f46ee Fiddled ms_getline_hack after talking w/ Guido: made clearer that the Tim Peters <tim.peters@gmail.com> parents: 15754 diff changeset	808 * after setting p one beyond the end of the line. The code here is
a43a8a1f46ee Fiddled ms_getline_hack after talking w/ Guido: made clearer that the Tim Peters <tim.peters@gmail.com> parents: 15754 diff changeset	809 * very much like the code above, except reads into v's buffer; see
a43a8a1f46ee Fiddled ms_getline_hack after talking w/ Guido: made clearer that the Tim Peters <tim.peters@gmail.com> parents: 15754 diff changeset	810 * the code above for detailed comments about the logic.
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	811 */
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	812 for (;;) {
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	813 Py_BEGIN_ALLOW_THREADS
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	814 pvend = BUF(v) + total_v_size;
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	815 nfree = pvend - pvfree;
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	816 memset(pvfree, '\n', nfree);
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	817 p = fgets(pvfree, nfree, fp);
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	818 Py_END_ALLOW_THREADS
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	819
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	820 if (p == NULL) {
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	821 clearerr(fp);
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	822 if (PyErr_CheckSignals()) {
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	823 Py_DECREF(v);
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	824 return NULL;
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	825 }
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	826 p = pvfree;
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	827 break;
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	828 }
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	829 p = memchr(pvfree, '\n', nfree);
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	830 if (p != NULL) {
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	831 if (p+1 < pvend && *(p+1) == '\0') {
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	832 /* \n came from fgets */
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	833 ++p;
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	834 break;
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	835 }
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	836 /* \n came from us; last line of file, no newline */
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	837 assert(p > pvfree && *(p-1) == '\0');
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	838 --p;
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	839 break;
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	840 }
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	841 /* expand buffer and try again */
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	842 assert(*(pvend-1) == '\0');
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	843 total_v_size += INCBUFSIZE;
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	844 if (total_v_size > INT_MAX) {
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	845 PyErr_SetString(PyExc_OverflowError,
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	846 "line is longer than a Python string can hold");
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	847 Py_DECREF(v);
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	848 return NULL;
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	849 }
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	850 if (_PyString_Resize(&v, (int)total_v_size) < 0)
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	851 return NULL;
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	852 /* overwrite the trailing null byte */
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	853 pvfree = BUF(v) + (total_v_size - INCBUFSIZE - 1);
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	854 }
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	855 if (BUF(v) + total_v_size != p)
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	856 _PyString_Resize(&v, p - BUF(v));
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	857 return v;
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	858 #undef INITBUFSIZE
15876 a33de23b3066 Speed getline_via_fgets(), by supplying two "fast paths", although one is Tim Peters <tim.peters@gmail.com> parents: 15875 diff changeset	859 #undef MAXBUFSIZE
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	860 #undef INCBUFSIZE
7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	861 }
15875 195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	862 #endif /* ifdef USE_FGETS_IN_GETLINE */
5410 3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	863
183 c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	864 /* Internal routine to get a line.
c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	865 Size argument interpretation:
c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	866 > 0: max length;
15757 a9e15bcab32c Let's hope that three time's a charm... Guido van Rossum <guido@python.org> parents: 15755 diff changeset	867 <= 0: read arbitrary line
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	868 */
f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	869
15745 f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	870 #ifdef HAVE_GETC_UNLOCKED
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	871 #define GETC(f) getc_unlocked(f)
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	872 #define FLOCKFILE(f) flockfile(f)
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	873 #define FUNLOCKFILE(f) funlockfile(f)
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	874 #else
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	875 #define GETC(f) getc(f)
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	876 #define FLOCKFILE(f)
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	877 #define FUNLOCKFILE(f)
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	878 #endif
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	879
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	880 static PyObject *
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	881 get_line(PyFileObject *f, int n)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	882 {
15745 f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	883 FILE *fp = f->f_fp;
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	884 int c;
15446 f813ede134bf Patch #102469: Use glibc's getline() extension when reading unbounded lines Andrew M. Kuchling <amk@amk.ca> parents: 15404 diff changeset	885 char buf, end;
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	886 size_t n1, n2;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	887 PyObject *v;
183 c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	888
15875 195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	889 #ifdef USE_FGETS_IN_GETLINE
15757 a9e15bcab32c Let's hope that three time's a charm... Guido van Rossum <guido@python.org> parents: 15755 diff changeset	890 if (n <= 0)
15875 195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	891 return getline_via_fgets(fp);
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	892 #endif
183 c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	893 n2 = n > 0 ? n : 100;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	894 v = PyString_FromStringAndSize((char *)NULL, n2);
86 a6934380c6e7 "Compiling" version Guido van Rossum <guido@python.org> parents: 38 diff changeset	895 if (v == NULL)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	896 return NULL;
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	897 buf = BUF(v);
f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	898 end = buf + n2;
923 72aceed365d4 * Makefile adapted to changes below. Guido van Rossum <guido@python.org> parents: 916 diff changeset	899
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	900 for (;;) {
15745 f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	901 Py_BEGIN_ALLOW_THREADS
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	902 FLOCKFILE(fp);
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	903 while ((c = GETC(fp)) != EOF &&
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	904 (*buf++ = c) != '\n' &&
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	905 buf != end)
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	906 ;
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	907 FUNLOCKFILE(fp);
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	908 Py_END_ALLOW_THREADS
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	909 if (c == '\n')
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	910 break;
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	911 if (c == EOF) {
19105 eea8dfbbee86 Apply anonymous SF patch #441229. Guido van Rossum <guido@python.org> parents: 19015 diff changeset	912 if (ferror(fp)) {
eea8dfbbee86 Apply anonymous SF patch #441229. Guido van Rossum <guido@python.org> parents: 19015 diff changeset	913 PyErr_SetFromErrno(PyExc_IOError);
eea8dfbbee86 Apply anonymous SF patch #441229. Guido van Rossum <guido@python.org> parents: 19015 diff changeset	914 clearerr(fp);
eea8dfbbee86 Apply anonymous SF patch #441229. Guido van Rossum <guido@python.org> parents: 19015 diff changeset	915 Py_DECREF(v);
eea8dfbbee86 Apply anonymous SF patch #441229. Guido van Rossum <guido@python.org> parents: 19015 diff changeset	916 return NULL;
eea8dfbbee86 Apply anonymous SF patch #441229. Guido van Rossum <guido@python.org> parents: 19015 diff changeset	917 }
251 48d58b74a3a4 Call clearerr() after EOF seen. Guido van Rossum <guido@python.org> parents: 183 diff changeset	918 clearerr(fp);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	919 if (PyErr_CheckSignals()) {
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	920 Py_DECREF(v);
183 c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	921 return NULL;
c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	922 }
c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	923 break;
c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	924 }
15745 f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	925 /* Must be because buf == end */
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	926 if (n > 0)
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	927 break;
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	928 n1 = n2;
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	929 n2 += 1000;
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	930 if (n2 > INT_MAX) {
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	931 PyErr_SetString(PyExc_OverflowError,
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	932 "line is longer than a Python string can hold");
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	933 Py_DECREF(v);
15745 f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	934 return NULL;
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	935 }
15745 f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	936 if (_PyString_Resize(&v, n2) < 0)
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	937 return NULL;
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	938 buf = BUF(v) + n1;
f5c04134f4e2 Restructured get_line() for clarity and speed. Guido van Rossum <guido@python.org> parents: 15633 diff changeset	939 end = BUF(v) + n2;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	940 }
923 72aceed365d4 * Makefile adapted to changes below. Guido van Rossum <guido@python.org> parents: 916 diff changeset	941
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	942 n1 = buf - BUF(v);
f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	943 if (n1 != n2)
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	944 _PyString_Resize(&v, n1);
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	945 return v;
f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	946 }
f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	947
183 c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	948 /* External C interface */
c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	949
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	950 PyObject *
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	951 PyFile_GetLine(PyObject *f, int n)
183 c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	952 {
15753 8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	953 PyObject *result;
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	954
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	955 if (f == NULL) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	956 PyErr_BadInternalCall();
183 c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	957 return NULL;
c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	958 }
15753 8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	959
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	960 if (PyFile_Check(f)) {
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	961 if (((PyFileObject*)f)->f_fp == NULL)
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	962 return err_closed();
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	963 result = get_line((PyFileObject *)f, n);
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	964 }
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	965 else {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	966 PyObject *reader;
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	967 PyObject *args;
15753 8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	968
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	969 reader = PyObject_GetAttrString(f, "readline");
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	970 if (reader == NULL)
2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	971 return NULL;
2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	972 if (n <= 0)
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	973 args = Py_BuildValue("()");
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	974 else
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	975 args = Py_BuildValue("(i)", n);
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	976 if (args == NULL) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	977 Py_DECREF(reader);
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	978 return NULL;
2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	979 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	980 result = PyEval_CallObject(reader, args);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	981 Py_DECREF(reader);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	982 Py_DECREF(args);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	983 if (result != NULL && !PyString_Check(result)) {
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	984 Py_DECREF(result);
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	985 result = NULL;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	986 PyErr_SetString(PyExc_TypeError,
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	987 "object.readline() returned non-string");
2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	988 }
15753 8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	989 }
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	990
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	991 if (n < 0 && result != NULL && PyString_Check(result)) {
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	992 char *s = PyString_AS_STRING(result);
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	993 int len = PyString_GET_SIZE(result);
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	994 if (len == 0) {
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	995 Py_DECREF(result);
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	996 result = NULL;
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	997 PyErr_SetString(PyExc_EOFError,
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	998 "EOF when reading a line");
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	999 }
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	1000 else if (s[len-1] == '\n') {
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	1001 if (result->ob_refcnt == 1)
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	1002 _PyString_Resize(&result, len-1);
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	1003 else {
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	1004 PyObject *v;
8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	1005 v = PyString_FromStringAndSize(s, len-1);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1006 Py_DECREF(result);
15753 8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	1007 result = v;
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1008 }
2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1009 }
2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1010 }
15753 8d00f7555eec Tim noticed that I had botched get_line_raw(). Looking again, I Guido van Rossum <guido@python.org> parents: 15745 diff changeset	1011 return result;
183 c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	1012 }
c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	1013
c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	1014 /* Python method */
c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	1015
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1016 static PyObject *
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	1017 file_readline(PyFileObject f, PyObject args)
183 c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	1018 {
5479 6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1019 int n = -1;
183 c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	1020
908 424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	1021 if (f->f_fp == NULL)
424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	1022 return err_closed();
11882 dc65c5f6ad7c Massive patch by Skip Montanaro to add ":name" to as many Guido van Rossum <guido@python.org> parents: 11243 diff changeset	1023 if (!PyArg_ParseTuple(args, "\|i:readline", &n))
5479 6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1024 return NULL;
6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1025 if (n == 0)
6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1026 return PyString_FromString("");
6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1027 if (n < 0)
6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1028 n = 0;
13360 484bfde70dcc Fix to bug #389: Marc-André Lemburg <mal@egenix.com> parents: 13256 diff changeset	1029 return get_line(f, n);
183 c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	1030 }
c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	1031
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1032 static PyObject *
19301 b9701538f827 Patch #427190: Implement and use METH_NOARGS and METH_O. Martin v. Löwis <martin@v.loewis.de> parents: 19105 diff changeset	1033 file_xreadlines(PyFileObject *f)
15780 d646d6068924 Jeff Epler's patch adding an xreadlines() method. (It just imports Guido van Rossum <guido@python.org> parents: 15767 diff changeset	1034 {
d646d6068924 Jeff Epler's patch adding an xreadlines() method. (It just imports Guido van Rossum <guido@python.org> parents: 15767 diff changeset	1035 static PyObject* xreadlines_function = NULL;
15875 195557a0f050 Use the "MS" getline hack (fgets()) by default on non-get_unlocked Tim Peters <tim.peters@gmail.com> parents: 15780 diff changeset	1036
15780 d646d6068924 Jeff Epler's patch adding an xreadlines() method. (It just imports Guido van Rossum <guido@python.org> parents: 15767 diff changeset	1037 if (!xreadlines_function) {
d646d6068924 Jeff Epler's patch adding an xreadlines() method. (It just imports Guido van Rossum <guido@python.org> parents: 15767 diff changeset	1038 PyObject *xreadlines_module =
d646d6068924 Jeff Epler's patch adding an xreadlines() method. (It just imports Guido van Rossum <guido@python.org> parents: 15767 diff changeset	1039 PyImport_ImportModule("xreadlines");
d646d6068924 Jeff Epler's patch adding an xreadlines() method. (It just imports Guido van Rossum <guido@python.org> parents: 15767 diff changeset	1040 if(!xreadlines_module)
d646d6068924 Jeff Epler's patch adding an xreadlines() method. (It just imports Guido van Rossum <guido@python.org> parents: 15767 diff changeset	1041 return NULL;
d646d6068924 Jeff Epler's patch adding an xreadlines() method. (It just imports Guido van Rossum <guido@python.org> parents: 15767 diff changeset	1042
d646d6068924 Jeff Epler's patch adding an xreadlines() method. (It just imports Guido van Rossum <guido@python.org> parents: 15767 diff changeset	1043 xreadlines_function = PyObject_GetAttrString(xreadlines_module,
d646d6068924 Jeff Epler's patch adding an xreadlines() method. (It just imports Guido van Rossum <guido@python.org> parents: 15767 diff changeset	1044 "xreadlines");
d646d6068924 Jeff Epler's patch adding an xreadlines() method. (It just imports Guido van Rossum <guido@python.org> parents: 15767 diff changeset	1045 Py_DECREF(xreadlines_module);
d646d6068924 Jeff Epler's patch adding an xreadlines() method. (It just imports Guido van Rossum <guido@python.org> parents: 15767 diff changeset	1046 if(!xreadlines_function)
d646d6068924 Jeff Epler's patch adding an xreadlines() method. (It just imports Guido van Rossum <guido@python.org> parents: 15767 diff changeset	1047 return NULL;
d646d6068924 Jeff Epler's patch adding an xreadlines() method. (It just imports Guido van Rossum <guido@python.org> parents: 15767 diff changeset	1048 }
d646d6068924 Jeff Epler's patch adding an xreadlines() method. (It just imports Guido van Rossum <guido@python.org> parents: 15767 diff changeset	1049 return PyObject_CallFunction(xreadlines_function, "(O)", f);
d646d6068924 Jeff Epler's patch adding an xreadlines() method. (It just imports Guido van Rossum <guido@python.org> parents: 15767 diff changeset	1050 }
d646d6068924 Jeff Epler's patch adding an xreadlines() method. (It just imports Guido van Rossum <guido@python.org> parents: 15767 diff changeset	1051
d646d6068924 Jeff Epler's patch adding an xreadlines() method. (It just imports Guido van Rossum <guido@python.org> parents: 15767 diff changeset	1052 static PyObject *
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	1053 file_readlines(PyFileObject f, PyObject args)
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	1054 {
5479 6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1055 long sizehint = 0;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1056 PyObject *list;
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1057 PyObject *line;
5478 266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1058 char small_buffer[SMALLCHUNK];
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1059 char *buffer = small_buffer;
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1060 size_t buffersize = SMALLCHUNK;
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1061 PyObject *big_buffer = NULL;
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1062 size_t nfilled = 0;
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1063 size_t nread;
5479 6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1064 size_t totalread = 0;
5478 266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1065 char p, q, *end;
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1066 int err;
20392 853c268bf247 Band-aid solution to SF bug #470634: readlines() on linux requires 2 ^D's. Guido van Rossum <guido@python.org> parents: 20365 diff changeset	1067 int shortread = 0;
183 c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	1068
908 424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	1069 if (f->f_fp == NULL)
424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	1070 return err_closed();
11882 dc65c5f6ad7c Massive patch by Skip Montanaro to add ":name" to as many Guido van Rossum <guido@python.org> parents: 11243 diff changeset	1071 if (!PyArg_ParseTuple(args, "\|l:readlines", &sizehint))
183 c9168afe23dd Added external interface to readline, for raw_input(). Guido van Rossum <guido@python.org> parents: 177 diff changeset	1072 return NULL;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1073 if ((list = PyList_New(0)) == NULL)
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	1074 return NULL;
f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	1075 for (;;) {
20392 853c268bf247 Band-aid solution to SF bug #470634: readlines() on linux requires 2 ^D's. Guido van Rossum <guido@python.org> parents: 20365 diff changeset	1076 if (shortread)
853c268bf247 Band-aid solution to SF bug #470634: readlines() on linux requires 2 ^D's. Guido van Rossum <guido@python.org> parents: 20365 diff changeset	1077 nread = 0;
853c268bf247 Band-aid solution to SF bug #470634: readlines() on linux requires 2 ^D's. Guido van Rossum <guido@python.org> parents: 20365 diff changeset	1078 else {
853c268bf247 Band-aid solution to SF bug #470634: readlines() on linux requires 2 ^D's. Guido van Rossum <guido@python.org> parents: 20365 diff changeset	1079 Py_BEGIN_ALLOW_THREADS
853c268bf247 Band-aid solution to SF bug #470634: readlines() on linux requires 2 ^D's. Guido van Rossum <guido@python.org> parents: 20365 diff changeset	1080 errno = 0;
853c268bf247 Band-aid solution to SF bug #470634: readlines() on linux requires 2 ^D's. Guido van Rossum <guido@python.org> parents: 20365 diff changeset	1081 nread = fread(buffer+nfilled, 1,
853c268bf247 Band-aid solution to SF bug #470634: readlines() on linux requires 2 ^D's. Guido van Rossum <guido@python.org> parents: 20365 diff changeset	1082 buffersize-nfilled, f->f_fp);
853c268bf247 Band-aid solution to SF bug #470634: readlines() on linux requires 2 ^D's. Guido van Rossum <guido@python.org> parents: 20365 diff changeset	1083 Py_END_ALLOW_THREADS
853c268bf247 Band-aid solution to SF bug #470634: readlines() on linux requires 2 ^D's. Guido van Rossum <guido@python.org> parents: 20365 diff changeset	1084 shortread = (nread < buffersize-nfilled);
853c268bf247 Band-aid solution to SF bug #470634: readlines() on linux requires 2 ^D's. Guido van Rossum <guido@python.org> parents: 20365 diff changeset	1085 }
5478 266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1086 if (nread == 0) {
5479 6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1087 sizehint = 0;
7398 7afc15f08d82 Check ferror(), not errno, for fread() error. Guido van Rossum <guido@python.org> parents: 6568 diff changeset	1088 if (!ferror(f->f_fp))
5478 266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1089 break;
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1090 PyErr_SetFromErrno(PyExc_IOError);
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1091 clearerr(f->f_fp);
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1092 error:
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1093 Py_DECREF(list);
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1094 list = NULL;
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1095 goto cleanup;
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	1096 }
5479 6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1097 totalread += nread;
5478 266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1098 p = memchr(buffer+nfilled, '\n', nread);
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1099 if (p == NULL) {
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1100 /* Need a larger buffer to fit this line */
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1101 nfilled += nread;
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1102 buffersize *= 2;
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	1103 if (buffersize > INT_MAX) {
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	1104 PyErr_SetString(PyExc_OverflowError,
15780 d646d6068924 Jeff Epler's patch adding an xreadlines() method. (It just imports Guido van Rossum <guido@python.org> parents: 15767 diff changeset	1105 "line is longer than a Python string can hold");
13924 ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	1106 goto error;
ddf302d69211 Add largefile support for Linux64 and WIn64. Add test_largefile and some minor Trent Mick <trentm@activestate.com> parents: 13591 diff changeset	1107 }
5478 266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1108 if (big_buffer == NULL) {
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1109 /* Create the big buffer */
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1110 big_buffer = PyString_FromStringAndSize(
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1111 NULL, buffersize);
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1112 if (big_buffer == NULL)
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1113 goto error;
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1114 buffer = PyString_AS_STRING(big_buffer);
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1115 memcpy(buffer, small_buffer, nfilled);
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1116 }
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1117 else {
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1118 /* Grow the big buffer */
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1119 _PyString_Resize(&big_buffer, buffersize);
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1120 buffer = PyString_AS_STRING(big_buffer);
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1121 }
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1122 continue;
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	1123 }
5478 266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1124 end = buffer+nfilled+nread;
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1125 q = buffer;
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1126 do {
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1127 /* Process complete lines */
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1128 p++;
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1129 line = PyString_FromStringAndSize(q, p-q);
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1130 if (line == NULL)
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1131 goto error;
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1132 err = PyList_Append(list, line);
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1133 Py_DECREF(line);
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1134 if (err != 0)
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1135 goto error;
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1136 q = p;
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1137 p = memchr(q, '\n', end-q);
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1138 } while (p != NULL);
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1139 /* Move the remaining incomplete line to the start */
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1140 nfilled = end-q;
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1141 memmove(buffer, q, nfilled);
5479 6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1142 if (sizehint > 0)
6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1143 if (totalread >= (size_t)sizehint)
6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1144 break;
5478 266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1145 }
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1146 if (nfilled != 0) {
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1147 /* Partial last line */
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1148 line = PyString_FromStringAndSize(buffer, nfilled);
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1149 if (line == NULL)
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1150 goto error;
5479 6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1151 if (sizehint > 0) {
6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1152 /* Need to complete the last line */
13360 484bfde70dcc Fix to bug #389: Marc-André Lemburg <mal@egenix.com> parents: 13256 diff changeset	1153 PyObject *rest = get_line(f, 0);
5479 6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1154 if (rest == NULL) {
6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1155 Py_DECREF(line);
6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1156 goto error;
6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1157 }
6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1158 PyString_Concat(&line, rest);
6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1159 Py_DECREF(rest);
6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1160 if (line == NULL)
6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1161 goto error;
6d53ebaec021 Add optional 'sizehint' argument to readlines(). After approximately Guido van Rossum <guido@python.org> parents: 5478 diff changeset	1162 }
5478 266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1163 err = PyList_Append(list, line);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1164 Py_DECREF(line);
5478 266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1165 if (err != 0)
266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1166 goto error;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1167 }
5478 266c9aa8c127 Rewrite readlines() to speed it up -- about a factor of 2 on my Guido van Rossum <guido@python.org> parents: 5477 diff changeset	1168 cleanup:
23310 01765d30532e backport tim_one's patch: Anthony Baxter <anthonybaxter@gmail.com> parents: 22874 diff changeset	1169 Py_XDECREF(big_buffer);
154 f2efceaf73cc Fixed read() and readline() to do arbitrarily long reads. Guido van Rossum <guido@python.org> parents: 145 diff changeset	1170 return list;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1171 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1172
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1173 static PyObject *
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	1174 file_write(PyFileObject f, PyObject args)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1175 {
908 424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	1176 char *s;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1177 int n, n2;
908 424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	1178 if (f->f_fp == NULL)
424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	1179 return err_closed();
20793 79fcbc31a03e fix for Michael W. Hudson <mwh@python.net> parents: 20635 diff changeset	1180 if (!PyArg_ParseTuple(args, f->f_binary ? "s#" : "t#", &s, &n))
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1181 return NULL;
177 bd49ca6c4add Added 'softspace' interface to replace 'needspace' printing hack. Guido van Rossum <guido@python.org> parents: 154 diff changeset	1182 f->f_softspace = 0;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1183 Py_BEGIN_ALLOW_THREADS
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1184 errno = 0;
908 424f55e67d5d Makefile: added instann rules and $(DEST) defines. Guido van Rossum <guido@python.org> parents: 902 diff changeset	1185 n2 = fwrite(s, 1, n, f->f_fp);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1186 Py_END_ALLOW_THREADS
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1187 if (n2 != n) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1188 PyErr_SetFromErrno(PyExc_IOError);
689 90ea50786095 Change error handling. Call clearerr() more often. Guido van Rossum <guido@python.org> parents: 645 diff changeset	1189 clearerr(f->f_fp);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1190 return NULL;
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1191 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1192 Py_INCREF(Py_None);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1193 return Py_None;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1194 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1195
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1196 static PyObject *
20045 7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1197 file_writelines(PyFileObject f, PyObject seq)
1362 560407ec632b * filemodule.c: added writelines() -- analogous to readlines() Guido van Rossum <guido@python.org> parents: 1354 diff changeset	1198 {
12000 8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1199 #define CHUNKSIZE 1000
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1200 PyObject list, line;
20045 7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1201 PyObject it; / iter(seq) */
12000 8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1202 PyObject *result;
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1203 int i, j, index, len, nwritten, islist;
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1204
20045 7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1205 assert(seq != NULL);
1362 560407ec632b * filemodule.c: added writelines() -- analogous to readlines() Guido van Rossum <guido@python.org> parents: 1354 diff changeset	1206 if (f->f_fp == NULL)
560407ec632b * filemodule.c: added writelines() -- analogous to readlines() Guido van Rossum <guido@python.org> parents: 1354 diff changeset	1207 return err_closed();
20045 7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1208
7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1209 result = NULL;
7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1210 list = NULL;
7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1211 islist = PyList_Check(seq);
7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1212 if (islist)
7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1213 it = NULL;
7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1214 else {
7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1215 it = PyObject_GetIter(seq);
7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1216 if (it == NULL) {
7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1217 PyErr_SetString(PyExc_TypeError,
7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1218 "writelines() requires an iterable argument");
7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1219 return NULL;
7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1220 }
7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1221 /* From here on, fail by going to error, to reclaim "it". */
7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1222 list = PyList_New(CHUNKSIZE);
7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1223 if (list == NULL)
7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1224 goto error;
1362 560407ec632b * filemodule.c: added writelines() -- analogous to readlines() Guido van Rossum <guido@python.org> parents: 1354 diff changeset	1225 }
12000 8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1226
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1227 /* Strategy: slurp CHUNKSIZE lines into a private list,
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1228 checking that they are all strings, then write that list
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1229 without holding the interpreter lock, then come back for more. */
20045 7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1230 for (index = 0; ; index += CHUNKSIZE) {
12000 8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1231 if (islist) {
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1232 Py_XDECREF(list);
20045 7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1233 list = PyList_GetSlice(seq, index, index+CHUNKSIZE);
12000 8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1234 if (list == NULL)
20045 7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1235 goto error;
12000 8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1236 j = PyList_GET_SIZE(list);
1362 560407ec632b * filemodule.c: added writelines() -- analogous to readlines() Guido van Rossum <guido@python.org> parents: 1354 diff changeset	1237 }
12000 8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1238 else {
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1239 for (j = 0; j < CHUNKSIZE; j++) {
20045 7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1240 line = PyIter_Next(it);
12000 8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1241 if (line == NULL) {
20045 7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1242 if (PyErr_Occurred())
7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1243 goto error;
7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1244 break;
12000 8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1245 }
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1246 PyList_SetItem(list, j, line);
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1247 }
1362 560407ec632b * filemodule.c: added writelines() -- analogous to readlines() Guido van Rossum <guido@python.org> parents: 1354 diff changeset	1248 }
12000 8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1249 if (j == 0)
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1250 break;
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1251
14213 63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1252 /* Check that all entries are indeed strings. If not,
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1253 apply the same rules as for file.write() and
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1254 convert the results to strings. This is slow, but
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1255 seems to be the only way since all conversion APIs
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1256 could potentially execute Python code. */
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1257 for (i = 0; i < j; i++) {
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1258 PyObject *v = PyList_GET_ITEM(list, i);
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1259 if (!PyString_Check(v)) {
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1260 const char *buffer;
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1261 int len;
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	1262 if (((f->f_binary &&
14213 63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1263 PyObject_AsReadBuffer(v,
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1264 (const void**)&buffer,
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1265 &len)) \|\|
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1266 PyObject_AsCharBuffer(v,
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1267 &buffer,
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1268 &len))) {
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1269 PyErr_SetString(PyExc_TypeError,
15318 8aa947e1eee8 Ka-Ping Yee <ping@lfw.org>: Fred Drake <fdrake@acm.org> parents: 15068 diff changeset	1270 "writelines() argument must be a sequence of strings");
14213 63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1271 goto error;
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1272 }
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1273 line = PyString_FromStringAndSize(buffer,
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1274 len);
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1275 if (line == NULL)
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1276 goto error;
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1277 Py_DECREF(v);
14215 0797fdb25a77 Fixed a serious typo. Marc-André Lemburg <mal@egenix.com> parents: 14213 diff changeset	1278 PyList_SET_ITEM(list, i, line);
14213 63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1279 }
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1280 }
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1281
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1282 /* Since we are releasing the global lock, the
63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1283 following code may not execute Python code. */
12000 8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1284 Py_BEGIN_ALLOW_THREADS
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1285 f->f_softspace = 0;
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1286 errno = 0;
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1287 for (i = 0; i < j; i++) {
14213 63ea2a2df06f Fix to bug [ Bug #111860 ] file.writelines() crashes. Marc-André Lemburg <mal@egenix.com> parents: 14125 diff changeset	1288 line = PyList_GET_ITEM(list, i);
12000 8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1289 len = PyString_GET_SIZE(line);
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1290 nwritten = fwrite(PyString_AS_STRING(line),
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1291 1, len, f->f_fp);
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1292 if (nwritten != len) {
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1293 Py_BLOCK_THREADS
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1294 PyErr_SetFromErrno(PyExc_IOError);
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1295 clearerr(f->f_fp);
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1296 goto error;
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1297 }
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1298 }
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1299 Py_END_ALLOW_THREADS
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1300
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1301 if (j < CHUNKSIZE)
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1302 break;
1362 560407ec632b * filemodule.c: added writelines() -- analogous to readlines() Guido van Rossum <guido@python.org> parents: 1354 diff changeset	1303 }
12000 8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1304
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1305 Py_INCREF(Py_None);
12000 8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1306 result = Py_None;
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1307 error:
8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1308 Py_XDECREF(list);
20045 7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1309 Py_XDECREF(it);
12000 8651f2da7c4c Checking in the new, improve file.writelines() code. Guido van Rossum <guido@python.org> parents: 11969 diff changeset	1310 return result;
20045 7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1311 #undef CHUNKSIZE
1362 560407ec632b * filemodule.c: added writelines() -- analogous to readlines() Guido van Rossum <guido@python.org> parents: 1354 diff changeset	1312 }
560407ec632b * filemodule.c: added writelines() -- analogous to readlines() Guido van Rossum <guido@python.org> parents: 1354 diff changeset	1313
19996 646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1314 static char readline_doc[] =
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1315 "readline([size]) -> next line from the file, as a string.\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1316 "\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1317 "Retain newline. A non-negative size argument limits the maximum\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1318 "number of bytes to return (an incomplete line may be returned then).\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1319 "Return an empty string at EOF.";
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1320
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1321 static char read_doc[] =
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1322 "read([size]) -> read at most size bytes, returned as a string.\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1323 "\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1324 "If the size argument is negative or omitted, read until EOF is reached.";
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1325
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1326 static char write_doc[] =
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1327 "write(str) -> None. Write string str to file.\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1328 "\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1329 "Note that due to buffering, flush() or close() may be needed before\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1330 "the file on disk reflects the data written.";
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1331
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1332 static char fileno_doc[] =
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1333 "fileno() -> integer \"file descriptor\".\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1334 "\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1335 "This is needed for lower-level file interfaces, such os.read().";
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1336
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1337 static char seek_doc[] =
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1338 "seek(offset[, whence]) -> None. Move to new file position.\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1339 "\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1340 "Argument offset is a byte count. Optional argument whence defaults to\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1341 "0 (offset from start of file, offset should be >= 0); other values are 1\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1342 "(move relative to current position, positive or negative), and 2 (move\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1343 "relative to end of file, usually negative, although many platforms allow\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1344 "seeking beyond the end of a file).\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1345 "\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1346 "Note that not all file objects are seekable.";
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1347
2053 de49d49044d7 Lots of minor changes. Note for mappingobject.c: the hash table pointer Guido van Rossum <guido@python.org> parents: 1746 diff changeset	1348 #ifdef HAVE_FTRUNCATE
19996 646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1349 static char truncate_doc[] =
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1350 "truncate([size]) -> None. Truncate the file to at most size bytes.\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1351 "\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1352 "Size defaults to the current file position, as returned by tell().";
2053 de49d49044d7 Lots of minor changes. Note for mappingobject.c: the hash table pointer Guido van Rossum <guido@python.org> parents: 1746 diff changeset	1353 #endif
19996 646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1354
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1355 static char tell_doc[] =
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1356 "tell() -> current file position, an integer (may be a long integer).";
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1357
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1358 static char readinto_doc[] =
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1359 "readinto() -> Undocumented. Don't use this; it may go away.";
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1360
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1361 static char readlines_doc[] =
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1362 "readlines([size]) -> list of strings, each a line from the file.\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1363 "\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1364 "Call readline() repeatedly and return a list of the lines so read.\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1365 "The optional size argument, if given, is an approximate bound on the\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1366 "total number of bytes in the lines returned.";
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1367
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1368 static char xreadlines_doc[] =
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1369 "xreadlines() -> next line from the file, as a string.\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1370 "\n"
25423 91b4f7abeba8 Fix typo in xreadlines() docstring. This does not apply to the trunk. Fred Drake <fdrake@acm.org> parents: 23310 diff changeset	1371 "Equivalent to xreadlines.xreadlines(file). This is like readlines(), but\n"
19996 646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1372 "often quicker, due to reading ahead internally.";
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1373
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1374 static char writelines_doc[] =
20045 7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1375 "writelines(sequence_of_strings) -> None. Write the strings to the file.\n"
19996 646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1376 "\n"
20045 7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1377 "Note that newlines are not added. The sequence can be any iterable object\n"
7b8c11739714 Generalize file.writelines() to allow iterable objects. Tim Peters <tim.peters@gmail.com> parents: 20015 diff changeset	1378 "producing strings. This is equivalent to calling write() for each string.";
19996 646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1379
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1380 static char flush_doc[] =
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1381 "flush() -> None. Flush the internal I/O buffer.";
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1382
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1383 static char close_doc[] =
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1384 "close() -> None or (perhaps) an integer. Close the file.\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1385 "\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1386 "Sets data attribute .closed to true. A closed file cannot be used for\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1387 "further I/O operations. close() may be called more than once without\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1388 "error. Some kinds of file objects (for example, opened by popen())\n"
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1389 "may return an exit status upon closing.";
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1390
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1391 static char isatty_doc[] =
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1392 "isatty() -> true or false. True if the file is connected to a tty device.";
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1393
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1394 static PyMethodDef file_methods[] = {
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1395 {"readline", (PyCFunction)file_readline, METH_VARARGS, readline_doc},
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1396 {"read", (PyCFunction)file_read, METH_VARARGS, read_doc},
20793 79fcbc31a03e fix for Michael W. Hudson <mwh@python.net> parents: 20635 diff changeset	1397 {"write", (PyCFunction)file_write, METH_VARARGS, write_doc},
19996 646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1398 {"fileno", (PyCFunction)file_fileno, METH_NOARGS, fileno_doc},
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1399 {"seek", (PyCFunction)file_seek, METH_VARARGS, seek_doc},
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1400 #ifdef HAVE_FTRUNCATE
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1401 {"truncate", (PyCFunction)file_truncate, METH_VARARGS, truncate_doc},
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1402 #endif
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1403 {"tell", (PyCFunction)file_tell, METH_NOARGS, tell_doc},
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1404 {"readinto", (PyCFunction)file_readinto, METH_OLDARGS, readinto_doc},
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1405 {"readlines", (PyCFunction)file_readlines, METH_VARARGS, readlines_doc},
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1406 {"xreadlines", (PyCFunction)file_xreadlines, METH_NOARGS, xreadlines_doc},
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1407 {"writelines", (PyCFunction)file_writelines, METH_O, writelines_doc},
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1408 {"flush", (PyCFunction)file_flush, METH_NOARGS, flush_doc},
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1409 {"close", (PyCFunction)file_close, METH_NOARGS, close_doc},
646e24728852 SF bug [#463093] File methods need doc strings. Tim Peters <tim.peters@gmail.com> parents: 19985 diff changeset	1410 {"isatty", (PyCFunction)file_isatty, METH_NOARGS, isatty_doc},
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1411 {NULL, NULL} /* sentinel */
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1412 };
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1413
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1414 #define OFF(x) offsetof(PyFileObject, x)
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	1415
20012 3faabf54b8b8 Add optional docstrings to member descriptors. For backwards Guido van Rossum <guido@python.org> parents: 19996 diff changeset	1416 static PyMemberDef file_memberlist[] = {
3faabf54b8b8 Add optional docstrings to member descriptors. For backwards Guido van Rossum <guido@python.org> parents: 19996 diff changeset	1417 {"softspace", T_INT, OFF(f_softspace), 0,
3faabf54b8b8 Add optional docstrings to member descriptors. For backwards Guido van Rossum <guido@python.org> parents: 19996 diff changeset	1418 "flag indicating that a space needs to be printed; used by print"},
3faabf54b8b8 Add optional docstrings to member descriptors. For backwards Guido van Rossum <guido@python.org> parents: 19996 diff changeset	1419 {"mode", T_OBJECT, OFF(f_mode), RO,
3faabf54b8b8 Add optional docstrings to member descriptors. For backwards Guido van Rossum <guido@python.org> parents: 19996 diff changeset	1420 "file mode ('r', 'w', 'a', possibly with 'b' or '+' added)"},
3faabf54b8b8 Add optional docstrings to member descriptors. For backwards Guido van Rossum <guido@python.org> parents: 19996 diff changeset	1421 {"name", T_OBJECT, OFF(f_name), RO,
3faabf54b8b8 Add optional docstrings to member descriptors. For backwards Guido van Rossum <guido@python.org> parents: 19996 diff changeset	1422 "file name"},
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	1423 /* getattr(f, "closed") is implemented without this table */
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	1424 {NULL} /* Sentinel */
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	1425 };
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	1426
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1427 static PyObject *
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18755 diff changeset	1428 get_closed(PyFileObject f, void closure)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1429 {
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18755 diff changeset	1430 return PyInt_FromLong((long)(f->f_fp == 0));
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	1431 }
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1400 diff changeset	1432
20015 ca7af2a5d915 Add optional docstrings to getset descriptors. Fortunately, there's Guido van Rossum <guido@python.org> parents: 20012 diff changeset	1433 static PyGetSetDef file_getsetlist[] = {
ca7af2a5d915 Add optional docstrings to getset descriptors. Fortunately, there's Guido van Rossum <guido@python.org> parents: 20012 diff changeset	1434 {"closed", (getter)get_closed, NULL, "flag set if the file is closed"},
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18755 diff changeset	1435 {0},
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18755 diff changeset	1436 };
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1437
17609 79f0cd3a71a1 Oops, forgot to merge this from the iter-branch to the trunk. Guido van Rossum <guido@python.org> parents: 17518 diff changeset	1438 static PyObject *
17911 fbffb6de25dd file_getiter(): make iter(file) be equivalent to file.xreadlines(). Guido van Rossum <guido@python.org> parents: 17617 diff changeset	1439 file_getiter(PyObject *f)
17609 79f0cd3a71a1 Oops, forgot to merge this from the iter-branch to the trunk. Guido van Rossum <guido@python.org> parents: 17518 diff changeset	1440 {
17911 fbffb6de25dd file_getiter(): make iter(file) be equivalent to file.xreadlines(). Guido van Rossum <guido@python.org> parents: 17617 diff changeset	1441 return PyObject_CallMethod(f, "xreadlines", "");
17609 79f0cd3a71a1 Oops, forgot to merge this from the iter-branch to the trunk. Guido van Rossum <guido@python.org> parents: 17518 diff changeset	1442 }
79f0cd3a71a1 Oops, forgot to merge this from the iter-branch to the trunk. Guido van Rossum <guido@python.org> parents: 17518 diff changeset	1443
19894 51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1444 static PyObject *
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1445 file_new(PyTypeObject type, PyObject args, PyObject *kwds)
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1446 {
19905 a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1447 PyObject *self;
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1448 static PyObject *not_yet_string;
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1449
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1450 assert(type != NULL && type->tp_alloc != NULL);
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1451
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1452 if (not_yet_string == NULL) {
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1453 not_yet_string = PyString_FromString("<uninitialized file>");
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1454 if (not_yet_string == NULL)
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1455 return NULL;
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1456 }
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1457
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1458 self = type->tp_alloc(type, 0);
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1459 if (self != NULL) {
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1460 /* Always fill in the name and mode, so that nobody else
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1461 needs to special-case NULLs there. */
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1462 Py_INCREF(not_yet_string);
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1463 ((PyFileObject *)self)->f_name = not_yet_string;
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1464 Py_INCREF(not_yet_string);
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1465 ((PyFileObject *)self)->f_mode = not_yet_string;
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1466 }
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1467 return self;
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1468 }
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1469
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1470 static int
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1471 file_init(PyObject self, PyObject args, PyObject *kwds)
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1472 {
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1473 PyFileObject foself = (PyFileObject )self;
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1474 int ret = 0;
19894 51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1475 static char *kwlist[] = {"name", "mode", "buffering", 0};
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1476 char *name = NULL;
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1477 char *mode = "r";
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1478 int bufsize = -1;
19905 a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1479
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1480 assert(PyFile_Check(self));
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1481 if (foself->f_fp != NULL) {
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1482 /* Have to close the existing file first. */
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1483 PyObject *closeresult = file_close(foself);
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1484 if (closeresult == NULL)
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1485 return -1;
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1486 Py_DECREF(closeresult);
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1487 }
19894 51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1488
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1489 if (!PyArg_ParseTupleAndKeywords(args, kwds, "et\|si:file", kwlist,
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1490 Py_FileSystemDefaultEncoding, &name,
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1491 &mode, &bufsize))
19905 a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1492 return -1;
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1493 if (fill_file_fields(foself, NULL, name, mode, fclose) == NULL)
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1494 goto Error;
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1495 if (open_the_file(foself, name, mode) == NULL)
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1496 goto Error;
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1497 PyFile_SetBufSize(self, bufsize);
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1498 goto Done;
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1499
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1500 Error:
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1501 ret = -1;
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1502 /* fall through */
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1503 Done:
19894 51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1504 PyMem_Free(name); /* free the encoded string */
19905 a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1505 return ret;
19894 51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1506 }
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1507
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1508 static char file_doc[] =
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1509 "file(name[, mode[, buffering]]) -> file object\n"
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1510 "\n"
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1511 "Open a file. The mode can be 'r', 'w' or 'a' for reading (default),\n"
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1512 "writing or appending. The file will be created if it doesn't exist\n"
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1513 "when opened for writing or appending; it will be truncated when\n"
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1514 "opened for writing. Add a 'b' to the mode for binary files.\n"
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1515 "Add a '+' to the mode to allow simultaneous reading and writing.\n"
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1516 "If the buffering argument is given, 0 means unbuffered, 1 means line\n"
19903 c082971823ce Get rid of builtin_open() entirely (the C code and docstring, not the Tim Peters <tim.peters@gmail.com> parents: 19901 diff changeset	1517 "buffered, and larger numbers specify the buffer size.\n"
c082971823ce Get rid of builtin_open() entirely (the C code and docstring, not the Tim Peters <tim.peters@gmail.com> parents: 19901 diff changeset	1518 "Note: open() is an alias for file().\n";
19894 51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1519
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1520 PyTypeObject PyFile_Type = {
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1521 PyObject_HEAD_INIT(&PyType_Type)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1522 0,
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1523 "file",
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1524 sizeof(PyFileObject),
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1525 0,
17609 79f0cd3a71a1 Oops, forgot to merge this from the iter-branch to the trunk. Guido van Rossum <guido@python.org> parents: 17518 diff changeset	1526 (destructor)file_dealloc, /* tp_dealloc */
79f0cd3a71a1 Oops, forgot to merge this from the iter-branch to the trunk. Guido van Rossum <guido@python.org> parents: 17518 diff changeset	1527 0, /* tp_print */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18755 diff changeset	1528 0, /* tp_getattr */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18755 diff changeset	1529 0, /* tp_setattr */
17609 79f0cd3a71a1 Oops, forgot to merge this from the iter-branch to the trunk. Guido van Rossum <guido@python.org> parents: 17518 diff changeset	1530 0, /* tp_compare */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18755 diff changeset	1531 (reprfunc)file_repr, /* tp_repr */
17609 79f0cd3a71a1 Oops, forgot to merge this from the iter-branch to the trunk. Guido van Rossum <guido@python.org> parents: 17518 diff changeset	1532 0, /* tp_as_number */
79f0cd3a71a1 Oops, forgot to merge this from the iter-branch to the trunk. Guido van Rossum <guido@python.org> parents: 17518 diff changeset	1533 0, /* tp_as_sequence */
79f0cd3a71a1 Oops, forgot to merge this from the iter-branch to the trunk. Guido van Rossum <guido@python.org> parents: 17518 diff changeset	1534 0, /* tp_as_mapping */
79f0cd3a71a1 Oops, forgot to merge this from the iter-branch to the trunk. Guido van Rossum <guido@python.org> parents: 17518 diff changeset	1535 0, /* tp_hash */
79f0cd3a71a1 Oops, forgot to merge this from the iter-branch to the trunk. Guido van Rossum <guido@python.org> parents: 17518 diff changeset	1536 0, /* tp_call */
79f0cd3a71a1 Oops, forgot to merge this from the iter-branch to the trunk. Guido van Rossum <guido@python.org> parents: 17518 diff changeset	1537 0, /* tp_str */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18755 diff changeset	1538 PyObject_GenericGetAttr, /* tp_getattro */
17609 79f0cd3a71a1 Oops, forgot to merge this from the iter-branch to the trunk. Guido van Rossum <guido@python.org> parents: 17518 diff changeset	1539 0, /* tp_setattro */
79f0cd3a71a1 Oops, forgot to merge this from the iter-branch to the trunk. Guido van Rossum <guido@python.org> parents: 17518 diff changeset	1540 0, /* tp_as_buffer */
20277 2983b54256c7 Enable GC for new-style instances. This touches lots of files, since Guido van Rossum <guido@python.org> parents: 20045 diff changeset	1541 Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_BASETYPE, /* tp_flags */
19894 51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1542 file_doc, /* tp_doc */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18755 diff changeset	1543 0, /* tp_traverse */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18755 diff changeset	1544 0, /* tp_clear */
17609 79f0cd3a71a1 Oops, forgot to merge this from the iter-branch to the trunk. Guido van Rossum <guido@python.org> parents: 17518 diff changeset	1545 0, /* tp_richcompare */
79f0cd3a71a1 Oops, forgot to merge this from the iter-branch to the trunk. Guido van Rossum <guido@python.org> parents: 17518 diff changeset	1546 0, /* tp_weaklistoffset */
17911 fbffb6de25dd file_getiter(): make iter(file) be equivalent to file.xreadlines(). Guido van Rossum <guido@python.org> parents: 17617 diff changeset	1547 file_getiter, /* tp_iter */
17617 aac65f50df6f Mondo changes to the iterator stuff, without changing how Python code Guido van Rossum <guido@python.org> parents: 17609 diff changeset	1548 0, /* tp_iternext */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18755 diff changeset	1549 file_methods, /* tp_methods */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18755 diff changeset	1550 file_memberlist, /* tp_members */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18755 diff changeset	1551 file_getsetlist, /* tp_getset */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18755 diff changeset	1552 0, /* tp_base */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18755 diff changeset	1553 0, /* tp_dict */
19894 51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1554 0, /* tp_descr_get */
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1555 0, /* tp_descr_set */
51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1556 0, /* tp_dictoffset */
19905 a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1557 (initproc)file_init, /* tp_init */
a7ba00e3b0de The end of [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19903 diff changeset	1558 PyType_GenericAlloc, /* tp_alloc */
19894 51cc82605d32 SF bug [#460467] file objects should be subclassable. Tim Peters <tim.peters@gmail.com> parents: 19836 diff changeset	1559 file_new, /* tp_new */
20277 2983b54256c7 Enable GC for new-style instances. This touches lots of files, since Guido van Rossum <guido@python.org> parents: 20045 diff changeset	1560 _PyObject_Del, /* tp_free */
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1561 };
177 bd49ca6c4add Added 'softspace' interface to replace 'needspace' printing hack. Guido van Rossum <guido@python.org> parents: 154 diff changeset	1562
bd49ca6c4add Added 'softspace' interface to replace 'needspace' printing hack. Guido van Rossum <guido@python.org> parents: 154 diff changeset	1563 /* Interface for the 'soft space' between print items. */
bd49ca6c4add Added 'softspace' interface to replace 'needspace' printing hack. Guido van Rossum <guido@python.org> parents: 154 diff changeset	1564
bd49ca6c4add Added 'softspace' interface to replace 'needspace' printing hack. Guido van Rossum <guido@python.org> parents: 154 diff changeset	1565 int
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	1566 PyFile_SoftSpace(PyObject *f, int newflag)
177 bd49ca6c4add Added 'softspace' interface to replace 'needspace' printing hack. Guido van Rossum <guido@python.org> parents: 154 diff changeset	1567 {
bd49ca6c4add Added 'softspace' interface to replace 'needspace' printing hack. Guido van Rossum <guido@python.org> parents: 154 diff changeset	1568 int oldflag = 0;
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1569 if (f == NULL) {
2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1570 /* Do nothing */
2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1571 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1572 else if (PyFile_Check(f)) {
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1573 oldflag = ((PyFileObject *)f)->f_softspace;
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1574 ((PyFileObject *)f)->f_softspace = newflag;
177 bd49ca6c4add Added 'softspace' interface to replace 'needspace' printing hack. Guido van Rossum <guido@python.org> parents: 154 diff changeset	1575 }
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1576 else {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1577 PyObject *v;
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1578 v = PyObject_GetAttrString(f, "softspace");
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1579 if (v == NULL)
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1580 PyErr_Clear();
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1581 else {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1582 if (PyInt_Check(v))
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1583 oldflag = PyInt_AsLong(v);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1584 Py_DECREF(v);
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1585 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1586 v = PyInt_FromLong((long)newflag);
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1587 if (v == NULL)
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1588 PyErr_Clear();
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1589 else {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1590 if (PyObject_SetAttrString(f, "softspace", v) != 0)
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1591 PyErr_Clear();
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1592 Py_DECREF(v);
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1593 }
2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1594 }
177 bd49ca6c4add Added 'softspace' interface to replace 'needspace' printing hack. Guido van Rossum <guido@python.org> parents: 154 diff changeset	1595 return oldflag;
bd49ca6c4add Added 'softspace' interface to replace 'needspace' printing hack. Guido van Rossum <guido@python.org> parents: 154 diff changeset	1596 }
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1597
2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1598 /* Interfaces to write objects/strings to file-like objects */
2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1599
2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1600 int
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	1601 PyFile_WriteObject(PyObject v, PyObject f, int flags)
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1602 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1603 PyObject writer, value, args, result;
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1604 if (f == NULL) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1605 PyErr_SetString(PyExc_TypeError, "writeobject with NULL file");
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1606 return -1;
2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1607 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1608 else if (PyFile_Check(f)) {
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1609 FILE *fp = PyFile_AsFile(f);
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1610 if (fp == NULL) {
2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1611 err_closed();
2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1612 return -1;
2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1613 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1614 return PyObject_Print(v, fp, flags);
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1615 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1616 writer = PyObject_GetAttrString(f, "write");
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1617 if (writer == NULL)
2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1618 return -1;
19985 712afdae1123 Patch #462849: Pass Unicode objects to file's .write method. Martin v. Löwis <martin@v.loewis.de> parents: 19905 diff changeset	1619 if (flags & Py_PRINT_RAW) {
712afdae1123 Patch #462849: Pass Unicode objects to file's .write method. Martin v. Löwis <martin@v.loewis.de> parents: 19905 diff changeset	1620 if (PyUnicode_Check(v)) {
712afdae1123 Patch #462849: Pass Unicode objects to file's .write method. Martin v. Löwis <martin@v.loewis.de> parents: 19905 diff changeset	1621 value = v;
712afdae1123 Patch #462849: Pass Unicode objects to file's .write method. Martin v. Löwis <martin@v.loewis.de> parents: 19905 diff changeset	1622 Py_INCREF(value);
712afdae1123 Patch #462849: Pass Unicode objects to file's .write method. Martin v. Löwis <martin@v.loewis.de> parents: 19905 diff changeset	1623 } else
712afdae1123 Patch #462849: Pass Unicode objects to file's .write method. Martin v. Löwis <martin@v.loewis.de> parents: 19905 diff changeset	1624 value = PyObject_Str(v);
712afdae1123 Patch #462849: Pass Unicode objects to file's .write method. Martin v. Löwis <martin@v.loewis.de> parents: 19905 diff changeset	1625 }
712afdae1123 Patch #462849: Pass Unicode objects to file's .write method. Martin v. Löwis <martin@v.loewis.de> parents: 19905 diff changeset	1626 else
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1627 value = PyObject_Repr(v);
1400 aac8231a715c * mpzmodule.c: removed redundant mpz_print function. Guido van Rossum <guido@python.org> parents: 1389 diff changeset	1628 if (value == NULL) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1629 Py_DECREF(writer);
1400 aac8231a715c * mpzmodule.c: removed redundant mpz_print function. Guido van Rossum <guido@python.org> parents: 1389 diff changeset	1630 return -1;
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1631 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1632 args = Py_BuildValue("(O)", value);
5582 87d5d7fa8d07 Fix typo in error checking spotted by Just... Guido van Rossum <guido@python.org> parents: 5479 diff changeset	1633 if (args == NULL) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1634 Py_DECREF(value);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1635 Py_DECREF(writer);
2825 bebb0ea7de20 fix read(0), readline(0); make tuple for call_object args Guido van Rossum <guido@python.org> parents: 2667 diff changeset	1636 return -1;
bebb0ea7de20 fix read(0), readline(0); make tuple for call_object args Guido van Rossum <guido@python.org> parents: 2667 diff changeset	1637 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1638 result = PyEval_CallObject(writer, args);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1639 Py_DECREF(args);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1640 Py_DECREF(value);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1641 Py_DECREF(writer);
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1642 if (result == NULL)
2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1643 return -1;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1644 Py_DECREF(result);
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1645 return 0;
2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1646 }
2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1647
5605 89af5bf8f873 PyFile_WriteString now returns an error indicator instead of calling Guido van Rossum <guido@python.org> parents: 5582 diff changeset	1648 int
21095 b1280cba79b5 PyFile_WriteString(): change prototype so that the string arg is Tim Peters <tim.peters@gmail.com> parents: 20942 diff changeset	1649 PyFile_WriteString(const char s, PyObject f)
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1650 {
2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1651 if (f == NULL) {
5605 89af5bf8f873 PyFile_WriteString now returns an error indicator instead of calling Guido van Rossum <guido@python.org> parents: 5582 diff changeset	1652 /* Should be caused by a pre-existing error */
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	1653 if (!PyErr_Occurred())
5605 89af5bf8f873 PyFile_WriteString now returns an error indicator instead of calling Guido van Rossum <guido@python.org> parents: 5582 diff changeset	1654 PyErr_SetString(PyExc_SystemError,
89af5bf8f873 PyFile_WriteString now returns an error indicator instead of calling Guido van Rossum <guido@python.org> parents: 5582 diff changeset	1655 "null file for PyFile_WriteString");
89af5bf8f873 PyFile_WriteString now returns an error indicator instead of calling Guido van Rossum <guido@python.org> parents: 5582 diff changeset	1656 return -1;
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1657 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1658 else if (PyFile_Check(f)) {
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1659 FILE *fp = PyFile_AsFile(f);
5605 89af5bf8f873 PyFile_WriteString now returns an error indicator instead of calling Guido van Rossum <guido@python.org> parents: 5582 diff changeset	1660 if (fp == NULL) {
89af5bf8f873 PyFile_WriteString now returns an error indicator instead of calling Guido van Rossum <guido@python.org> parents: 5582 diff changeset	1661 err_closed();
89af5bf8f873 PyFile_WriteString now returns an error indicator instead of calling Guido van Rossum <guido@python.org> parents: 5582 diff changeset	1662 return -1;
89af5bf8f873 PyFile_WriteString now returns an error indicator instead of calling Guido van Rossum <guido@python.org> parents: 5582 diff changeset	1663 }
89af5bf8f873 PyFile_WriteString now returns an error indicator instead of calling Guido van Rossum <guido@python.org> parents: 5582 diff changeset	1664 fputs(s, fp);
89af5bf8f873 PyFile_WriteString now returns an error indicator instead of calling Guido van Rossum <guido@python.org> parents: 5582 diff changeset	1665 return 0;
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1666 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1667 else if (!PyErr_Occurred()) {
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4585 diff changeset	1668 PyObject *v = PyString_FromString(s);
5605 89af5bf8f873 PyFile_WriteString now returns an error indicator instead of calling Guido van Rossum <guido@python.org> parents: 5582 diff changeset	1669 int err;
89af5bf8f873 PyFile_WriteString now returns an error indicator instead of calling Guido van Rossum <guido@python.org> parents: 5582 diff changeset	1670 if (v == NULL)
89af5bf8f873 PyFile_WriteString now returns an error indicator instead of calling Guido van Rossum <guido@python.org> parents: 5582 diff changeset	1671 return -1;
89af5bf8f873 PyFile_WriteString now returns an error indicator instead of calling Guido van Rossum <guido@python.org> parents: 5582 diff changeset	1672 err = PyFile_WriteObject(v, f, Py_PRINT_RAW);
89af5bf8f873 PyFile_WriteString now returns an error indicator instead of calling Guido van Rossum <guido@python.org> parents: 5582 diff changeset	1673 Py_DECREF(v);
89af5bf8f873 PyFile_WriteString now returns an error indicator instead of calling Guido van Rossum <guido@python.org> parents: 5582 diff changeset	1674 return err;
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1675 }
5783 9cfbc9bb6423 Reordered list of methods to hopefully put the most frequently used Guido van Rossum <guido@python.org> parents: 5605 diff changeset	1676 else
9cfbc9bb6423 Reordered list of methods to hopefully put the most frequently used Guido van Rossum <guido@python.org> parents: 5605 diff changeset	1677 return -1;
1073 2c0432fcc270 Modified most (but not yet all) I/O to always go through sys.stdout or Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1678 }
13591 2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1679
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1680 /* Try to get a file-descriptor from a Python object. If the object
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1681 is an integer or long integer, its value is returned. If not, the
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1682 object's fileno() method is called if it exists; the method must return
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1683 an integer or long integer, which is returned as the file descriptor value.
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1684 -1 is returned on failure.
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1685 */
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1686
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1687 int PyObject_AsFileDescriptor(PyObject *o)
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1688 {
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1689 int fd;
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1690 PyObject *meth;
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1691
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1692 if (PyInt_Check(o)) {
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1693 fd = PyInt_AsLong(o);
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1694 }
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1695 else if (PyLong_Check(o)) {
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1696 fd = PyLong_AsLong(o);
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1697 }
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1698 else if ((meth = PyObject_GetAttrString(o, "fileno")) != NULL)
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1699 {
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1700 PyObject *fno = PyEval_CallObject(meth, NULL);
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1701 Py_DECREF(meth);
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1702 if (fno == NULL)
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1703 return -1;
15754 7c8fac4ac31a MS Win32 .readline() speedup, as discussed on Python-Dev. This is a tricky Tim Peters <tim.peters@gmail.com> parents: 15753 diff changeset	1704
13591 2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1705 if (PyInt_Check(fno)) {
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1706 fd = PyInt_AsLong(fno);
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1707 Py_DECREF(fno);
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1708 }
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1709 else if (PyLong_Check(fno)) {
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1710 fd = PyLong_AsLong(fno);
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1711 Py_DECREF(fno);
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1712 }
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1713 else {
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1714 PyErr_SetString(PyExc_TypeError,
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1715 "fileno() returned a non-integer");
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1716 Py_DECREF(fno);
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1717 return -1;
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1718 }
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1719 }
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1720 else {
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1721 PyErr_SetString(PyExc_TypeError,
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1722 "argument must be an int, or have a fileno() method.");
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1723 return -1;
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1724 }
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1725
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1726 if (fd < 0) {
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1727 PyErr_Format(PyExc_ValueError,
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1728 "file descriptor cannot be a negative integer (%i)",
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1729 fd);
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1730 return -1;
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1731 }
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1732 return fd;
2077bf141b37 Added PyObject_AsFileDescriptor, which checks for integer, long integer, Andrew M. Kuchling <amk@amk.ca> parents: 13454 diff changeset	1733 }

Mercurial > cpython-lru_cache-weakref

annotate Objects/fileobject.c @ 25838:8540887bcec6 2.2