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