diff options
Diffstat (limited to 'Objects/fileobject.c')
| -rw-r--r-- | Objects/fileobject.c | 4004 |
1 files changed, 2002 insertions, 2002 deletions
diff --git a/Objects/fileobject.c b/Objects/fileobject.c index f479501..6b95a0c 100644 --- a/Objects/fileobject.c +++ b/Objects/fileobject.c @@ -37,10 +37,10 @@ #endif /* Bits in f_newlinetypes */ -#define NEWLINE_UNKNOWN 0 /* No newline seen, yet */ -#define NEWLINE_CR 1 /* \r newline seen */ -#define NEWLINE_LF 2 /* \n newline seen */ -#define NEWLINE_CRLF 4 /* \r\n newline seen */ +#define NEWLINE_UNKNOWN 0 /* No newline seen, yet */ +#define NEWLINE_CR 1 /* \r newline seen */ +#define NEWLINE_LF 2 /* \n newline seen */ +#define NEWLINE_CRLF 4 /* \r\n newline seen */ /* * These macros release the GIL while preventing the f_close() function being @@ -52,19 +52,19 @@ #define FILE_BEGIN_ALLOW_THREADS(fobj) \ { \ - fobj->unlocked_count++; \ - Py_BEGIN_ALLOW_THREADS + fobj->unlocked_count++; \ + Py_BEGIN_ALLOW_THREADS #define FILE_END_ALLOW_THREADS(fobj) \ - Py_END_ALLOW_THREADS \ - fobj->unlocked_count--; \ - assert(fobj->unlocked_count >= 0); \ + Py_END_ALLOW_THREADS \ + fobj->unlocked_count--; \ + assert(fobj->unlocked_count >= 0); \ } #define FILE_ABORT_ALLOW_THREADS(fobj) \ - Py_BLOCK_THREADS \ - fobj->unlocked_count--; \ - assert(fobj->unlocked_count >= 0); + Py_BLOCK_THREADS \ + fobj->unlocked_count--; \ + assert(fobj->unlocked_count >= 0); #ifdef __cplusplus extern "C" { @@ -73,30 +73,30 @@ extern "C" { FILE * PyFile_AsFile(PyObject *f) { - if (f == NULL || !PyFile_Check(f)) - return NULL; - else - return ((PyFileObject *)f)->f_fp; + if (f == NULL || !PyFile_Check(f)) + return NULL; + else + return ((PyFileObject *)f)->f_fp; } void PyFile_IncUseCount(PyFileObject *fobj) { - fobj->unlocked_count++; + fobj->unlocked_count++; } void PyFile_DecUseCount(PyFileObject *fobj) { - fobj->unlocked_count--; - assert(fobj->unlocked_count >= 0); + fobj->unlocked_count--; + assert(fobj->unlocked_count >= 0); } PyObject * PyFile_Name(PyObject *f) { - if (f == NULL || !PyFile_Check(f)) - return NULL; - else - return ((PyFileObject *)f)->f_name; + if (f == NULL || !PyFile_Check(f)) + return NULL; + else + return ((PyFileObject *)f)->f_name; } /* This is a safe wrapper around PyObject_Print to print to the FILE @@ -105,11 +105,11 @@ PyFile_Name(PyObject *f) static int file_PyObject_Print(PyObject *op, PyFileObject *f, int flags) { - int result; - PyFile_IncUseCount(f); - result = PyObject_Print(op, f->f_fp, flags); - PyFile_DecUseCount(f); - return result; + int result; + PyFile_IncUseCount(f); + result = PyObject_Print(op, f->f_fp, flags); + PyFile_DecUseCount(f); + return result; } /* On Unix, fopen will succeed for directories. @@ -120,66 +120,66 @@ static PyFileObject* dircheck(PyFileObject* f) { #if defined(HAVE_FSTAT) && defined(S_IFDIR) && defined(EISDIR) - struct stat buf; - if (f->f_fp == NULL) - return f; - if (fstat(fileno(f->f_fp), &buf) == 0 && - S_ISDIR(buf.st_mode)) { - char *msg = strerror(EISDIR); - PyObject *exc = PyObject_CallFunction(PyExc_IOError, "(isO)", - EISDIR, msg, f->f_name); - PyErr_SetObject(PyExc_IOError, exc); - Py_XDECREF(exc); - return NULL; - } + struct stat buf; + if (f->f_fp == NULL) + return f; + if (fstat(fileno(f->f_fp), &buf) == 0 && + S_ISDIR(buf.st_mode)) { + char *msg = strerror(EISDIR); + PyObject *exc = PyObject_CallFunction(PyExc_IOError, "(isO)", + EISDIR, msg, f->f_name); + PyErr_SetObject(PyExc_IOError, exc); + Py_XDECREF(exc); + return NULL; + } #endif - return f; + return f; } static PyObject * fill_file_fields(PyFileObject *f, FILE *fp, PyObject *name, char *mode, - int (*close)(FILE *)) + int (*close)(FILE *)) { - assert(name != NULL); - assert(f != NULL); - assert(PyFile_Check(f)); - assert(f->f_fp == NULL); - - Py_DECREF(f->f_name); - Py_DECREF(f->f_mode); - Py_DECREF(f->f_encoding); - Py_DECREF(f->f_errors); - - Py_INCREF(name); - f->f_name = name; - - f->f_mode = PyString_FromString(mode); - - f->f_close = close; - f->f_softspace = 0; - f->f_binary = strchr(mode,'b') != NULL; - f->f_buf = NULL; - f->f_univ_newline = (strchr(mode, 'U') != NULL); - f->f_newlinetypes = NEWLINE_UNKNOWN; - f->f_skipnextlf = 0; - Py_INCREF(Py_None); - f->f_encoding = Py_None; - Py_INCREF(Py_None); - f->f_errors = Py_None; - f->readable = f->writable = 0; - if (strchr(mode, 'r') != NULL || f->f_univ_newline) - f->readable = 1; - if (strchr(mode, 'w') != NULL || strchr(mode, 'a') != NULL) - f->writable = 1; - if (strchr(mode, '+') != NULL) - f->readable = f->writable = 1; - - if (f->f_mode == NULL) - return NULL; - f->f_fp = fp; - f = dircheck(f); - return (PyObject *) f; + assert(name != NULL); + assert(f != NULL); + assert(PyFile_Check(f)); + assert(f->f_fp == NULL); + + Py_DECREF(f->f_name); + Py_DECREF(f->f_mode); + Py_DECREF(f->f_encoding); + Py_DECREF(f->f_errors); + + Py_INCREF(name); + f->f_name = name; + + f->f_mode = PyString_FromString(mode); + + f->f_close = close; + f->f_softspace = 0; + f->f_binary = strchr(mode,'b') != NULL; + f->f_buf = NULL; + f->f_univ_newline = (strchr(mode, 'U') != NULL); + f->f_newlinetypes = NEWLINE_UNKNOWN; + f->f_skipnextlf = 0; + Py_INCREF(Py_None); + f->f_encoding = Py_None; + Py_INCREF(Py_None); + f->f_errors = Py_None; + f->readable = f->writable = 0; + if (strchr(mode, 'r') != NULL || f->f_univ_newline) + f->readable = 1; + if (strchr(mode, 'w') != NULL || strchr(mode, 'a') != NULL) + f->writable = 1; + if (strchr(mode, '+') != NULL) + f->readable = f->writable = 1; + + if (f->f_mode == NULL) + return NULL; + f->f_fp = fp; + f = dircheck(f); + return (PyObject *) f; } #if defined _MSC_VER && _MSC_VER >= 1400 && defined(__STDC_SECURE_LIB__) @@ -192,74 +192,74 @@ fill_file_fields(PyFileObject *f, FILE *fp, PyObject *name, char *mode, */ static int _PyVerify_Mode_WINNT(const char *mode) { - /* See if mode string is valid on Windows to avoid hard assertions */ - /* remove leading spacese */ - int singles = 0; - int pairs = 0; - int encoding = 0; - const char *s, *c; - - while(*mode == ' ') /* strip initial spaces */ - ++mode; - if (!strchr("rwa", *mode)) /* must start with one of these */ - return 0; - while (*++mode) { - if (*mode == ' ' || *mode == 'N') /* ignore spaces and N */ - continue; - s = "+TD"; /* each of this can appear only once */ - c = strchr(s, *mode); - if (c) { - ptrdiff_t idx = s-c; - if (singles & (1<<idx)) - return 0; - singles |= (1<<idx); - continue; - } - s = "btcnSR"; /* only one of each letter in the pairs allowed */ - c = strchr(s, *mode); - if (c) { - ptrdiff_t idx = (s-c)/2; - if (pairs & (1<<idx)) - return 0; - pairs |= (1<<idx); - continue; - } - if (*mode == ',') { - encoding = 1; - break; - } - return 0; /* found an invalid char */ - } - - if (encoding) { - char *e[] = {"UTF-8", "UTF-16LE", "UNICODE"}; - while (*mode == ' ') - ++mode; - /* find 'ccs =' */ - if (strncmp(mode, "ccs", 3)) - return 0; - mode += 3; - while (*mode == ' ') - ++mode; - if (*mode != '=') - return 0; - while (*mode == ' ') - ++mode; - for(encoding = 0; encoding<_countof(e); ++encoding) { - size_t l = strlen(e[encoding]); - if (!strncmp(mode, e[encoding], l)) { - mode += l; /* found a valid encoding */ - break; - } - } - if (encoding == _countof(e)) - return 0; - } - /* skip trailing spaces */ - while (*mode == ' ') - ++mode; - - return *mode == '\0'; /* must be at the end of the string */ + /* See if mode string is valid on Windows to avoid hard assertions */ + /* remove leading spacese */ + int singles = 0; + int pairs = 0; + int encoding = 0; + const char *s, *c; + + while(*mode == ' ') /* strip initial spaces */ + ++mode; + if (!strchr("rwa", *mode)) /* must start with one of these */ + return 0; + while (*++mode) { + if (*mode == ' ' || *mode == 'N') /* ignore spaces and N */ + continue; + s = "+TD"; /* each of this can appear only once */ + c = strchr(s, *mode); + if (c) { + ptrdiff_t idx = s-c; + if (singles & (1<<idx)) + return 0; + singles |= (1<<idx); + continue; + } + s = "btcnSR"; /* only one of each letter in the pairs allowed */ + c = strchr(s, *mode); + if (c) { + ptrdiff_t idx = (s-c)/2; + if (pairs & (1<<idx)) + return 0; + pairs |= (1<<idx); + continue; + } + if (*mode == ',') { + encoding = 1; + break; + } + return 0; /* found an invalid char */ + } + + if (encoding) { + char *e[] = {"UTF-8", "UTF-16LE", "UNICODE"}; + while (*mode == ' ') + ++mode; + /* find 'ccs =' */ + if (strncmp(mode, "ccs", 3)) + return 0; + mode += 3; + while (*mode == ' ') + ++mode; + if (*mode != '=') + return 0; + while (*mode == ' ') + ++mode; + for(encoding = 0; encoding<_countof(e); ++encoding) { + size_t l = strlen(e[encoding]); + if (!strncmp(mode, e[encoding], l)) { + mode += l; /* found a valid encoding */ + break; + } + } + if (encoding == _countof(e)) + return 0; + } + /* skip trailing spaces */ + while (*mode == ' ') + ++mode; + + return *mode == '\0'; /* must be at the end of the string */ } #endif @@ -272,264 +272,264 @@ static int _PyVerify_Mode_WINNT(const char *mode) int _PyFile_SanitizeMode(char *mode) { - char *upos; - size_t len = strlen(mode); - - if (!len) { - PyErr_SetString(PyExc_ValueError, "empty mode string"); - return -1; - } - - upos = strchr(mode, 'U'); - if (upos) { - memmove(upos, upos+1, len-(upos-mode)); /* incl null char */ - - if (mode[0] == 'w' || mode[0] == 'a') { - PyErr_Format(PyExc_ValueError, "universal newline " - "mode can only be used with modes " - "starting with 'r'"); - return -1; - } - - if (mode[0] != 'r') { - memmove(mode+1, mode, strlen(mode)+1); - mode[0] = 'r'; - } - - if (!strchr(mode, 'b')) { - memmove(mode+2, mode+1, strlen(mode)); - mode[1] = 'b'; - } - } else if (mode[0] != 'r' && mode[0] != 'w' && mode[0] != 'a') { - PyErr_Format(PyExc_ValueError, "mode string must begin with " - "one of 'r', 'w', 'a' or 'U', not '%.200s'", mode); - return -1; - } + char *upos; + size_t len = strlen(mode); + + if (!len) { + PyErr_SetString(PyExc_ValueError, "empty mode string"); + return -1; + } + + upos = strchr(mode, 'U'); + if (upos) { + memmove(upos, upos+1, len-(upos-mode)); /* incl null char */ + + if (mode[0] == 'w' || mode[0] == 'a') { + PyErr_Format(PyExc_ValueError, "universal newline " + "mode can only be used with modes " + "starting with 'r'"); + return -1; + } + + if (mode[0] != 'r') { + memmove(mode+1, mode, strlen(mode)+1); + mode[0] = 'r'; + } + + if (!strchr(mode, 'b')) { + memmove(mode+2, mode+1, strlen(mode)); + mode[1] = 'b'; + } + } else if (mode[0] != 'r' && mode[0] != 'w' && mode[0] != 'a') { + PyErr_Format(PyExc_ValueError, "mode string must begin with " + "one of 'r', 'w', 'a' or 'U', not '%.200s'", mode); + return -1; + } #ifdef Py_VERIFY_WINNT - /* additional checks on NT with visual studio 2005 and higher */ - if (!_PyVerify_Mode_WINNT(mode)) { - PyErr_Format(PyExc_ValueError, "Invalid mode ('%.50s')", mode); - return -1; - } + /* additional checks on NT with visual studio 2005 and higher */ + if (!_PyVerify_Mode_WINNT(mode)) { + PyErr_Format(PyExc_ValueError, "Invalid mode ('%.50s')", mode); + return -1; + } #endif - return 0; + return 0; } static PyObject * open_the_file(PyFileObject *f, char *name, char *mode) { - char *newmode; - assert(f != NULL); - assert(PyFile_Check(f)); + char *newmode; + assert(f != NULL); + assert(PyFile_Check(f)); #ifdef MS_WINDOWS - /* windows ignores the passed name in order to support Unicode */ - assert(f->f_name != NULL); + /* windows ignores the passed name in order to support Unicode */ + assert(f->f_name != NULL); #else - assert(name != NULL); + assert(name != NULL); #endif - assert(mode != NULL); - assert(f->f_fp == NULL); - - /* probably need to replace 'U' by 'rb' */ - newmode = PyMem_MALLOC(strlen(mode) + 3); - if (!newmode) { - PyErr_NoMemory(); - return NULL; - } - strcpy(newmode, mode); - - if (_PyFile_SanitizeMode(newmode)) { - f = NULL; - goto cleanup; - } - - /* rexec.py can't stop a user from getting the file() constructor -- - all they have to do is get *any* file object f, and then do - type(f). Here we prevent them from doing damage with it. */ - if (PyEval_GetRestricted()) { - PyErr_SetString(PyExc_IOError, - "file() constructor not accessible in restricted mode"); - f = NULL; - goto cleanup; - } - errno = 0; + assert(mode != NULL); + assert(f->f_fp == NULL); + + /* probably need to replace 'U' by 'rb' */ + newmode = PyMem_MALLOC(strlen(mode) + 3); + if (!newmode) { + PyErr_NoMemory(); + return NULL; + } + strcpy(newmode, mode); + + if (_PyFile_SanitizeMode(newmode)) { + f = NULL; + goto cleanup; + } + + /* rexec.py can't stop a user from getting the file() constructor -- + all they have to do is get *any* file object f, and then do + type(f). Here we prevent them from doing damage with it. */ + if (PyEval_GetRestricted()) { + PyErr_SetString(PyExc_IOError, + "file() constructor not accessible in restricted mode"); + f = NULL; + goto cleanup; + } + errno = 0; #ifdef MS_WINDOWS - if (PyUnicode_Check(f->f_name)) { - PyObject *wmode; - wmode = PyUnicode_DecodeASCII(newmode, strlen(newmode), NULL); - if (f->f_name && wmode) { - FILE_BEGIN_ALLOW_THREADS(f) - /* PyUnicode_AS_UNICODE OK without thread - lock as it is a simple dereference. */ - f->f_fp = _wfopen(PyUnicode_AS_UNICODE(f->f_name), - PyUnicode_AS_UNICODE(wmode)); - FILE_END_ALLOW_THREADS(f) - } - Py_XDECREF(wmode); - } + if (PyUnicode_Check(f->f_name)) { + PyObject *wmode; + wmode = PyUnicode_DecodeASCII(newmode, strlen(newmode), NULL); + if (f->f_name && wmode) { + FILE_BEGIN_ALLOW_THREADS(f) + /* PyUnicode_AS_UNICODE OK without thread + lock as it is a simple dereference. */ + f->f_fp = _wfopen(PyUnicode_AS_UNICODE(f->f_name), + PyUnicode_AS_UNICODE(wmode)); + FILE_END_ALLOW_THREADS(f) + } + Py_XDECREF(wmode); + } #endif - if (NULL == f->f_fp && NULL != name) { - FILE_BEGIN_ALLOW_THREADS(f) - f->f_fp = fopen(name, newmode); - FILE_END_ALLOW_THREADS(f) - } + if (NULL == f->f_fp && NULL != name) { + FILE_BEGIN_ALLOW_THREADS(f) + f->f_fp = fopen(name, newmode); + FILE_END_ALLOW_THREADS(f) + } - if (f->f_fp == NULL) { + if (f->f_fp == NULL) { #if defined _MSC_VER && (_MSC_VER < 1400 || !defined(__STDC_SECURE_LIB__)) - /* MSVC 6 (Microsoft) leaves errno at 0 for bad mode strings, - * across all Windows flavors. When it sets EINVAL varies - * across Windows flavors, the exact conditions aren't - * documented, and the answer lies in the OS's implementation - * of Win32's CreateFile function (whose source is secret). - * Seems the best we can do is map EINVAL to ENOENT. - * Starting with Visual Studio .NET 2005, EINVAL is correctly - * set by our CRT error handler (set in exceptions.c.) - */ - if (errno == 0) /* bad mode string */ - errno = EINVAL; - else if (errno == EINVAL) /* unknown, but not a mode string */ - errno = ENOENT; + /* MSVC 6 (Microsoft) leaves errno at 0 for bad mode strings, + * across all Windows flavors. When it sets EINVAL varies + * across Windows flavors, the exact conditions aren't + * documented, and the answer lies in the OS's implementation + * of Win32's CreateFile function (whose source is secret). + * Seems the best we can do is map EINVAL to ENOENT. + * Starting with Visual Studio .NET 2005, EINVAL is correctly + * set by our CRT error handler (set in exceptions.c.) + */ + if (errno == 0) /* bad mode string */ + errno = EINVAL; + else if (errno == EINVAL) /* unknown, but not a mode string */ + errno = ENOENT; #endif - /* EINVAL is returned when an invalid filename or - * an invalid mode is supplied. */ - if (errno == EINVAL) { - PyObject *v; - char message[100]; - PyOS_snprintf(message, 100, - "invalid mode ('%.50s') or filename", mode); - v = Py_BuildValue("(isO)", errno, message, f->f_name); - if (v != NULL) { - PyErr_SetObject(PyExc_IOError, v); - Py_DECREF(v); - } - } - else - PyErr_SetFromErrnoWithFilenameObject(PyExc_IOError, f->f_name); - f = NULL; - } - if (f != NULL) - f = dircheck(f); + /* EINVAL is returned when an invalid filename or + * an invalid mode is supplied. */ + if (errno == EINVAL) { + PyObject *v; + char message[100]; + PyOS_snprintf(message, 100, + "invalid mode ('%.50s') or filename", mode); + v = Py_BuildValue("(isO)", errno, message, f->f_name); + if (v != NULL) { + PyErr_SetObject(PyExc_IOError, v); + Py_DECREF(v); + } + } + else + PyErr_SetFromErrnoWithFilenameObject(PyExc_IOError, f->f_name); + f = NULL; + } + if (f != NULL) + f = dircheck(f); cleanup: - PyMem_FREE(newmode); + PyMem_FREE(newmode); - return (PyObject *)f; + return (PyObject *)f; } static PyObject * close_the_file(PyFileObject *f) { - int sts = 0; - int (*local_close)(FILE *); - FILE *local_fp = f->f_fp; - if (local_fp != NULL) { - local_close = f->f_close; - if (local_close != NULL && f->unlocked_count > 0) { - if (f->ob_refcnt > 0) { - PyErr_SetString(PyExc_IOError, - "close() called during concurrent " - "operation on the same file object."); - } else { - /* This should not happen unless someone is - * carelessly playing with the PyFileObject - * struct fields and/or its associated FILE - * pointer. */ - PyErr_SetString(PyExc_SystemError, - "PyFileObject locking error in " - "destructor (refcnt <= 0 at close)."); - } - return NULL; - } - /* NULL out the FILE pointer before releasing the GIL, because - * it will not be valid anymore after the close() function is - * called. */ - f->f_fp = NULL; - if (local_close != NULL) { - Py_BEGIN_ALLOW_THREADS - errno = 0; - sts = (*local_close)(local_fp); - Py_END_ALLOW_THREADS - if (sts == EOF) - return PyErr_SetFromErrno(PyExc_IOError); - if (sts != 0) - return PyInt_FromLong((long)sts); - } - } - Py_RETURN_NONE; + int sts = 0; + int (*local_close)(FILE *); + FILE *local_fp = f->f_fp; + if (local_fp != NULL) { + local_close = f->f_close; + if (local_close != NULL && f->unlocked_count > 0) { + if (f->ob_refcnt > 0) { + PyErr_SetString(PyExc_IOError, + "close() called during concurrent " + "operation on the same file object."); + } else { + /* This should not happen unless someone is + * carelessly playing with the PyFileObject + * struct fields and/or its associated FILE + * pointer. */ + PyErr_SetString(PyExc_SystemError, + "PyFileObject locking error in " + "destructor (refcnt <= 0 at close)."); + } + return NULL; + } + /* NULL out the FILE pointer before releasing the GIL, because + * it will not be valid anymore after the close() function is + * called. */ + f->f_fp = NULL; + if (local_close != NULL) { + Py_BEGIN_ALLOW_THREADS + errno = 0; + sts = (*local_close)(local_fp); + Py_END_ALLOW_THREADS + if (sts == EOF) + return PyErr_SetFromErrno(PyExc_IOError); + if (sts != 0) + return PyInt_FromLong((long)sts); + } + } + Py_RETURN_NONE; } PyObject * PyFile_FromFile(FILE *fp, char *name, char *mode, int (*close)(FILE *)) { - PyFileObject *f = (PyFileObject *)PyFile_Type.tp_new(&PyFile_Type, - NULL, NULL); - if (f != NULL) { - PyObject *o_name = PyString_FromString(name); - if (o_name == NULL) - return NULL; - if (fill_file_fields(f, fp, o_name, mode, close) == NULL) { - Py_DECREF(f); - f = NULL; - } - Py_DECREF(o_name); - } - return (PyObject *) f; + PyFileObject *f = (PyFileObject *)PyFile_Type.tp_new(&PyFile_Type, + NULL, NULL); + if (f != NULL) { + PyObject *o_name = PyString_FromString(name); + if (o_name == NULL) + return NULL; + if (fill_file_fields(f, fp, o_name, mode, close) == NULL) { + Py_DECREF(f); + f = NULL; + } + Py_DECREF(o_name); + } + return (PyObject *) f; } PyObject * PyFile_FromString(char *name, char *mode) { - extern int fclose(FILE *); - PyFileObject *f; - - f = (PyFileObject *)PyFile_FromFile((FILE *)NULL, name, mode, fclose); - if (f != NULL) { - if (open_the_file(f, name, mode) == NULL) { - Py_DECREF(f); - f = NULL; - } - } - return (PyObject *)f; + extern int fclose(FILE *); + PyFileObject *f; + + f = (PyFileObject *)PyFile_FromFile((FILE *)NULL, name, mode, fclose); + if (f != NULL) { + if (open_the_file(f, name, mode) == NULL) { + Py_DECREF(f); + f = NULL; + } + } + return (PyObject *)f; } void PyFile_SetBufSize(PyObject *f, int bufsize) { - PyFileObject *file = (PyFileObject *)f; - if (bufsize >= 0) { - int type; - switch (bufsize) { - case 0: - type = _IONBF; - break; + PyFileObject *file = (PyFileObject *)f; + if (bufsize >= 0) { + int type; + switch (bufsize) { + case 0: + type = _IONBF; + break; #ifdef HAVE_SETVBUF - case 1: - type = _IOLBF; - bufsize = BUFSIZ; - break; + case 1: + type = _IOLBF; + bufsize = BUFSIZ; + break; #endif - default: - type = _IOFBF; + default: + type = _IOFBF; #ifndef HAVE_SETVBUF - bufsize = BUFSIZ; + bufsize = BUFSIZ; #endif - break; - } - fflush(file->f_fp); - if (type == _IONBF) { - PyMem_Free(file->f_setbuf); - file->f_setbuf = NULL; - } else { - file->f_setbuf = (char *)PyMem_Realloc(file->f_setbuf, - bufsize); - } + break; + } + fflush(file->f_fp); + if (type == _IONBF) { + PyMem_Free(file->f_setbuf); + file->f_setbuf = NULL; + } else { + file->f_setbuf = (char *)PyMem_Realloc(file->f_setbuf, + bufsize); + } #ifdef HAVE_SETVBUF - setvbuf(file->f_fp, file->f_setbuf, type, bufsize); + setvbuf(file->f_fp, file->f_setbuf, type, bufsize); #else /* !HAVE_SETVBUF */ - setbuf(file->f_fp, file->f_setbuf); + setbuf(file->f_fp, file->f_setbuf); #endif /* !HAVE_SETVBUF */ - } + } } /* Set the encoding used to output Unicode strings. @@ -538,48 +538,48 @@ PyFile_SetBufSize(PyObject *f, int bufsize) int PyFile_SetEncoding(PyObject *f, const char *enc) { - return PyFile_SetEncodingAndErrors(f, enc, NULL); + return PyFile_SetEncodingAndErrors(f, enc, NULL); } int PyFile_SetEncodingAndErrors(PyObject *f, const char *enc, char* errors) { - PyFileObject *file = (PyFileObject*)f; - PyObject *str, *oerrors; - - assert(PyFile_Check(f)); - str = PyString_FromString(enc); - if (!str) - return 0; - if (errors) { - oerrors = PyString_FromString(errors); - if (!oerrors) { - Py_DECREF(str); - return 0; - } - } else { - oerrors = Py_None; - Py_INCREF(Py_None); - } - Py_DECREF(file->f_encoding); - file->f_encoding = str; - Py_DECREF(file->f_errors); - file->f_errors = oerrors; - return 1; + PyFileObject *file = (PyFileObject*)f; + PyObject *str, *oerrors; + + assert(PyFile_Check(f)); + str = PyString_FromString(enc); + if (!str) + return 0; + if (errors) { + oerrors = PyString_FromString(errors); + if (!oerrors) { + Py_DECREF(str); + return 0; + } + } else { + oerrors = Py_None; + Py_INCREF(Py_None); + } + Py_DECREF(file->f_encoding); + file->f_encoding = str; + Py_DECREF(file->f_errors); + file->f_errors = oerrors; + return 1; } static PyObject * err_closed(void) { - PyErr_SetString(PyExc_ValueError, "I/O operation on closed file"); - return NULL; + PyErr_SetString(PyExc_ValueError, "I/O operation on closed file"); + return NULL; } static PyObject * err_mode(char *action) { - PyErr_Format(PyExc_IOError, "File not open for %s", action); - return NULL; + PyErr_Format(PyExc_IOError, "File not open for %s", action); + return NULL; } /* Refuse regular file I/O if there's data in the iteration-buffer. @@ -588,9 +588,9 @@ err_mode(char *action) static PyObject * err_iterbuffered(void) { - PyErr_SetString(PyExc_ValueError, - "Mixing iteration and read methods would lose data"); - return NULL; + PyErr_SetString(PyExc_ValueError, + "Mixing iteration and read methods would lose data"); + return NULL; } static void drop_readahead(PyFileObject *); @@ -600,58 +600,58 @@ static void drop_readahead(PyFileObject *); static void file_dealloc(PyFileObject *f) { - PyObject *ret; - if (f->weakreflist != NULL) - PyObject_ClearWeakRefs((PyObject *) f); - ret = close_the_file(f); - if (!ret) { - PySys_WriteStderr("close failed in file object destructor:\n"); - PyErr_Print(); - } - else { - Py_DECREF(ret); - } - PyMem_Free(f->f_setbuf); - Py_XDECREF(f->f_name); - Py_XDECREF(f->f_mode); - Py_XDECREF(f->f_encoding); - Py_XDECREF(f->f_errors); - drop_readahead(f); - Py_TYPE(f)->tp_free((PyObject *)f); + PyObject *ret; + if (f->weakreflist != NULL) + PyObject_ClearWeakRefs((PyObject *) f); + ret = close_the_file(f); + if (!ret) { + PySys_WriteStderr("close failed in file object destructor:\n"); + PyErr_Print(); + } + else { + Py_DECREF(ret); + } + PyMem_Free(f->f_setbuf); + Py_XDECREF(f->f_name); + Py_XDECREF(f->f_mode); + Py_XDECREF(f->f_encoding); + Py_XDECREF(f->f_errors); + drop_readahead(f); + Py_TYPE(f)->tp_free((PyObject *)f); } static PyObject * file_repr(PyFileObject *f) { - if (PyUnicode_Check(f->f_name)) { + if (PyUnicode_Check(f->f_name)) { #ifdef Py_USING_UNICODE - PyObject *ret = NULL; - PyObject *name = PyUnicode_AsUnicodeEscapeString(f->f_name); - const char *name_str = name ? PyString_AsString(name) : "?"; - ret = PyString_FromFormat("<%s file u'%s', mode '%s' at %p>", - f->f_fp == NULL ? "closed" : "open", - name_str, - PyString_AsString(f->f_mode), - f); - Py_XDECREF(name); - return ret; + PyObject *ret = NULL; + PyObject *name = PyUnicode_AsUnicodeEscapeString(f->f_name); + const char *name_str = name ? PyString_AsString(name) : "?"; + ret = PyString_FromFormat("<%s file u'%s', mode '%s' at %p>", + f->f_fp == NULL ? "closed" : "open", + name_str, + PyString_AsString(f->f_mode), + f); + Py_XDECREF(name); + return ret; #endif - } else { - return PyString_FromFormat("<%s file '%s', mode '%s' at %p>", - f->f_fp == NULL ? "closed" : "open", - PyString_AsString(f->f_name), - PyString_AsString(f->f_mode), - f); - } + } else { + return PyString_FromFormat("<%s file '%s', mode '%s' at %p>", + f->f_fp == NULL ? "closed" : "open", + PyString_AsString(f->f_name), + PyString_AsString(f->f_mode), + f); + } } static PyObject * file_close(PyFileObject *f) { - PyObject *sts = close_the_file(f); - PyMem_Free(f->f_setbuf); - f->f_setbuf = NULL; - return sts; + PyObject *sts = close_the_file(f); + PyMem_Free(f->f_setbuf); + f->f_setbuf = NULL; + return sts; } @@ -673,36 +673,36 @@ static int _portable_fseek(FILE *fp, Py_off_t offset, int whence) { #if !defined(HAVE_LARGEFILE_SUPPORT) - return fseek(fp, offset, whence); + return fseek(fp, offset, whence); #elif defined(HAVE_FSEEKO) && SIZEOF_OFF_T >= 8 - return fseeko(fp, offset, whence); + return fseeko(fp, offset, whence); #elif defined(HAVE_FSEEK64) - return fseek64(fp, offset, whence); + return fseek64(fp, offset, whence); #elif defined(__BEOS__) - return _fseek(fp, offset, whence); + return _fseek(fp, offset, whence); #elif SIZEOF_FPOS_T >= 8 - /* lacking a 64-bit capable fseek(), use a 64-bit capable fsetpos() - and fgetpos() to implement fseek()*/ - fpos_t pos; - switch (whence) { - case SEEK_END: + /* lacking a 64-bit capable fseek(), use a 64-bit capable fsetpos() + and fgetpos() to implement fseek()*/ + fpos_t pos; + switch (whence) { + case SEEK_END: #ifdef MS_WINDOWS - fflush(fp); - if (_lseeki64(fileno(fp), 0, 2) == -1) - return -1; + fflush(fp); + if (_lseeki64(fileno(fp), 0, 2) == -1) + return -1; #else - if (fseek(fp, 0, SEEK_END) != 0) - return -1; + if (fseek(fp, 0, SEEK_END) != 0) + return -1; #endif - /* fall through */ - case SEEK_CUR: - if (fgetpos(fp, &pos) != 0) - return -1; - offset += pos; - break; - /* case SEEK_SET: break; */ - } - return fsetpos(fp, &offset); + /* fall through */ + case SEEK_CUR: + if (fgetpos(fp, &pos) != 0) + return -1; + offset += pos; + break; + /* case SEEK_SET: break; */ + } + return fsetpos(fp, &offset); #else #error "Large file support, but no way to fseek." #endif @@ -716,16 +716,16 @@ static Py_off_t _portable_ftell(FILE* fp) { #if !defined(HAVE_LARGEFILE_SUPPORT) - return ftell(fp); + return ftell(fp); #elif defined(HAVE_FTELLO) && SIZEOF_OFF_T >= 8 - return ftello(fp); + return ftello(fp); #elif defined(HAVE_FTELL64) - return ftell64(fp); + return ftell64(fp); #elif SIZEOF_FPOS_T >= 8 - fpos_t pos; - if (fgetpos(fp, &pos) != 0) - return -1; - return pos; + fpos_t pos; + if (fgetpos(fp, &pos) != 0) + return -1; + return pos; #else #error "Large file support, but no way to ftell." #endif @@ -735,53 +735,53 @@ _portable_ftell(FILE* fp) static PyObject * file_seek(PyFileObject *f, PyObject *args) { - int whence; - int ret; - Py_off_t offset; - PyObject *offobj, *off_index; - - if (f->f_fp == NULL) - return err_closed(); - drop_readahead(f); - whence = 0; - if (!PyArg_ParseTuple(args, "O|i:seek", &offobj, &whence)) - return NULL; - off_index = PyNumber_Index(offobj); - if (!off_index) { - if (!PyFloat_Check(offobj)) - return NULL; - /* Deprecated in 2.6 */ - PyErr_Clear(); - if (PyErr_WarnEx(PyExc_DeprecationWarning, - "integer argument expected, got float", - 1) < 0) - return NULL; - off_index = offobj; - Py_INCREF(offobj); - } + int whence; + int ret; + Py_off_t offset; + PyObject *offobj, *off_index; + + if (f->f_fp == NULL) + return err_closed(); + drop_readahead(f); + whence = 0; + if (!PyArg_ParseTuple(args, "O|i:seek", &offobj, &whence)) + return NULL; + off_index = PyNumber_Index(offobj); + if (!off_index) { + if (!PyFloat_Check(offobj)) + return NULL; + /* Deprecated in 2.6 */ + PyErr_Clear(); + if (PyErr_WarnEx(PyExc_DeprecationWarning, + "integer argument expected, got float", + 1) < 0) + return NULL; + off_index = offobj; + Py_INCREF(offobj); + } #if !defined(HAVE_LARGEFILE_SUPPORT) - offset = PyInt_AsLong(off_index); + offset = PyInt_AsLong(off_index); #else - offset = PyLong_Check(off_index) ? - PyLong_AsLongLong(off_index) : PyInt_AsLong(off_index); + offset = PyLong_Check(off_index) ? + PyLong_AsLongLong(off_index) : PyInt_AsLong(off_index); #endif - Py_DECREF(off_index); - if (PyErr_Occurred()) - return NULL; - - FILE_BEGIN_ALLOW_THREADS(f) - errno = 0; - ret = _portable_fseek(f->f_fp, offset, whence); - FILE_END_ALLOW_THREADS(f) - - if (ret != 0) { - PyErr_SetFromErrno(PyExc_IOError); - clearerr(f->f_fp); - return NULL; - } - f->f_skipnextlf = 0; - Py_INCREF(Py_None); - return Py_None; + Py_DECREF(off_index); + if (PyErr_Occurred()) + return NULL; + + FILE_BEGIN_ALLOW_THREADS(f) + errno = 0; + ret = _portable_fseek(f->f_fp, offset, whence); + FILE_END_ALLOW_THREADS(f) + + if (ret != 0) { + PyErr_SetFromErrno(PyExc_IOError); + clearerr(f->f_fp); + return NULL; + } + f->f_skipnextlf = 0; + Py_INCREF(Py_None); + return Py_None; } @@ -789,186 +789,186 @@ file_seek(PyFileObject *f, PyObject *args) static PyObject * file_truncate(PyFileObject *f, PyObject *args) { - Py_off_t newsize; - PyObject *newsizeobj = NULL; - Py_off_t initialpos; - int ret; - - if (f->f_fp == NULL) - return err_closed(); - if (!f->writable) - return err_mode("writing"); - if (!PyArg_UnpackTuple(args, "truncate", 0, 1, &newsizeobj)) - return NULL; - - /* Get current file position. If the file happens to be open for - * update and the last operation was an input operation, C doesn't - * define what the later fflush() will do, but we promise truncate() - * won't change the current position (and fflush() *does* change it - * then at least on Windows). The easiest thing is to capture - * current pos now and seek back to it at the end. - */ - FILE_BEGIN_ALLOW_THREADS(f) - errno = 0; - initialpos = _portable_ftell(f->f_fp); - FILE_END_ALLOW_THREADS(f) - if (initialpos == -1) - goto onioerror; - - /* Set newsize to current postion if newsizeobj NULL, else to the - * specified value. - */ - if (newsizeobj != NULL) { + Py_off_t newsize; + PyObject *newsizeobj = NULL; + Py_off_t initialpos; + int ret; + + if (f->f_fp == NULL) + return err_closed(); + if (!f->writable) + return err_mode("writing"); + if (!PyArg_UnpackTuple(args, "truncate", 0, 1, &newsizeobj)) + return NULL; + + /* Get current file position. If the file happens to be open for + * update and the last operation was an input operation, C doesn't + * define what the later fflush() will do, but we promise truncate() + * won't change the current position (and fflush() *does* change it + * then at least on Windows). The easiest thing is to capture + * current pos now and seek back to it at the end. + */ + FILE_BEGIN_ALLOW_THREADS(f) + errno = 0; + initialpos = _portable_ftell(f->f_fp); + FILE_END_ALLOW_THREADS(f) + if (initialpos == -1) + goto onioerror; + + /* Set newsize to current postion if newsizeobj NULL, else to the + * specified value. + */ + if (newsizeobj != NULL) { #if !defined(HAVE_LARGEFILE_SUPPORT) - newsize = PyInt_AsLong(newsizeobj); + newsize = PyInt_AsLong(newsizeobj); #else - newsize = PyLong_Check(newsizeobj) ? - PyLong_AsLongLong(newsizeobj) : - PyInt_AsLong(newsizeobj); + newsize = PyLong_Check(newsizeobj) ? + PyLong_AsLongLong(newsizeobj) : + PyInt_AsLong(newsizeobj); #endif - if (PyErr_Occurred()) - return NULL; - } - else /* default to current position */ - newsize = initialpos; - - /* Flush the stream. We're mixing stream-level I/O with lower-level - * I/O, and a flush may be necessary to synch both platform views - * of the current file state. - */ - FILE_BEGIN_ALLOW_THREADS(f) - errno = 0; - ret = fflush(f->f_fp); - FILE_END_ALLOW_THREADS(f) - if (ret != 0) - goto onioerror; + if (PyErr_Occurred()) + return NULL; + } + else /* default to current position */ + newsize = initialpos; + + /* Flush the stream. We're mixing stream-level I/O with lower-level + * I/O, and a flush may be necessary to synch both platform views + * of the current file state. + */ + FILE_BEGIN_ALLOW_THREADS(f) + errno = 0; + ret = fflush(f->f_fp); + FILE_END_ALLOW_THREADS(f) + if (ret != 0) + goto onioerror; #ifdef MS_WINDOWS - /* MS _chsize doesn't work if newsize doesn't fit in 32 bits, - so don't even try using it. */ - { - HANDLE hFile; - - /* Have to move current pos to desired endpoint on Windows. */ - FILE_BEGIN_ALLOW_THREADS(f) - errno = 0; - ret = _portable_fseek(f->f_fp, newsize, SEEK_SET) != 0; - FILE_END_ALLOW_THREADS(f) - if (ret) - goto onioerror; - - /* Truncate. Note that this may grow the file! */ - FILE_BEGIN_ALLOW_THREADS(f) - errno = 0; - hFile = (HANDLE)_get_osfhandle(fileno(f->f_fp)); - ret = hFile == (HANDLE)-1; - if (ret == 0) { - ret = SetEndOfFile(hFile) == 0; - if (ret) - errno = EACCES; - } - FILE_END_ALLOW_THREADS(f) - if (ret) - goto onioerror; - } + /* MS _chsize doesn't work if newsize doesn't fit in 32 bits, + so don't even try using it. */ + { + HANDLE hFile; + + /* Have to move current pos to desired endpoint on Windows. */ + FILE_BEGIN_ALLOW_THREADS(f) + errno = 0; + ret = _portable_fseek(f->f_fp, newsize, SEEK_SET) != 0; + FILE_END_ALLOW_THREADS(f) + if (ret) + goto onioerror; + + /* Truncate. Note that this may grow the file! */ + FILE_BEGIN_ALLOW_THREADS(f) + errno = 0; + hFile = (HANDLE)_get_osfhandle(fileno(f->f_fp)); + ret = hFile == (HANDLE)-1; + if (ret == 0) { + ret = SetEndOfFile(hFile) == 0; + if (ret) + errno = EACCES; + } + FILE_END_ALLOW_THREADS(f) + if (ret) + goto onioerror; + } #else - FILE_BEGIN_ALLOW_THREADS(f) - errno = 0; - ret = ftruncate(fileno(f->f_fp), newsize); - FILE_END_ALLOW_THREADS(f) - if (ret != 0) - goto onioerror; + FILE_BEGIN_ALLOW_THREADS(f) + errno = 0; + ret = ftruncate(fileno(f->f_fp), newsize); + FILE_END_ALLOW_THREADS(f) + if (ret != 0) + goto onioerror; #endif /* !MS_WINDOWS */ - /* Restore original file position. */ - FILE_BEGIN_ALLOW_THREADS(f) - errno = 0; - ret = _portable_fseek(f->f_fp, initialpos, SEEK_SET) != 0; - FILE_END_ALLOW_THREADS(f) - if (ret) - goto onioerror; + /* Restore original file position. */ + FILE_BEGIN_ALLOW_THREADS(f) + errno = 0; + ret = _portable_fseek(f->f_fp, initialpos, SEEK_SET) != 0; + FILE_END_ALLOW_THREADS(f) + if (ret) + goto onioerror; - Py_INCREF(Py_None); - return Py_None; + Py_INCREF(Py_None); + return Py_None; onioerror: - PyErr_SetFromErrno(PyExc_IOError); - clearerr(f->f_fp); - return NULL; + PyErr_SetFromErrno(PyExc_IOError); + clearerr(f->f_fp); + return NULL; } #endif /* HAVE_FTRUNCATE */ static PyObject * file_tell(PyFileObject *f) { - Py_off_t pos; - - if (f->f_fp == NULL) - return err_closed(); - FILE_BEGIN_ALLOW_THREADS(f) - errno = 0; - pos = _portable_ftell(f->f_fp); - FILE_END_ALLOW_THREADS(f) - - if (pos == -1) { - PyErr_SetFromErrno(PyExc_IOError); - clearerr(f->f_fp); - return NULL; - } - if (f->f_skipnextlf) { - int c; - c = GETC(f->f_fp); - if (c == '\n') { - f->f_newlinetypes |= NEWLINE_CRLF; - pos++; - f->f_skipnextlf = 0; - } else if (c != EOF) ungetc(c, f->f_fp); - } + Py_off_t pos; + + if (f->f_fp == NULL) + return err_closed(); + FILE_BEGIN_ALLOW_THREADS(f) + errno = 0; + pos = _portable_ftell(f->f_fp); + FILE_END_ALLOW_THREADS(f) + + if (pos == -1) { + PyErr_SetFromErrno(PyExc_IOError); + clearerr(f->f_fp); + return NULL; + } + if (f->f_skipnextlf) { + int c; + c = GETC(f->f_fp); + if (c == '\n') { + f->f_newlinetypes |= NEWLINE_CRLF; + pos++; + f->f_skipnextlf = 0; + } else if (c != EOF) ungetc(c, f->f_fp); + } #if !defined(HAVE_LARGEFILE_SUPPORT) - return PyInt_FromLong(pos); + return PyInt_FromLong(pos); #else - return PyLong_FromLongLong(pos); + return PyLong_FromLongLong(pos); #endif } static PyObject * file_fileno(PyFileObject *f) { - if (f->f_fp == NULL) - return err_closed(); - return PyInt_FromLong((long) fileno(f->f_fp)); + if (f->f_fp == NULL) + return err_closed(); + return PyInt_FromLong((long) fileno(f->f_fp)); } static PyObject * file_flush(PyFileObject *f) { - int res; - - if (f->f_fp == NULL) - return err_closed(); - FILE_BEGIN_ALLOW_THREADS(f) - errno = 0; - res = fflush(f->f_fp); - FILE_END_ALLOW_THREADS(f) - if (res != 0) { - PyErr_SetFromErrno(PyExc_IOError); - clearerr(f->f_fp); - return NULL; - } - Py_INCREF(Py_None); - return Py_None; + int res; + + if (f->f_fp == NULL) + return err_closed(); + FILE_BEGIN_ALLOW_THREADS(f) + errno = 0; + res = fflush(f->f_fp); + FILE_END_ALLOW_THREADS(f) + if (res != 0) { + PyErr_SetFromErrno(PyExc_IOError); + clearerr(f->f_fp); + return NULL; + } + Py_INCREF(Py_None); + return Py_None; } static PyObject * file_isatty(PyFileObject *f) { - long res; - if (f->f_fp == NULL) - return err_closed(); - FILE_BEGIN_ALLOW_THREADS(f) - res = isatty((int)fileno(f->f_fp)); - FILE_END_ALLOW_THREADS(f) - return PyBool_FromLong(res); + long res; + if (f->f_fp == NULL) + return err_closed(); + FILE_BEGIN_ALLOW_THREADS(f) + res = isatty((int)fileno(f->f_fp)); + FILE_END_ALLOW_THREADS(f) + return PyBool_FromLong(res); } @@ -988,39 +988,39 @@ static size_t new_buffersize(PyFileObject *f, size_t currentsize) { #ifdef HAVE_FSTAT - off_t pos, end; - struct stat st; - if (fstat(fileno(f->f_fp), &st) == 0) { - end = st.st_size; - /* The following is not a bug: we really need to call lseek() - *and* ftell(). The reason is that some stdio libraries - mistakenly flush their buffer when ftell() is called and - the lseek() call it makes fails, thereby throwing away - data that cannot be recovered in any way. To avoid this, - we first test lseek(), and only call ftell() if lseek() - works. We can't use the lseek() value either, because we - need to take the amount of buffered data into account. - (Yet another reason why stdio stinks. :-) */ - pos = lseek(fileno(f->f_fp), 0L, SEEK_CUR); - if (pos >= 0) { - pos = ftell(f->f_fp); - } - if (pos < 0) - clearerr(f->f_fp); - if (end > pos && pos >= 0) - return currentsize + end - pos + 1; - /* Add 1 so if the file were to grow we'd notice. */ - } + off_t pos, end; + struct stat st; + if (fstat(fileno(f->f_fp), &st) == 0) { + end = st.st_size; + /* The following is not a bug: we really need to call lseek() + *and* ftell(). The reason is that some stdio libraries + mistakenly flush their buffer when ftell() is called and + the lseek() call it makes fails, thereby throwing away + data that cannot be recovered in any way. To avoid this, + we first test lseek(), and only call ftell() if lseek() + works. We can't use the lseek() value either, because we + need to take the amount of buffered data into account. + (Yet another reason why stdio stinks. :-) */ + pos = lseek(fileno(f->f_fp), 0L, SEEK_CUR); + if (pos >= 0) { + pos = ftell(f->f_fp); + } + if (pos < 0) + clearerr(f->f_fp); + if (end > pos && pos >= 0) + return currentsize + end - pos + 1; + /* Add 1 so if the file were to grow we'd notice. */ + } #endif - if (currentsize > SMALLCHUNK) { - /* Keep doubling until we reach BIGCHUNK; - then keep adding BIGCHUNK. */ - if (currentsize <= BIGCHUNK) - return currentsize + currentsize; - else - return currentsize + BIGCHUNK; - } - return currentsize + SMALLCHUNK; + if (currentsize > SMALLCHUNK) { + /* Keep doubling until we reach BIGCHUNK; + then keep adding BIGCHUNK. */ + if (currentsize <= BIGCHUNK) + return currentsize + currentsize; + else + return currentsize + BIGCHUNK; + } + return currentsize + SMALLCHUNK; } #if defined(EWOULDBLOCK) && defined(EAGAIN) && EWOULDBLOCK != EAGAIN @@ -1040,114 +1040,114 @@ new_buffersize(PyFileObject *f, size_t currentsize) static PyObject * file_read(PyFileObject *f, PyObject *args) { - long bytesrequested = -1; - size_t bytesread, buffersize, chunksize; - PyObject *v; - - if (f->f_fp == NULL) - return err_closed(); - if (!f->readable) - return err_mode("reading"); - /* refuse to mix with f.next() */ - if (f->f_buf != NULL && - (f->f_bufend - f->f_bufptr) > 0 && - f->f_buf[0] != '\0') - return err_iterbuffered(); - if (!PyArg_ParseTuple(args, "|l:read", &bytesrequested)) - return NULL; - if (bytesrequested < 0) - buffersize = new_buffersize(f, (size_t)0); - else - buffersize = bytesrequested; - if (buffersize > PY_SSIZE_T_MAX) { - PyErr_SetString(PyExc_OverflowError, - "requested number of bytes is more than a Python string can hold"); - return NULL; - } - v = PyString_FromStringAndSize((char *)NULL, buffersize); - if (v == NULL) - return NULL; - bytesread = 0; - for (;;) { - FILE_BEGIN_ALLOW_THREADS(f) - errno = 0; - chunksize = Py_UniversalNewlineFread(BUF(v) + bytesread, - buffersize - bytesread, f->f_fp, (PyObject *)f); - FILE_END_ALLOW_THREADS(f) - if (chunksize == 0) { - if (!ferror(f->f_fp)) - break; - clearerr(f->f_fp); - /* When in non-blocking mode, data shouldn't - * be discarded if a blocking signal was - * received. That will also happen if - * chunksize != 0, but bytesread < buffersize. */ - if (bytesread > 0 && BLOCKED_ERRNO(errno)) - break; - PyErr_SetFromErrno(PyExc_IOError); - Py_DECREF(v); - return NULL; - } - bytesread += chunksize; - if (bytesread < buffersize) { - clearerr(f->f_fp); - break; - } - if (bytesrequested < 0) { - buffersize = new_buffersize(f, buffersize); - if (_PyString_Resize(&v, buffersize) < 0) - return NULL; - } else { - /* Got what was requested. */ - break; - } - } - if (bytesread != buffersize && _PyString_Resize(&v, bytesread)) - return NULL; - return v; + long bytesrequested = -1; + size_t bytesread, buffersize, chunksize; + PyObject *v; + + if (f->f_fp == NULL) + return err_closed(); + if (!f->readable) + return err_mode("reading"); + /* refuse to mix with f.next() */ + if (f->f_buf != NULL && + (f->f_bufend - f->f_bufptr) > 0 && + f->f_buf[0] != '\0') + return err_iterbuffered(); + if (!PyArg_ParseTuple(args, "|l:read", &bytesrequested)) + return NULL; + if (bytesrequested < 0) + buffersize = new_buffersize(f, (size_t)0); + else + buffersize = bytesrequested; + if (buffersize > PY_SSIZE_T_MAX) { + PyErr_SetString(PyExc_OverflowError, + "requested number of bytes is more than a Python string can hold"); + return NULL; + } + v = PyString_FromStringAndSize((char *)NULL, buffersize); + if (v == NULL) + return NULL; + bytesread = 0; + for (;;) { + FILE_BEGIN_ALLOW_THREADS(f) + errno = 0; + chunksize = Py_UniversalNewlineFread(BUF(v) + bytesread, + buffersize - bytesread, f->f_fp, (PyObject *)f); + FILE_END_ALLOW_THREADS(f) + if (chunksize == 0) { + if (!ferror(f->f_fp)) + break; + clearerr(f->f_fp); + /* When in non-blocking mode, data shouldn't + * be discarded if a blocking signal was + * received. That will also happen if + * chunksize != 0, but bytesread < buffersize. */ + if (bytesread > 0 && BLOCKED_ERRNO(errno)) + break; + PyErr_SetFromErrno(PyExc_IOError); + Py_DECREF(v); + return NULL; + } + bytesread += chunksize; + if (bytesread < buffersize) { + clearerr(f->f_fp); + break; + } + if (bytesrequested < 0) { + buffersize = new_buffersize(f, buffersize); + if (_PyString_Resize(&v, buffersize) < 0) + return NULL; + } else { + /* Got what was requested. */ + break; + } + } + if (bytesread != buffersize && _PyString_Resize(&v, bytesread)) + return NULL; + return v; } static PyObject * file_readinto(PyFileObject *f, PyObject *args) { - char *ptr; - Py_ssize_t ntodo; - Py_ssize_t ndone, nnow; - Py_buffer pbuf; - - if (f->f_fp == NULL) - return err_closed(); - if (!f->readable) - return err_mode("reading"); - /* refuse to mix with f.next() */ - if (f->f_buf != NULL && - (f->f_bufend - f->f_bufptr) > 0 && - f->f_buf[0] != '\0') - return err_iterbuffered(); - if (!PyArg_ParseTuple(args, "w*", &pbuf)) - return NULL; - ptr = pbuf.buf; - ntodo = pbuf.len; - ndone = 0; - while (ntodo > 0) { - FILE_BEGIN_ALLOW_THREADS(f) - errno = 0; - nnow = Py_UniversalNewlineFread(ptr+ndone, ntodo, f->f_fp, - (PyObject *)f); - FILE_END_ALLOW_THREADS(f) - if (nnow == 0) { - if (!ferror(f->f_fp)) - break; - PyErr_SetFromErrno(PyExc_IOError); - clearerr(f->f_fp); - PyBuffer_Release(&pbuf); - return NULL; - } - ndone += nnow; - ntodo -= nnow; - } - PyBuffer_Release(&pbuf); - return PyInt_FromSsize_t(ndone); + char *ptr; + Py_ssize_t ntodo; + Py_ssize_t ndone, nnow; + Py_buffer pbuf; + + if (f->f_fp == NULL) + return err_closed(); + if (!f->readable) + return err_mode("reading"); + /* refuse to mix with f.next() */ + if (f->f_buf != NULL && + (f->f_bufend - f->f_bufptr) > 0 && + f->f_buf[0] != '\0') + return err_iterbuffered(); + if (!PyArg_ParseTuple(args, "w*", &pbuf)) + return NULL; + ptr = pbuf.buf; + ntodo = pbuf.len; + ndone = 0; + while (ntodo > 0) { + FILE_BEGIN_ALLOW_THREADS(f) + errno = 0; + nnow = Py_UniversalNewlineFread(ptr+ndone, ntodo, f->f_fp, + (PyObject *)f); + FILE_END_ALLOW_THREADS(f) + if (nnow == 0) { + if (!ferror(f->f_fp)) + break; + PyErr_SetFromErrno(PyExc_IOError); + clearerr(f->f_fp); + PyBuffer_Release(&pbuf); + return NULL; + } + ndone += nnow; + ntodo -= nnow; + } + PyBuffer_Release(&pbuf); + return PyInt_FromSsize_t(ndone); } /************************************************************************** @@ -1169,9 +1169,9 @@ MS realloc is also slow. Reports from other platforms on this method vs getc_unlocked (which MS doesn't have): - Linux a wash - Solaris a wash - Tru64 Unix getline_via_fgets significantly faster + Linux a wash + Solaris a wash + Tru64 Unix getline_via_fgets significantly faster CAUTION: The C std isn't clear about this: in those cases where fgets writes something into the buffer, can it write into any position beyond the @@ -1218,151 +1218,151 @@ getline_via_fgets(PyFileObject *f, FILE *fp) */ #define INITBUFSIZE 100 #define MAXBUFSIZE 300 - char* p; /* temp */ - char buf[MAXBUFSIZE]; - PyObject* v; /* the string object result */ - char* pvfree; /* address of next free slot */ - char* pvend; /* address one beyond last free slot */ - size_t nfree; /* # of free buffer slots; pvend-pvfree */ - size_t total_v_size; /* total # of slots in buffer */ - size_t increment; /* amount to increment the buffer */ - size_t prev_v_size; - - /* Optimize for normal case: avoid _PyString_Resize if at all - * possible via first reading into stack buffer "buf". - */ - total_v_size = INITBUFSIZE; /* start small and pray */ - pvfree = buf; - for (;;) { - FILE_BEGIN_ALLOW_THREADS(f) - pvend = buf + total_v_size; - nfree = pvend - pvfree; - memset(pvfree, '\n', nfree); - assert(nfree < INT_MAX); /* Should be atmost MAXBUFSIZE */ - p = fgets(pvfree, (int)nfree, fp); - FILE_END_ALLOW_THREADS(f) - - if (p == NULL) { - clearerr(fp); - if (PyErr_CheckSignals()) - return NULL; - v = PyString_FromStringAndSize(buf, pvfree - buf); - return v; - } - /* fgets read *something* */ - p = memchr(pvfree, '\n', nfree); - if (p != NULL) { - /* Did the \n come from fgets or from us? - * Since fgets stops at the first \n, and then writes - * \0, if it's from fgets a \0 must be next. But if - * that's so, it could not have come from us, since - * the \n's we filled the buffer with have only more - * \n's to the right. - */ - if (p+1 < pvend && *(p+1) == '\0') { - /* It's from fgets: we win! In particular, - * we haven't done any mallocs yet, and can - * build the final result on the first try. - */ - ++p; /* include \n from fgets */ - } - else { - /* Must be from us: fgets didn't fill the - * buffer and didn't find a newline, so it - * must be the last and newline-free line of - * the file. - */ - assert(p > pvfree && *(p-1) == '\0'); - --p; /* don't include \0 from fgets */ - } - v = PyString_FromStringAndSize(buf, p - buf); - return v; - } - /* yuck: fgets overwrote all the newlines, i.e. the entire - * buffer. So this line isn't over yet, or maybe it is but - * we're exactly at EOF. If we haven't already, try using the - * rest of the stack buffer. - */ - assert(*(pvend-1) == '\0'); - if (pvfree == buf) { - pvfree = pvend - 1; /* overwrite trailing null */ - total_v_size = MAXBUFSIZE; - } - else - break; - } - - /* The stack buffer isn't big enough; malloc a string object and read - * into its buffer. - */ - total_v_size = MAXBUFSIZE << 1; - v = PyString_FromStringAndSize((char*)NULL, (int)total_v_size); - if (v == NULL) - return v; - /* copy over everything except the last null byte */ - memcpy(BUF(v), buf, MAXBUFSIZE-1); - pvfree = BUF(v) + MAXBUFSIZE - 1; - - /* Keep reading stuff into v; if it ever ends successfully, break - * after setting p one beyond the end of the line. The code here is - * very much like the code above, except reads into v's buffer; see - * the code above for detailed comments about the logic. - */ - for (;;) { - FILE_BEGIN_ALLOW_THREADS(f) - pvend = BUF(v) + total_v_size; - nfree = pvend - pvfree; - memset(pvfree, '\n', nfree); - assert(nfree < INT_MAX); - p = fgets(pvfree, (int)nfree, fp); - FILE_END_ALLOW_THREADS(f) - - if (p == NULL) { - clearerr(fp); - if (PyErr_CheckSignals()) { - Py_DECREF(v); - return NULL; - } - p = pvfree; - break; - } - p = memchr(pvfree, '\n', nfree); - if (p != NULL) { - if (p+1 < pvend && *(p+1) == '\0') { - /* \n came from fgets */ - ++p; - break; - } - /* \n came from us; last line of file, no newline */ - assert(p > pvfree && *(p-1) == '\0'); - --p; - break; - } - /* expand buffer and try again */ - assert(*(pvend-1) == '\0'); - increment = total_v_size >> 2; /* mild exponential growth */ - prev_v_size = total_v_size; - total_v_size += increment; - /* check for overflow */ - if (total_v_size <= prev_v_size || - total_v_size > PY_SSIZE_T_MAX) { - PyErr_SetString(PyExc_OverflowError, - "line is longer than a Python string can hold"); - Py_DECREF(v); - return NULL; - } - if (_PyString_Resize(&v, (int)total_v_size) < 0) - return NULL; - /* overwrite the trailing null byte */ - pvfree = BUF(v) + (prev_v_size - 1); - } - if (BUF(v) + total_v_size != p && _PyString_Resize(&v, p - BUF(v))) - return NULL; - return v; + char* p; /* temp */ + char buf[MAXBUFSIZE]; + PyObject* v; /* the string object result */ + char* pvfree; /* address of next free slot */ + char* pvend; /* address one beyond last free slot */ + size_t nfree; /* # of free buffer slots; pvend-pvfree */ + size_t total_v_size; /* total # of slots in buffer */ + size_t increment; /* amount to increment the buffer */ + size_t prev_v_size; + + /* Optimize for normal case: avoid _PyString_Resize if at all + * possible via first reading into stack buffer "buf". + */ + total_v_size = INITBUFSIZE; /* start small and pray */ + pvfree = buf; + for (;;) { + FILE_BEGIN_ALLOW_THREADS(f) + pvend = buf + total_v_size; + nfree = pvend - pvfree; + memset(pvfree, '\n', nfree); + assert(nfree < INT_MAX); /* Should be atmost MAXBUFSIZE */ + p = fgets(pvfree, (int)nfree, fp); + FILE_END_ALLOW_THREADS(f) + + if (p == NULL) { + clearerr(fp); + if (PyErr_CheckSignals()) + return NULL; + v = PyString_FromStringAndSize(buf, pvfree - buf); + return v; + } + /* fgets read *something* */ + p = memchr(pvfree, '\n', nfree); + if (p != NULL) { + /* Did the \n come from fgets or from us? + * Since fgets stops at the first \n, and then writes + * \0, if it's from fgets a \0 must be next. But if + * that's so, it could not have come from us, since + * the \n's we filled the buffer with have only more + * \n's to the right. + */ + if (p+1 < pvend && *(p+1) == '\0') { + /* It's from fgets: we win! In particular, + * we haven't done any mallocs yet, and can + * build the final result on the first try. + */ + ++p; /* include \n from fgets */ + } + else { + /* Must be from us: fgets didn't fill the + * buffer and didn't find a newline, so it + * must be the last and newline-free line of + * the file. + */ + assert(p > pvfree && *(p-1) == '\0'); + --p; /* don't include \0 from fgets */ + } + v = PyString_FromStringAndSize(buf, p - buf); + return v; + } + /* yuck: fgets overwrote all the newlines, i.e. the entire + * buffer. So this line isn't over yet, or maybe it is but + * we're exactly at EOF. If we haven't already, try using the + * rest of the stack buffer. + */ + assert(*(pvend-1) == '\0'); + if (pvfree == buf) { + pvfree = pvend - 1; /* overwrite trailing null */ + total_v_size = MAXBUFSIZE; + } + else + break; + } + + /* The stack buffer isn't big enough; malloc a string object and read + * into its buffer. + */ + total_v_size = MAXBUFSIZE << 1; + v = PyString_FromStringAndSize((char*)NULL, (int)total_v_size); + if (v == NULL) + return v; + /* copy over everything except the last null byte */ + memcpy(BUF(v), buf, MAXBUFSIZE-1); + pvfree = BUF(v) + MAXBUFSIZE - 1; + + /* Keep reading stuff into v; if it ever ends successfully, break + * after setting p one beyond the end of the line. The code here is + * very much like the code above, except reads into v's buffer; see + * the code above for detailed comments about the logic. + */ + for (;;) { + FILE_BEGIN_ALLOW_THREADS(f) + pvend = BUF(v) + total_v_size; + nfree = pvend - pvfree; + memset(pvfree, '\n', nfree); + assert(nfree < INT_MAX); + p = fgets(pvfree, (int)nfree, fp); + FILE_END_ALLOW_THREADS(f) + + if (p == NULL) { + clearerr(fp); + if (PyErr_CheckSignals()) { + Py_DECREF(v); + return NULL; + } + p = pvfree; + break; + } + p = memchr(pvfree, '\n', nfree); + if (p != NULL) { + if (p+1 < pvend && *(p+1) == '\0') { + /* \n came from fgets */ + ++p; + break; + } + /* \n came from us; last line of file, no newline */ + assert(p > pvfree && *(p-1) == '\0'); + --p; + break; + } + /* expand buffer and try again */ + assert(*(pvend-1) == '\0'); + increment = total_v_size >> 2; /* mild exponential growth */ + prev_v_size = total_v_size; + total_v_size += increment; + /* check for overflow */ + if (total_v_size <= prev_v_size || + total_v_size > PY_SSIZE_T_MAX) { + PyErr_SetString(PyExc_OverflowError, + "line is longer than a Python string can hold"); + Py_DECREF(v); + return NULL; + } + if (_PyString_Resize(&v, (int)total_v_size) < 0) + return NULL; + /* overwrite the trailing null byte */ + pvfree = BUF(v) + (prev_v_size - 1); + } + if (BUF(v) + total_v_size != p && _PyString_Resize(&v, p - BUF(v))) + return NULL; + return v; #undef INITBUFSIZE #undef MAXBUFSIZE } -#endif /* ifdef USE_FGETS_IN_GETLINE */ +#endif /* ifdef USE_FGETS_IN_GETLINE */ /* Internal routine to get a line. Size argument interpretation: @@ -1373,105 +1373,105 @@ getline_via_fgets(PyFileObject *f, FILE *fp) static PyObject * get_line(PyFileObject *f, int n) { - FILE *fp = f->f_fp; - int c; - char *buf, *end; - size_t total_v_size; /* total # of slots in buffer */ - size_t used_v_size; /* # used slots in buffer */ - size_t increment; /* amount to increment the buffer */ - PyObject *v; - int newlinetypes = f->f_newlinetypes; - int skipnextlf = f->f_skipnextlf; - int univ_newline = f->f_univ_newline; + FILE *fp = f->f_fp; + int c; + char *buf, *end; + size_t total_v_size; /* total # of slots in buffer */ + size_t used_v_size; /* # used slots in buffer */ + size_t increment; /* amount to increment the buffer */ + PyObject *v; + int newlinetypes = f->f_newlinetypes; + int skipnextlf = f->f_skipnextlf; + int univ_newline = f->f_univ_newline; #if defined(USE_FGETS_IN_GETLINE) - if (n <= 0 && !univ_newline ) - return getline_via_fgets(f, fp); + if (n <= 0 && !univ_newline ) + return getline_via_fgets(f, fp); #endif - total_v_size = n > 0 ? n : 100; - v = PyString_FromStringAndSize((char *)NULL, total_v_size); - if (v == NULL) - return NULL; - buf = BUF(v); - end = buf + total_v_size; - - for (;;) { - FILE_BEGIN_ALLOW_THREADS(f) - FLOCKFILE(fp); - if (univ_newline) { - c = 'x'; /* Shut up gcc warning */ - while ( buf != end && (c = GETC(fp)) != EOF ) { - if (skipnextlf ) { - skipnextlf = 0; - if (c == '\n') { - /* Seeing a \n here with - * skipnextlf true means we - * saw a \r before. - */ - newlinetypes |= NEWLINE_CRLF; - c = GETC(fp); - if (c == EOF) break; - } else { - newlinetypes |= NEWLINE_CR; - } - } - if (c == '\r') { - skipnextlf = 1; - c = '\n'; - } else if ( c == '\n') - newlinetypes |= NEWLINE_LF; - *buf++ = c; - if (c == '\n') break; - } - if ( c == EOF && skipnextlf ) - newlinetypes |= NEWLINE_CR; - } else /* If not universal newlines use the normal loop */ - while ((c = GETC(fp)) != EOF && - (*buf++ = c) != '\n' && - buf != end) - ; - FUNLOCKFILE(fp); - FILE_END_ALLOW_THREADS(f) - f->f_newlinetypes = newlinetypes; - f->f_skipnextlf = skipnextlf; - if (c == '\n') - break; - if (c == EOF) { - if (ferror(fp)) { - PyErr_SetFromErrno(PyExc_IOError); - clearerr(fp); - Py_DECREF(v); - return NULL; - } - clearerr(fp); - if (PyErr_CheckSignals()) { - Py_DECREF(v); - return NULL; - } - break; - } - /* Must be because buf == end */ - if (n > 0) - break; - used_v_size = total_v_size; - increment = total_v_size >> 2; /* mild exponential growth */ - total_v_size += increment; - if (total_v_size > PY_SSIZE_T_MAX) { - PyErr_SetString(PyExc_OverflowError, - "line is longer than a Python string can hold"); - Py_DECREF(v); - return NULL; - } - if (_PyString_Resize(&v, total_v_size) < 0) - return NULL; - buf = BUF(v) + used_v_size; - end = BUF(v) + total_v_size; - } - - used_v_size = buf - BUF(v); - if (used_v_size != total_v_size && _PyString_Resize(&v, used_v_size)) - return NULL; - return v; + total_v_size = n > 0 ? n : 100; + v = PyString_FromStringAndSize((char *)NULL, total_v_size); + if (v == NULL) + return NULL; + buf = BUF(v); + end = buf + total_v_size; + + for (;;) { + FILE_BEGIN_ALLOW_THREADS(f) + FLOCKFILE(fp); + if (univ_newline) { + c = 'x'; /* Shut up gcc warning */ + while ( buf != end && (c = GETC(fp)) != EOF ) { + if (skipnextlf ) { + skipnextlf = 0; + if (c == '\n') { + /* Seeing a \n here with + * skipnextlf true means we + * saw a \r before. + */ + newlinetypes |= NEWLINE_CRLF; + c = GETC(fp); + if (c == EOF) break; + } else { + newlinetypes |= NEWLINE_CR; + } + } + if (c == '\r') { + skipnextlf = 1; + c = '\n'; + } else if ( c == '\n') + newlinetypes |= NEWLINE_LF; + *buf++ = c; + if (c == '\n') break; + } + if ( c == EOF && skipnextlf ) + newlinetypes |= NEWLINE_CR; + } else /* If not universal newlines use the normal loop */ + while ((c = GETC(fp)) != EOF && + (*buf++ = c) != '\n' && + buf != end) + ; + FUNLOCKFILE(fp); + FILE_END_ALLOW_THREADS(f) + f->f_newlinetypes = newlinetypes; + f->f_skipnextlf = skipnextlf; + if (c == '\n') + break; + if (c == EOF) { + if (ferror(fp)) { + PyErr_SetFromErrno(PyExc_IOError); + clearerr(fp); + Py_DECREF(v); + return NULL; + } + clearerr(fp); + if (PyErr_CheckSignals()) { + Py_DECREF(v); + return NULL; + } + break; + } + /* Must be because buf == end */ + if (n > 0) + break; + used_v_size = total_v_size; + increment = total_v_size >> 2; /* mild exponential growth */ + total_v_size += increment; + if (total_v_size > PY_SSIZE_T_MAX) { + PyErr_SetString(PyExc_OverflowError, + "line is longer than a Python string can hold"); + Py_DECREF(v); + return NULL; + } + if (_PyString_Resize(&v, total_v_size) < 0) + return NULL; + buf = BUF(v) + used_v_size; + end = BUF(v) + total_v_size; + } + + used_v_size = buf - BUF(v); + if (used_v_size != total_v_size && _PyString_Resize(&v, used_v_size)) + return NULL; + return v; } /* External C interface */ @@ -1479,98 +1479,98 @@ get_line(PyFileObject *f, int n) PyObject * PyFile_GetLine(PyObject *f, int n) { - PyObject *result; - - if (f == NULL) { - PyErr_BadInternalCall(); - return NULL; - } - - if (PyFile_Check(f)) { - PyFileObject *fo = (PyFileObject *)f; - if (fo->f_fp == NULL) - return err_closed(); - if (!fo->readable) - return err_mode("reading"); - /* refuse to mix with f.next() */ - if (fo->f_buf != NULL && - (fo->f_bufend - fo->f_bufptr) > 0 && - fo->f_buf[0] != '\0') - return err_iterbuffered(); - result = get_line(fo, n); - } - else { - PyObject *reader; - PyObject *args; - - reader = PyObject_GetAttrString(f, "readline"); - if (reader == NULL) - return NULL; - if (n <= 0) - args = PyTuple_New(0); - else - args = Py_BuildValue("(i)", n); - if (args == NULL) { - Py_DECREF(reader); - return NULL; - } - result = PyEval_CallObject(reader, args); - Py_DECREF(reader); - Py_DECREF(args); - if (result != NULL && !PyString_Check(result) && - !PyUnicode_Check(result)) { - Py_DECREF(result); - result = NULL; - PyErr_SetString(PyExc_TypeError, - "object.readline() returned non-string"); - } - } - - if (n < 0 && result != NULL && PyString_Check(result)) { - char *s = PyString_AS_STRING(result); - Py_ssize_t len = PyString_GET_SIZE(result); - if (len == 0) { - Py_DECREF(result); - result = NULL; - PyErr_SetString(PyExc_EOFError, - "EOF when reading a line"); - } - else if (s[len-1] == '\n') { - if (result->ob_refcnt == 1) { - if (_PyString_Resize(&result, len-1)) - return NULL; - } - else { - PyObject *v; - v = PyString_FromStringAndSize(s, len-1); - Py_DECREF(result); - result = v; - } - } - } + PyObject *result; + + if (f == NULL) { + PyErr_BadInternalCall(); + return NULL; + } + + if (PyFile_Check(f)) { + PyFileObject *fo = (PyFileObject *)f; + if (fo->f_fp == NULL) + return err_closed(); + if (!fo->readable) + return err_mode("reading"); + /* refuse to mix with f.next() */ + if (fo->f_buf != NULL && + (fo->f_bufend - fo->f_bufptr) > 0 && + fo->f_buf[0] != '\0') + return err_iterbuffered(); + result = get_line(fo, n); + } + else { + PyObject *reader; + PyObject *args; + + reader = PyObject_GetAttrString(f, "readline"); + if (reader == NULL) + return NULL; + if (n <= 0) + args = PyTuple_New(0); + else + args = Py_BuildValue("(i)", n); + if (args == NULL) { + Py_DECREF(reader); + return NULL; + } + result = PyEval_CallObject(reader, args); + Py_DECREF(reader); + Py_DECREF(args); + if (result != NULL && !PyString_Check(result) && + !PyUnicode_Check(result)) { + Py_DECREF(result); + result = NULL; + PyErr_SetString(PyExc_TypeError, + "object.readline() returned non-string"); + } + } + + if (n < 0 && result != NULL && PyString_Check(result)) { + char *s = PyString_AS_STRING(result); + Py_ssize_t len = PyString_GET_SIZE(result); + if (len == 0) { + Py_DECREF(result); + result = NULL; + PyErr_SetString(PyExc_EOFError, + "EOF when reading a line"); + } + else if (s[len-1] == '\n') { + if (result->ob_refcnt == 1) { + if (_PyString_Resize(&result, len-1)) + return NULL; + } + else { + PyObject *v; + v = PyString_FromStringAndSize(s, len-1); + Py_DECREF(result); + result = v; + } + } + } #ifdef Py_USING_UNICODE - if (n < 0 && result != NULL && PyUnicode_Check(result)) { - Py_UNICODE *s = PyUnicode_AS_UNICODE(result); - Py_ssize_t len = PyUnicode_GET_SIZE(result); - if (len == 0) { - Py_DECREF(result); - result = NULL; - PyErr_SetString(PyExc_EOFError, - "EOF when reading a line"); - } - else if (s[len-1] == '\n') { - if (result->ob_refcnt == 1) - PyUnicode_Resize(&result, len-1); - else { - PyObject *v; - v = PyUnicode_FromUnicode(s, len-1); - Py_DECREF(result); - result = v; - } - } - } + if (n < 0 && result != NULL && PyUnicode_Check(result)) { + Py_UNICODE *s = PyUnicode_AS_UNICODE(result); + Py_ssize_t len = PyUnicode_GET_SIZE(result); + if (len == 0) { + Py_DECREF(result); + result = NULL; + PyErr_SetString(PyExc_EOFError, + "EOF when reading a line"); + } + else if (s[len-1] == '\n') { + if (result->ob_refcnt == 1) + PyUnicode_Resize(&result, len-1); + else { + PyObject *v; + v = PyUnicode_FromUnicode(s, len-1); + Py_DECREF(result); + result = v; + } + } + } #endif - return result; + return result; } /* Python method */ @@ -1578,341 +1578,341 @@ PyFile_GetLine(PyObject *f, int n) static PyObject * file_readline(PyFileObject *f, PyObject *args) { - int n = -1; - - if (f->f_fp == NULL) - return err_closed(); - if (!f->readable) - return err_mode("reading"); - /* refuse to mix with f.next() */ - if (f->f_buf != NULL && - (f->f_bufend - f->f_bufptr) > 0 && - f->f_buf[0] != '\0') - return err_iterbuffered(); - if (!PyArg_ParseTuple(args, "|i:readline", &n)) - return NULL; - if (n == 0) - return PyString_FromString(""); - if (n < 0) - n = 0; - return get_line(f, n); + int n = -1; + + if (f->f_fp == NULL) + return err_closed(); + if (!f->readable) + return err_mode("reading"); + /* refuse to mix with f.next() */ + if (f->f_buf != NULL && + (f->f_bufend - f->f_bufptr) > 0 && + f->f_buf[0] != '\0') + return err_iterbuffered(); + if (!PyArg_ParseTuple(args, "|i:readline", &n)) + return NULL; + if (n == 0) + return PyString_FromString(""); + if (n < 0) + n = 0; + return get_line(f, n); } static PyObject * file_readlines(PyFileObject *f, PyObject *args) { - long sizehint = 0; - PyObject *list = NULL; - PyObject *line; - char small_buffer[SMALLCHUNK]; - char *buffer = small_buffer; - size_t buffersize = SMALLCHUNK; - PyObject *big_buffer = NULL; - size_t nfilled = 0; - size_t nread; - size_t totalread = 0; - char *p, *q, *end; - int err; - int shortread = 0; - - if (f->f_fp == NULL) - return err_closed(); - if (!f->readable) - return err_mode("reading"); - /* refuse to mix with f.next() */ - if (f->f_buf != NULL && - (f->f_bufend - f->f_bufptr) > 0 && - f->f_buf[0] != '\0') - return err_iterbuffered(); - if (!PyArg_ParseTuple(args, "|l:readlines", &sizehint)) - return NULL; - if ((list = PyList_New(0)) == NULL) - return NULL; - for (;;) { - if (shortread) - nread = 0; - else { - FILE_BEGIN_ALLOW_THREADS(f) - errno = 0; - nread = Py_UniversalNewlineFread(buffer+nfilled, - buffersize-nfilled, f->f_fp, (PyObject *)f); - FILE_END_ALLOW_THREADS(f) - shortread = (nread < buffersize-nfilled); - } - if (nread == 0) { - sizehint = 0; - if (!ferror(f->f_fp)) - break; - PyErr_SetFromErrno(PyExc_IOError); - clearerr(f->f_fp); - goto error; - } - totalread += nread; - p = (char *)memchr(buffer+nfilled, '\n', nread); - if (p == NULL) { - /* Need a larger buffer to fit this line */ - nfilled += nread; - buffersize *= 2; - if (buffersize > PY_SSIZE_T_MAX) { - PyErr_SetString(PyExc_OverflowError, - "line is longer than a Python string can hold"); - goto error; - } - if (big_buffer == NULL) { - /* Create the big buffer */ - big_buffer = PyString_FromStringAndSize( - NULL, buffersize); - if (big_buffer == NULL) - goto error; - buffer = PyString_AS_STRING(big_buffer); - memcpy(buffer, small_buffer, nfilled); - } - else { - /* Grow the big buffer */ - if ( _PyString_Resize(&big_buffer, buffersize) < 0 ) - goto error; - buffer = PyString_AS_STRING(big_buffer); - } - continue; - } - end = buffer+nfilled+nread; - q = buffer; - do { - /* Process complete lines */ - p++; - line = PyString_FromStringAndSize(q, p-q); - if (line == NULL) - goto error; - err = PyList_Append(list, line); - Py_DECREF(line); - if (err != 0) - goto error; - q = p; - p = (char *)memchr(q, '\n', end-q); - } while (p != NULL); - /* Move the remaining incomplete line to the start */ - nfilled = end-q; - memmove(buffer, q, nfilled); - if (sizehint > 0) - if (totalread >= (size_t)sizehint) - break; - } - if (nfilled != 0) { - /* Partial last line */ - line = PyString_FromStringAndSize(buffer, nfilled); - if (line == NULL) - goto error; - if (sizehint > 0) { - /* Need to complete the last line */ - PyObject *rest = get_line(f, 0); - if (rest == NULL) { - Py_DECREF(line); - goto error; - } - PyString_Concat(&line, rest); - Py_DECREF(rest); - if (line == NULL) - goto error; - } - err = PyList_Append(list, line); - Py_DECREF(line); - if (err != 0) - goto error; - } + long sizehint = 0; + PyObject *list = NULL; + PyObject *line; + char small_buffer[SMALLCHUNK]; + char *buffer = small_buffer; + size_t buffersize = SMALLCHUNK; + PyObject *big_buffer = NULL; + size_t nfilled = 0; + size_t nread; + size_t totalread = 0; + char *p, *q, *end; + int err; + int shortread = 0; + + if (f->f_fp == NULL) + return err_closed(); + if (!f->readable) + return err_mode("reading"); + /* refuse to mix with f.next() */ + if (f->f_buf != NULL && + (f->f_bufend - f->f_bufptr) > 0 && + f->f_buf[0] != '\0') + return err_iterbuffered(); + if (!PyArg_ParseTuple(args, "|l:readlines", &sizehint)) + return NULL; + if ((list = PyList_New(0)) == NULL) + return NULL; + for (;;) { + if (shortread) + nread = 0; + else { + FILE_BEGIN_ALLOW_THREADS(f) + errno = 0; + nread = Py_UniversalNewlineFread(buffer+nfilled, + buffersize-nfilled, f->f_fp, (PyObject *)f); + FILE_END_ALLOW_THREADS(f) + shortread = (nread < buffersize-nfilled); + } + if (nread == 0) { + sizehint = 0; + if (!ferror(f->f_fp)) + break; + PyErr_SetFromErrno(PyExc_IOError); + clearerr(f->f_fp); + goto error; + } + totalread += nread; + p = (char *)memchr(buffer+nfilled, '\n', nread); + if (p == NULL) { + /* Need a larger buffer to fit this line */ + nfilled += nread; + buffersize *= 2; + if (buffersize > PY_SSIZE_T_MAX) { + PyErr_SetString(PyExc_OverflowError, + "line is longer than a Python string can hold"); + goto error; + } + if (big_buffer == NULL) { + /* Create the big buffer */ + big_buffer = PyString_FromStringAndSize( + NULL, buffersize); + if (big_buffer == NULL) + goto error; + buffer = PyString_AS_STRING(big_buffer); + memcpy(buffer, small_buffer, nfilled); + } + else { + /* Grow the big buffer */ + if ( _PyString_Resize(&big_buffer, buffersize) < 0 ) + goto error; + buffer = PyString_AS_STRING(big_buffer); + } + continue; + } + end = buffer+nfilled+nread; + q = buffer; + do { + /* Process complete lines */ + p++; + line = PyString_FromStringAndSize(q, p-q); + if (line == NULL) + goto error; + err = PyList_Append(list, line); + Py_DECREF(line); + if (err != 0) + goto error; + q = p; + p = (char *)memchr(q, '\n', end-q); + } while (p != NULL); + /* Move the remaining incomplete line to the start */ + nfilled = end-q; + memmove(buffer, q, nfilled); + if (sizehint > 0) + if (totalread >= (size_t)sizehint) + break; + } + if (nfilled != 0) { + /* Partial last line */ + line = PyString_FromStringAndSize(buffer, nfilled); + if (line == NULL) + goto error; + if (sizehint > 0) { + /* Need to complete the last line */ + PyObject *rest = get_line(f, 0); + if (rest == NULL) { + Py_DECREF(line); + goto error; + } + PyString_Concat(&line, rest); + Py_DECREF(rest); + if (line == NULL) + goto error; + } + err = PyList_Append(list, line); + Py_DECREF(line); + if (err != 0) + goto error; + } cleanup: - Py_XDECREF(big_buffer); - return list; + Py_XDECREF(big_buffer); + return list; error: - Py_CLEAR(list); - goto cleanup; + Py_CLEAR(list); + goto cleanup; } static PyObject * file_write(PyFileObject *f, PyObject *args) { - Py_buffer pbuf; - char *s; - Py_ssize_t n, n2; - if (f->f_fp == NULL) - return err_closed(); - if (!f->writable) - return err_mode("writing"); - if (f->f_binary) { - if (!PyArg_ParseTuple(args, "s*", &pbuf)) - return NULL; - s = pbuf.buf; - n = pbuf.len; - } else - if (!PyArg_ParseTuple(args, "t#", &s, &n)) - return NULL; - f->f_softspace = 0; - FILE_BEGIN_ALLOW_THREADS(f) - errno = 0; - n2 = fwrite(s, 1, n, f->f_fp); - FILE_END_ALLOW_THREADS(f) - if (f->f_binary) - PyBuffer_Release(&pbuf); - if (n2 != n) { - PyErr_SetFromErrno(PyExc_IOError); - clearerr(f->f_fp); - return NULL; - } - Py_INCREF(Py_None); - return Py_None; + Py_buffer pbuf; + char *s; + Py_ssize_t n, n2; + if (f->f_fp == NULL) + return err_closed(); + if (!f->writable) + return err_mode("writing"); + if (f->f_binary) { + if (!PyArg_ParseTuple(args, "s*", &pbuf)) + return NULL; + s = pbuf.buf; + n = pbuf.len; + } else + if (!PyArg_ParseTuple(args, "t#", &s, &n)) + return NULL; + f->f_softspace = 0; + FILE_BEGIN_ALLOW_THREADS(f) + errno = 0; + n2 = fwrite(s, 1, n, f->f_fp); + FILE_END_ALLOW_THREADS(f) + if (f->f_binary) + PyBuffer_Release(&pbuf); + if (n2 != n) { + PyErr_SetFromErrno(PyExc_IOError); + clearerr(f->f_fp); + return NULL; + } + Py_INCREF(Py_None); + return Py_None; } static PyObject * file_writelines(PyFileObject *f, PyObject *seq) { #define CHUNKSIZE 1000 - PyObject *list, *line; - PyObject *it; /* iter(seq) */ - PyObject *result; - int index, islist; - Py_ssize_t i, j, nwritten, len; - - assert(seq != NULL); - if (f->f_fp == NULL) - return err_closed(); - if (!f->writable) - return err_mode("writing"); - - result = NULL; - list = NULL; - islist = PyList_Check(seq); - if (islist) - it = NULL; - else { - it = PyObject_GetIter(seq); - if (it == NULL) { - PyErr_SetString(PyExc_TypeError, - "writelines() requires an iterable argument"); - return NULL; - } - /* From here on, fail by going to error, to reclaim "it". */ - list = PyList_New(CHUNKSIZE); - if (list == NULL) - goto error; - } - - /* Strategy: slurp CHUNKSIZE lines into a private list, - checking that they are all strings, then write that list - without holding the interpreter lock, then come back for more. */ - for (index = 0; ; index += CHUNKSIZE) { - if (islist) { - Py_XDECREF(list); - list = PyList_GetSlice(seq, index, index+CHUNKSIZE); - if (list == NULL) - goto error; - j = PyList_GET_SIZE(list); - } - else { - for (j = 0; j < CHUNKSIZE; j++) { - line = PyIter_Next(it); - if (line == NULL) { - if (PyErr_Occurred()) - goto error; - break; - } - PyList_SetItem(list, j, line); - } - } - if (j == 0) - break; - - /* Check that all entries are indeed strings. If not, - apply the same rules as for file.write() and - convert the results to strings. This is slow, but - seems to be the only way since all conversion APIs - could potentially execute Python code. */ - for (i = 0; i < j; i++) { - PyObject *v = PyList_GET_ITEM(list, i); - if (!PyString_Check(v)) { - const char *buffer; - if (((f->f_binary && - PyObject_AsReadBuffer(v, - (const void**)&buffer, - &len)) || - PyObject_AsCharBuffer(v, - &buffer, - &len))) { - PyErr_SetString(PyExc_TypeError, - "writelines() argument must be a sequence of strings"); - goto error; - } - line = PyString_FromStringAndSize(buffer, - len); - if (line == NULL) - goto error; - Py_DECREF(v); - PyList_SET_ITEM(list, i, line); - } - } - - /* Since we are releasing the global lock, the - following code may *not* execute Python code. */ - f->f_softspace = 0; - FILE_BEGIN_ALLOW_THREADS(f) - errno = 0; - for (i = 0; i < j; i++) { - line = PyList_GET_ITEM(list, i); - len = PyString_GET_SIZE(line); - nwritten = fwrite(PyString_AS_STRING(line), - 1, len, f->f_fp); - if (nwritten != len) { - FILE_ABORT_ALLOW_THREADS(f) - PyErr_SetFromErrno(PyExc_IOError); - clearerr(f->f_fp); - goto error; - } - } - FILE_END_ALLOW_THREADS(f) - - if (j < CHUNKSIZE) - break; - } - - Py_INCREF(Py_None); - result = Py_None; + PyObject *list, *line; + PyObject *it; /* iter(seq) */ + PyObject *result; + int index, islist; + Py_ssize_t i, j, nwritten, len; + + assert(seq != NULL); + if (f->f_fp == NULL) + return err_closed(); + if (!f->writable) + return err_mode("writing"); + + result = NULL; + list = NULL; + islist = PyList_Check(seq); + if (islist) + it = NULL; + else { + it = PyObject_GetIter(seq); + if (it == NULL) { + PyErr_SetString(PyExc_TypeError, + "writelines() requires an iterable argument"); + return NULL; + } + /* From here on, fail by going to error, to reclaim "it". */ + list = PyList_New(CHUNKSIZE); + if (list == NULL) + goto error; + } + + /* Strategy: slurp CHUNKSIZE lines into a private list, + checking that they are all strings, then write that list + without holding the interpreter lock, then come back for more. */ + for (index = 0; ; index += CHUNKSIZE) { + if (islist) { + Py_XDECREF(list); + list = PyList_GetSlice(seq, index, index+CHUNKSIZE); + if (list == NULL) + goto error; + j = PyList_GET_SIZE(list); + } + else { + for (j = 0; j < CHUNKSIZE; j++) { + line = PyIter_Next(it); + if (line == NULL) { + if (PyErr_Occurred()) + goto error; + break; + } + PyList_SetItem(list, j, line); + } + } + if (j == 0) + break; + + /* Check that all entries are indeed strings. If not, + apply the same rules as for file.write() and + convert the results to strings. This is slow, but + seems to be the only way since all conversion APIs + could potentially execute Python code. */ + for (i = 0; i < j; i++) { + PyObject *v = PyList_GET_ITEM(list, i); + if (!PyString_Check(v)) { + const char *buffer; + if (((f->f_binary && + PyObject_AsReadBuffer(v, + (const void**)&buffer, + &len)) || + PyObject_AsCharBuffer(v, + &buffer, + &len))) { + PyErr_SetString(PyExc_TypeError, + "writelines() argument must be a sequence of strings"); + goto error; + } + line = PyString_FromStringAndSize(buffer, + len); + if (line == NULL) + goto error; + Py_DECREF(v); + PyList_SET_ITEM(list, i, line); + } + } + + /* Since we are releasing the global lock, the + following code may *not* execute Python code. */ + f->f_softspace = 0; + FILE_BEGIN_ALLOW_THREADS(f) + errno = 0; + for (i = 0; i < j; i++) { + line = PyList_GET_ITEM(list, i); + len = PyString_GET_SIZE(line); + nwritten = fwrite(PyString_AS_STRING(line), + 1, len, f->f_fp); + if (nwritten != len) { + FILE_ABORT_ALLOW_THREADS(f) + PyErr_SetFromErrno(PyExc_IOError); + clearerr(f->f_fp); + goto error; + } + } + FILE_END_ALLOW_THREADS(f) + + if (j < CHUNKSIZE) + break; + } + + Py_INCREF(Py_None); + result = Py_None; error: - Py_XDECREF(list); - Py_XDECREF(it); - return result; + Py_XDECREF(list); + Py_XDECREF(it); + return result; #undef CHUNKSIZE } static PyObject * file_self(PyFileObject *f) { - if (f->f_fp == NULL) - return err_closed(); - Py_INCREF(f); - return (PyObject *)f; + if (f->f_fp == NULL) + return err_closed(); + Py_INCREF(f); + return (PyObject *)f; } static PyObject * file_xreadlines(PyFileObject *f) { - if (PyErr_WarnPy3k("f.xreadlines() not supported in 3.x, " - "try 'for line in f' instead", 1) < 0) - return NULL; - return file_self(f); + if (PyErr_WarnPy3k("f.xreadlines() not supported in 3.x, " + "try 'for line in f' instead", 1) < 0) + return NULL; + return file_self(f); } static PyObject * file_exit(PyObject *f, PyObject *args) { - PyObject *ret = PyObject_CallMethod(f, "close", NULL); - if (!ret) - /* If error occurred, pass through */ - return NULL; - Py_DECREF(ret); - /* We cannot return the result of close since a true - * value will be interpreted as "yes, swallow the - * exception if one was raised inside the with block". */ - Py_RETURN_NONE; + PyObject *ret = PyObject_CallMethod(f, "close", NULL); + if (!ret) + /* If error occurred, pass through */ + return NULL; + Py_DECREF(ret); + /* We cannot return the result of close since a true + * value will be interpreted as "yes, swallow the + * exception if one was raised inside the with block". */ + Py_RETURN_NONE; } PyDoc_STRVAR(readline_doc, @@ -2000,126 +2000,126 @@ PyDoc_STRVAR(isatty_doc, "isatty() -> true or false. True if the file is connected to a tty device."); PyDoc_STRVAR(enter_doc, - "__enter__() -> self."); + "__enter__() -> self."); PyDoc_STRVAR(exit_doc, - "__exit__(*excinfo) -> None. Closes the file."); + "__exit__(*excinfo) -> None. Closes the file."); static PyMethodDef file_methods[] = { - {"readline", (PyCFunction)file_readline, METH_VARARGS, readline_doc}, - {"read", (PyCFunction)file_read, METH_VARARGS, read_doc}, - {"write", (PyCFunction)file_write, METH_VARARGS, write_doc}, - {"fileno", (PyCFunction)file_fileno, METH_NOARGS, fileno_doc}, - {"seek", (PyCFunction)file_seek, METH_VARARGS, seek_doc}, + {"readline", (PyCFunction)file_readline, METH_VARARGS, readline_doc}, + {"read", (PyCFunction)file_read, METH_VARARGS, read_doc}, + {"write", (PyCFunction)file_write, METH_VARARGS, write_doc}, + {"fileno", (PyCFunction)file_fileno, METH_NOARGS, fileno_doc}, + {"seek", (PyCFunction)file_seek, METH_VARARGS, seek_doc}, #ifdef HAVE_FTRUNCATE - {"truncate", (PyCFunction)file_truncate, METH_VARARGS, truncate_doc}, + {"truncate", (PyCFunction)file_truncate, METH_VARARGS, truncate_doc}, #endif - {"tell", (PyCFunction)file_tell, METH_NOARGS, tell_doc}, - {"readinto", (PyCFunction)file_readinto, METH_VARARGS, readinto_doc}, - {"readlines", (PyCFunction)file_readlines, METH_VARARGS, readlines_doc}, - {"xreadlines",(PyCFunction)file_xreadlines, METH_NOARGS, xreadlines_doc}, - {"writelines",(PyCFunction)file_writelines, METH_O, writelines_doc}, - {"flush", (PyCFunction)file_flush, METH_NOARGS, flush_doc}, - {"close", (PyCFunction)file_close, METH_NOARGS, close_doc}, - {"isatty", (PyCFunction)file_isatty, METH_NOARGS, isatty_doc}, - {"__enter__", (PyCFunction)file_self, METH_NOARGS, enter_doc}, - {"__exit__", (PyCFunction)file_exit, METH_VARARGS, exit_doc}, - {NULL, NULL} /* sentinel */ + {"tell", (PyCFunction)file_tell, METH_NOARGS, tell_doc}, + {"readinto", (PyCFunction)file_readinto, METH_VARARGS, readinto_doc}, + {"readlines", (PyCFunction)file_readlines, METH_VARARGS, readlines_doc}, + {"xreadlines",(PyCFunction)file_xreadlines, METH_NOARGS, xreadlines_doc}, + {"writelines",(PyCFunction)file_writelines, METH_O, writelines_doc}, + {"flush", (PyCFunction)file_flush, METH_NOARGS, flush_doc}, + {"close", (PyCFunction)file_close, METH_NOARGS, close_doc}, + {"isatty", (PyCFunction)file_isatty, METH_NOARGS, isatty_doc}, + {"__enter__", (PyCFunction)file_self, METH_NOARGS, enter_doc}, + {"__exit__", (PyCFunction)file_exit, METH_VARARGS, exit_doc}, + {NULL, NULL} /* sentinel */ }; #define OFF(x) offsetof(PyFileObject, x) static PyMemberDef file_memberlist[] = { - {"mode", T_OBJECT, OFF(f_mode), RO, - "file mode ('r', 'U', 'w', 'a', possibly with 'b' or '+' added)"}, - {"name", T_OBJECT, OFF(f_name), RO, - "file name"}, - {"encoding", T_OBJECT, OFF(f_encoding), RO, - "file encoding"}, - {"errors", T_OBJECT, OFF(f_errors), RO, - "Unicode error handler"}, - /* getattr(f, "closed") is implemented without this table */ - {NULL} /* Sentinel */ + {"mode", T_OBJECT, OFF(f_mode), RO, + "file mode ('r', 'U', 'w', 'a', possibly with 'b' or '+' added)"}, + {"name", T_OBJECT, OFF(f_name), RO, + "file name"}, + {"encoding", T_OBJECT, OFF(f_encoding), RO, + "file encoding"}, + {"errors", T_OBJECT, OFF(f_errors), RO, + "Unicode error handler"}, + /* getattr(f, "closed") is implemented without this table */ + {NULL} /* Sentinel */ }; static PyObject * get_closed(PyFileObject *f, void *closure) { - return PyBool_FromLong((long)(f->f_fp == 0)); + return PyBool_FromLong((long)(f->f_fp == 0)); } static PyObject * get_newlines(PyFileObject *f, void *closure) { - switch (f->f_newlinetypes) { - case NEWLINE_UNKNOWN: - Py_INCREF(Py_None); - return Py_None; - case NEWLINE_CR: - return PyString_FromString("\r"); - case NEWLINE_LF: - return PyString_FromString("\n"); - case NEWLINE_CR|NEWLINE_LF: - return Py_BuildValue("(ss)", "\r", "\n"); - case NEWLINE_CRLF: - return PyString_FromString("\r\n"); - case NEWLINE_CR|NEWLINE_CRLF: - return Py_BuildValue("(ss)", "\r", "\r\n"); - case NEWLINE_LF|NEWLINE_CRLF: - return Py_BuildValue("(ss)", "\n", "\r\n"); - case NEWLINE_CR|NEWLINE_LF|NEWLINE_CRLF: - return Py_BuildValue("(sss)", "\r", "\n", "\r\n"); - default: - PyErr_Format(PyExc_SystemError, - "Unknown newlines value 0x%x\n", - f->f_newlinetypes); - return NULL; - } + switch (f->f_newlinetypes) { + case NEWLINE_UNKNOWN: + Py_INCREF(Py_None); + return Py_None; + case NEWLINE_CR: + return PyString_FromString("\r"); + case NEWLINE_LF: + return PyString_FromString("\n"); + case NEWLINE_CR|NEWLINE_LF: + return Py_BuildValue("(ss)", "\r", "\n"); + case NEWLINE_CRLF: + return PyString_FromString("\r\n"); + case NEWLINE_CR|NEWLINE_CRLF: + return Py_BuildValue("(ss)", "\r", "\r\n"); + case NEWLINE_LF|NEWLINE_CRLF: + return Py_BuildValue("(ss)", "\n", "\r\n"); + case NEWLINE_CR|NEWLINE_LF|NEWLINE_CRLF: + return Py_BuildValue("(sss)", "\r", "\n", "\r\n"); + default: + PyErr_Format(PyExc_SystemError, + "Unknown newlines value 0x%x\n", + f->f_newlinetypes); + return NULL; + } } static PyObject * get_softspace(PyFileObject *f, void *closure) { - if (PyErr_WarnPy3k("file.softspace not supported in 3.x", 1) < 0) - return NULL; - return PyInt_FromLong(f->f_softspace); + if (PyErr_WarnPy3k("file.softspace not supported in 3.x", 1) < 0) + return NULL; + return PyInt_FromLong(f->f_softspace); } static int set_softspace(PyFileObject *f, PyObject *value) { - int new; - if (PyErr_WarnPy3k("file.softspace not supported in 3.x", 1) < 0) - return -1; - - if (value == NULL) { - PyErr_SetString(PyExc_TypeError, - "can't delete softspace attribute"); - return -1; - } - - new = PyInt_AsLong(value); - if (new == -1 && PyErr_Occurred()) - return -1; - f->f_softspace = new; - return 0; + int new; + if (PyErr_WarnPy3k("file.softspace not supported in 3.x", 1) < 0) + return -1; + + if (value == NULL) { + PyErr_SetString(PyExc_TypeError, + "can't delete softspace attribute"); + return -1; + } + + new = PyInt_AsLong(value); + if (new == -1 && PyErr_Occurred()) + return -1; + f->f_softspace = new; + return 0; } static PyGetSetDef file_getsetlist[] = { - {"closed", (getter)get_closed, NULL, "True if the file is closed"}, - {"newlines", (getter)get_newlines, NULL, - "end-of-line convention used in this file"}, - {"softspace", (getter)get_softspace, (setter)set_softspace, - "flag indicating that a space needs to be printed; used by print"}, - {0}, + {"closed", (getter)get_closed, NULL, "True if the file is closed"}, + {"newlines", (getter)get_newlines, NULL, + "end-of-line convention used in this file"}, + {"softspace", (getter)get_softspace, (setter)set_softspace, + "flag indicating that a space needs to be printed; used by print"}, + {0}, }; static void drop_readahead(PyFileObject *f) { - if (f->f_buf != NULL) { - PyMem_Free(f->f_buf); - f->f_buf = NULL; - } + if (f->f_buf != NULL) { + PyMem_Free(f->f_buf); + f->f_buf = NULL; + } } /* Make sure that file has a readahead buffer with at least one byte @@ -2128,34 +2128,34 @@ drop_readahead(PyFileObject *f) static int readahead(PyFileObject *f, int bufsize) { - Py_ssize_t chunksize; - - if (f->f_buf != NULL) { - if( (f->f_bufend - f->f_bufptr) >= 1) - return 0; - else - drop_readahead(f); - } - if ((f->f_buf = (char *)PyMem_Malloc(bufsize)) == NULL) { - PyErr_NoMemory(); - return -1; - } - FILE_BEGIN_ALLOW_THREADS(f) - errno = 0; - chunksize = Py_UniversalNewlineFread( - f->f_buf, bufsize, f->f_fp, (PyObject *)f); - FILE_END_ALLOW_THREADS(f) - if (chunksize == 0) { - if (ferror(f->f_fp)) { - PyErr_SetFromErrno(PyExc_IOError); - clearerr(f->f_fp); - drop_readahead(f); - return -1; - } - } - f->f_bufptr = f->f_buf; - f->f_bufend = f->f_buf + chunksize; - return 0; + Py_ssize_t chunksize; + + if (f->f_buf != NULL) { + if( (f->f_bufend - f->f_bufptr) >= 1) + return 0; + else + drop_readahead(f); + } + if ((f->f_buf = (char *)PyMem_Malloc(bufsize)) == NULL) { + PyErr_NoMemory(); + return -1; + } + FILE_BEGIN_ALLOW_THREADS(f) + errno = 0; + chunksize = Py_UniversalNewlineFread( + f->f_buf, bufsize, f->f_fp, (PyObject *)f); + FILE_END_ALLOW_THREADS(f) + if (chunksize == 0) { + if (ferror(f->f_fp)) { + PyErr_SetFromErrno(PyExc_IOError); + clearerr(f->f_fp); + drop_readahead(f); + return -1; + } + } + f->f_bufptr = f->f_buf; + f->f_bufend = f->f_buf + chunksize; + return 0; } /* Used by file_iternext. The returned string will start with 'skip' @@ -2166,46 +2166,46 @@ readahead(PyFileObject *f, int bufsize) static PyStringObject * readahead_get_line_skip(PyFileObject *f, int skip, int bufsize) { - PyStringObject* s; - char *bufptr; - char *buf; - Py_ssize_t len; - - if (f->f_buf == NULL) - if (readahead(f, bufsize) < 0) - return NULL; - - len = f->f_bufend - f->f_bufptr; - if (len == 0) - return (PyStringObject *) - PyString_FromStringAndSize(NULL, skip); - bufptr = (char *)memchr(f->f_bufptr, '\n', len); - if (bufptr != NULL) { - bufptr++; /* Count the '\n' */ - len = bufptr - f->f_bufptr; - s = (PyStringObject *) - PyString_FromStringAndSize(NULL, skip+len); - if (s == NULL) - return NULL; - memcpy(PyString_AS_STRING(s)+skip, f->f_bufptr, len); - f->f_bufptr = bufptr; - if (bufptr == f->f_bufend) - drop_readahead(f); - } else { - bufptr = f->f_bufptr; - buf = f->f_buf; - f->f_buf = NULL; /* Force new readahead buffer */ - assert(skip+len < INT_MAX); - s = readahead_get_line_skip( - f, (int)(skip+len), bufsize + (bufsize>>2) ); - if (s == NULL) { - PyMem_Free(buf); - return NULL; - } - memcpy(PyString_AS_STRING(s)+skip, bufptr, len); - PyMem_Free(buf); - } - return s; + PyStringObject* s; + char *bufptr; + char *buf; + Py_ssize_t len; + + if (f->f_buf == NULL) + if (readahead(f, bufsize) < 0) + return NULL; + + len = f->f_bufend - f->f_bufptr; + if (len == 0) + return (PyStringObject *) + PyString_FromStringAndSize(NULL, skip); + bufptr = (char *)memchr(f->f_bufptr, '\n', len); + if (bufptr != NULL) { + bufptr++; /* Count the '\n' */ + len = bufptr - f->f_bufptr; + s = (PyStringObject *) + PyString_FromStringAndSize(NULL, skip+len); + if (s == NULL) + return NULL; + memcpy(PyString_AS_STRING(s)+skip, f->f_bufptr, len); + f->f_bufptr = bufptr; + if (bufptr == f->f_bufend) + drop_readahead(f); + } else { + bufptr = f->f_bufptr; + buf = f->f_buf; + f->f_buf = NULL; /* Force new readahead buffer */ + assert(skip+len < INT_MAX); + s = readahead_get_line_skip( + f, (int)(skip+len), bufsize + (bufsize>>2) ); + if (s == NULL) { + PyMem_Free(buf); + return NULL; + } + memcpy(PyString_AS_STRING(s)+skip, bufptr, len); + PyMem_Free(buf); + } + return s; } /* A larger buffer size may actually decrease performance. */ @@ -2214,122 +2214,122 @@ readahead_get_line_skip(PyFileObject *f, int skip, int bufsize) static PyObject * file_iternext(PyFileObject *f) { - PyStringObject* l; - - if (f->f_fp == NULL) - return err_closed(); - if (!f->readable) - return err_mode("reading"); - - l = readahead_get_line_skip(f, 0, READAHEAD_BUFSIZE); - if (l == NULL || PyString_GET_SIZE(l) == 0) { - Py_XDECREF(l); - return NULL; - } - return (PyObject *)l; + PyStringObject* l; + + if (f->f_fp == NULL) + return err_closed(); + if (!f->readable) + return err_mode("reading"); + + l = readahead_get_line_skip(f, 0, READAHEAD_BUFSIZE); + if (l == NULL || PyString_GET_SIZE(l) == 0) { + Py_XDECREF(l); + return NULL; + } + return (PyObject *)l; } static PyObject * file_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { - PyObject *self; - static PyObject *not_yet_string; - - assert(type != NULL && type->tp_alloc != NULL); - - if (not_yet_string == NULL) { - not_yet_string = PyString_InternFromString("<uninitialized file>"); - if (not_yet_string == NULL) - return NULL; - } - - self = type->tp_alloc(type, 0); - if (self != NULL) { - /* Always fill in the name and mode, so that nobody else - needs to special-case NULLs there. */ - Py_INCREF(not_yet_string); - ((PyFileObject *)self)->f_name = not_yet_string; - Py_INCREF(not_yet_string); - ((PyFileObject *)self)->f_mode = not_yet_string; - Py_INCREF(Py_None); - ((PyFileObject *)self)->f_encoding = Py_None; - Py_INCREF(Py_None); - ((PyFileObject *)self)->f_errors = Py_None; - ((PyFileObject *)self)->weakreflist = NULL; - ((PyFileObject *)self)->unlocked_count = 0; - } - return self; + PyObject *self; + static PyObject *not_yet_string; + + assert(type != NULL && type->tp_alloc != NULL); + + if (not_yet_string == NULL) { + not_yet_string = PyString_InternFromString("<uninitialized file>"); + if (not_yet_string == NULL) + return NULL; + } + + self = type->tp_alloc(type, 0); + if (self != NULL) { + /* Always fill in the name and mode, so that nobody else + needs to special-case NULLs there. */ + Py_INCREF(not_yet_string); + ((PyFileObject *)self)->f_name = not_yet_string; + Py_INCREF(not_yet_string); + ((PyFileObject *)self)->f_mode = not_yet_string; + Py_INCREF(Py_None); + ((PyFileObject *)self)->f_encoding = Py_None; + Py_INCREF(Py_None); + ((PyFileObject *)self)->f_errors = Py_None; + ((PyFileObject *)self)->weakreflist = NULL; + ((PyFileObject *)self)->unlocked_count = 0; + } + return self; } static int file_init(PyObject *self, PyObject *args, PyObject *kwds) { - PyFileObject *foself = (PyFileObject *)self; - int ret = 0; - static char *kwlist[] = {"name", "mode", "buffering", 0}; - char *name = NULL; - char *mode = "r"; - int bufsize = -1; - int wideargument = 0; + PyFileObject *foself = (PyFileObject *)self; + int ret = 0; + static char *kwlist[] = {"name", "mode", "buffering", 0}; + char *name = NULL; + char *mode = "r"; + int bufsize = -1; + int wideargument = 0; #ifdef MS_WINDOWS - PyObject *po; + PyObject *po; #endif - assert(PyFile_Check(self)); - if (foself->f_fp != NULL) { - /* Have to close the existing file first. */ - PyObject *closeresult = file_close(foself); - if (closeresult == NULL) - return -1; - Py_DECREF(closeresult); - } + assert(PyFile_Check(self)); + if (foself->f_fp != NULL) { + /* Have to close the existing file first. */ + PyObject *closeresult = file_close(foself); + if (closeresult == NULL) + return -1; + Py_DECREF(closeresult); + } #ifdef MS_WINDOWS - if (PyArg_ParseTupleAndKeywords(args, kwds, "U|si:file", - kwlist, &po, &mode, &bufsize)) { - wideargument = 1; - if (fill_file_fields(foself, NULL, po, mode, - fclose) == NULL) - goto Error; - } else { - /* Drop the argument parsing error as narrow - strings are also valid. */ - PyErr_Clear(); - } + if (PyArg_ParseTupleAndKeywords(args, kwds, "U|si:file", + kwlist, &po, &mode, &bufsize)) { + wideargument = 1; + if (fill_file_fields(foself, NULL, po, mode, + fclose) == NULL) + goto Error; + } else { + /* Drop the argument parsing error as narrow + strings are also valid. */ + PyErr_Clear(); + } #endif - if (!wideargument) { - PyObject *o_name; - - if (!PyArg_ParseTupleAndKeywords(args, kwds, "et|si:file", kwlist, - Py_FileSystemDefaultEncoding, - &name, - &mode, &bufsize)) - return -1; - - /* We parse again to get the name as a PyObject */ - if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|si:file", - kwlist, &o_name, &mode, - &bufsize)) - goto Error; - - if (fill_file_fields(foself, NULL, o_name, mode, - fclose) == NULL) - goto Error; - } - if (open_the_file(foself, name, mode) == NULL) - goto Error; - foself->f_setbuf = NULL; - PyFile_SetBufSize(self, bufsize); - goto Done; + if (!wideargument) { + PyObject *o_name; + + if (!PyArg_ParseTupleAndKeywords(args, kwds, "et|si:file", kwlist, + Py_FileSystemDefaultEncoding, + &name, + &mode, &bufsize)) + return -1; + + /* We parse again to get the name as a PyObject */ + if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|si:file", + kwlist, &o_name, &mode, + &bufsize)) + goto Error; + + if (fill_file_fields(foself, NULL, o_name, mode, + fclose) == NULL) + goto Error; + } + if (open_the_file(foself, name, mode) == NULL) + goto Error; + foself->f_setbuf = NULL; + PyFile_SetBufSize(self, bufsize); + goto Done; Error: - ret = -1; - /* fall through */ + ret = -1; + /* fall through */ Done: - PyMem_Free(name); /* free the encoded string */ - return ret; + PyMem_Free(name); /* free the encoded string */ + return ret; } PyDoc_VAR(file_doc) = @@ -2356,46 +2356,46 @@ PyDoc_STR( ); PyTypeObject PyFile_Type = { - PyVarObject_HEAD_INIT(&PyType_Type, 0) - "file", - sizeof(PyFileObject), - 0, - (destructor)file_dealloc, /* tp_dealloc */ - 0, /* tp_print */ - 0, /* tp_getattr */ - 0, /* tp_setattr */ - 0, /* tp_compare */ - (reprfunc)file_repr, /* tp_repr */ - 0, /* tp_as_number */ - 0, /* tp_as_sequence */ - 0, /* tp_as_mapping */ - 0, /* tp_hash */ - 0, /* tp_call */ - 0, /* tp_str */ - PyObject_GenericGetAttr, /* tp_getattro */ - /* softspace is writable: we must supply tp_setattro */ - PyObject_GenericSetAttr, /* tp_setattro */ - 0, /* tp_as_buffer */ - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */ - file_doc, /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - 0, /* tp_richcompare */ - offsetof(PyFileObject, weakreflist), /* tp_weaklistoffset */ - (getiterfunc)file_self, /* tp_iter */ - (iternextfunc)file_iternext, /* tp_iternext */ - file_methods, /* tp_methods */ - file_memberlist, /* tp_members */ - file_getsetlist, /* tp_getset */ - 0, /* tp_base */ - 0, /* tp_dict */ - 0, /* tp_descr_get */ - 0, /* tp_descr_set */ - 0, /* tp_dictoffset */ - file_init, /* tp_init */ - PyType_GenericAlloc, /* tp_alloc */ - file_new, /* tp_new */ - PyObject_Del, /* tp_free */ + PyVarObject_HEAD_INIT(&PyType_Type, 0) + "file", + sizeof(PyFileObject), + 0, + (destructor)file_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + (reprfunc)file_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + /* softspace is writable: we must supply tp_setattro */ + PyObject_GenericSetAttr, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */ + file_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + offsetof(PyFileObject, weakreflist), /* tp_weaklistoffset */ + (getiterfunc)file_self, /* tp_iter */ + (iternextfunc)file_iternext, /* tp_iternext */ + file_methods, /* tp_methods */ + file_memberlist, /* tp_members */ + file_getsetlist, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + file_init, /* tp_init */ + PyType_GenericAlloc, /* tp_alloc */ + file_new, /* tp_new */ + PyObject_Del, /* tp_free */ }; /* Interface for the 'soft space' between print items. */ @@ -2403,35 +2403,35 @@ PyTypeObject PyFile_Type = { int PyFile_SoftSpace(PyObject *f, int newflag) { - long oldflag = 0; - if (f == NULL) { - /* Do nothing */ - } - else if (PyFile_Check(f)) { - oldflag = ((PyFileObject *)f)->f_softspace; - ((PyFileObject *)f)->f_softspace = newflag; - } - else { - PyObject *v; - v = PyObject_GetAttrString(f, "softspace"); - if (v == NULL) - PyErr_Clear(); - else { - if (PyInt_Check(v)) - oldflag = PyInt_AsLong(v); - assert(oldflag < INT_MAX); - Py_DECREF(v); - } - v = PyInt_FromLong((long)newflag); - if (v == NULL) - PyErr_Clear(); - else { - if (PyObject_SetAttrString(f, "softspace", v) != 0) - PyErr_Clear(); - Py_DECREF(v); - } - } - return (int)oldflag; + long oldflag = 0; + if (f == NULL) { + /* Do nothing */ + } + else if (PyFile_Check(f)) { + oldflag = ((PyFileObject *)f)->f_softspace; + ((PyFileObject *)f)->f_softspace = newflag; + } + else { + PyObject *v; + v = PyObject_GetAttrString(f, "softspace"); + if (v == NULL) + PyErr_Clear(); + else { + if (PyInt_Check(v)) + oldflag = PyInt_AsLong(v); + assert(oldflag < INT_MAX); + Py_DECREF(v); + } + v = PyInt_FromLong((long)newflag); + if (v == NULL) + PyErr_Clear(); + else { + if (PyObject_SetAttrString(f, "softspace", v) != 0) + PyErr_Clear(); + Py_DECREF(v); + } + } + return (int)oldflag; } /* Interfaces to write objects/strings to file-like objects */ @@ -2439,107 +2439,107 @@ PyFile_SoftSpace(PyObject *f, int newflag) int PyFile_WriteObject(PyObject *v, PyObject *f, int flags) { - PyObject *writer, *value, *args, *result; - if (f == NULL) { - PyErr_SetString(PyExc_TypeError, "writeobject with NULL file"); - return -1; - } - else if (PyFile_Check(f)) { - PyFileObject *fobj = (PyFileObject *) f; + PyObject *writer, *value, *args, *result; + if (f == NULL) { + PyErr_SetString(PyExc_TypeError, "writeobject with NULL file"); + return -1; + } + else if (PyFile_Check(f)) { + PyFileObject *fobj = (PyFileObject *) f; #ifdef Py_USING_UNICODE - PyObject *enc = fobj->f_encoding; - int result; + PyObject *enc = fobj->f_encoding; + int result; #endif - if (fobj->f_fp == NULL) { - err_closed(); - return -1; - } + if (fobj->f_fp == NULL) { + err_closed(); + return -1; + } #ifdef Py_USING_UNICODE - if ((flags & Py_PRINT_RAW) && - PyUnicode_Check(v) && enc != Py_None) { - char *cenc = PyString_AS_STRING(enc); - char *errors = fobj->f_errors == Py_None ? - "strict" : PyString_AS_STRING(fobj->f_errors); - value = PyUnicode_AsEncodedString(v, cenc, errors); - if (value == NULL) - return -1; - } else { - value = v; - Py_INCREF(value); - } - result = file_PyObject_Print(value, fobj, flags); - Py_DECREF(value); - return result; + if ((flags & Py_PRINT_RAW) && + PyUnicode_Check(v) && enc != Py_None) { + char *cenc = PyString_AS_STRING(enc); + char *errors = fobj->f_errors == Py_None ? + "strict" : PyString_AS_STRING(fobj->f_errors); + value = PyUnicode_AsEncodedString(v, cenc, errors); + if (value == NULL) + return -1; + } else { + value = v; + Py_INCREF(value); + } + result = file_PyObject_Print(value, fobj, flags); + Py_DECREF(value); + return result; #else - return file_PyObject_Print(v, fobj, flags); + return file_PyObject_Print(v, fobj, flags); #endif - } - writer = PyObject_GetAttrString(f, "write"); - if (writer == NULL) - return -1; - if (flags & Py_PRINT_RAW) { - if (PyUnicode_Check(v)) { - value = v; - Py_INCREF(value); - } else - value = PyObject_Str(v); - } - else - value = PyObject_Repr(v); - if (value == NULL) { - Py_DECREF(writer); - return -1; - } - args = PyTuple_Pack(1, value); - if (args == NULL) { - Py_DECREF(value); - Py_DECREF(writer); - return -1; - } - result = PyEval_CallObject(writer, args); - Py_DECREF(args); - Py_DECREF(value); - Py_DECREF(writer); - if (result == NULL) - return -1; - Py_DECREF(result); - return 0; + } + writer = PyObject_GetAttrString(f, "write"); + if (writer == NULL) + return -1; + if (flags & Py_PRINT_RAW) { + if (PyUnicode_Check(v)) { + value = v; + Py_INCREF(value); + } else + value = PyObject_Str(v); + } + else + value = PyObject_Repr(v); + if (value == NULL) { + Py_DECREF(writer); + return -1; + } + args = PyTuple_Pack(1, value); + if (args == NULL) { + Py_DECREF(value); + Py_DECREF(writer); + return -1; + } + result = PyEval_CallObject(writer, args); + Py_DECREF(args); + Py_DECREF(value); + Py_DECREF(writer); + if (result == NULL) + return -1; + Py_DECREF(result); + return 0; } int PyFile_WriteString(const char *s, PyObject *f) { - if (f == NULL) { - /* Should be caused by a pre-existing error */ - if (!PyErr_Occurred()) - PyErr_SetString(PyExc_SystemError, - "null file for PyFile_WriteString"); - return -1; - } - else if (PyFile_Check(f)) { - PyFileObject *fobj = (PyFileObject *) f; - FILE *fp = PyFile_AsFile(f); - if (fp == NULL) { - err_closed(); - return -1; - } - FILE_BEGIN_ALLOW_THREADS(fobj) - fputs(s, fp); - FILE_END_ALLOW_THREADS(fobj) - return 0; - } - else if (!PyErr_Occurred()) { - PyObject *v = PyString_FromString(s); - int err; - if (v == NULL) - return -1; - err = PyFile_WriteObject(v, f, Py_PRINT_RAW); - Py_DECREF(v); - return err; - } - else - return -1; + if (f == NULL) { + /* Should be caused by a pre-existing error */ + if (!PyErr_Occurred()) + PyErr_SetString(PyExc_SystemError, + "null file for PyFile_WriteString"); + return -1; + } + else if (PyFile_Check(f)) { + PyFileObject *fobj = (PyFileObject *) f; + FILE *fp = PyFile_AsFile(f); + if (fp == NULL) { + err_closed(); + return -1; + } + FILE_BEGIN_ALLOW_THREADS(fobj) + fputs(s, fp); + FILE_END_ALLOW_THREADS(fobj) + return 0; + } + else if (!PyErr_Occurred()) { + PyObject *v = PyString_FromString(s); + int err; + if (v == NULL) + return -1; + err = PyFile_WriteObject(v, f, Py_PRINT_RAW); + Py_DECREF(v); + return err; + } + else + return -1; } /* Try to get a file-descriptor from a Python object. If the object @@ -2551,50 +2551,50 @@ PyFile_WriteString(const char *s, PyObject *f) int PyObject_AsFileDescriptor(PyObject *o) { - int fd; - PyObject *meth; - - if (PyInt_Check(o)) { - fd = PyInt_AsLong(o); - } - else if (PyLong_Check(o)) { - fd = PyLong_AsLong(o); - } - else if ((meth = PyObject_GetAttrString(o, "fileno")) != NULL) - { - PyObject *fno = PyEval_CallObject(meth, NULL); - Py_DECREF(meth); - if (fno == NULL) - return -1; - - if (PyInt_Check(fno)) { - fd = PyInt_AsLong(fno); - Py_DECREF(fno); - } - else if (PyLong_Check(fno)) { - fd = PyLong_AsLong(fno); - Py_DECREF(fno); - } - else { - PyErr_SetString(PyExc_TypeError, - "fileno() returned a non-integer"); - Py_DECREF(fno); - return -1; - } - } - else { - PyErr_SetString(PyExc_TypeError, - "argument must be an int, or have a fileno() method."); - return -1; - } - - if (fd < 0) { - PyErr_Format(PyExc_ValueError, - "file descriptor cannot be a negative integer (%i)", - fd); - return -1; - } - return fd; + int fd; + PyObject *meth; + + if (PyInt_Check(o)) { + fd = PyInt_AsLong(o); + } + else if (PyLong_Check(o)) { + fd = PyLong_AsLong(o); + } + else if ((meth = PyObject_GetAttrString(o, "fileno")) != NULL) + { + PyObject *fno = PyEval_CallObject(meth, NULL); + Py_DECREF(meth); + if (fno == NULL) + return -1; + + if (PyInt_Check(fno)) { + fd = PyInt_AsLong(fno); + Py_DECREF(fno); + } + else if (PyLong_Check(fno)) { + fd = PyLong_AsLong(fno); + Py_DECREF(fno); + } + else { + PyErr_SetString(PyExc_TypeError, + "fileno() returned a non-integer"); + Py_DECREF(fno); + return -1; + } + } + else { + PyErr_SetString(PyExc_TypeError, + "argument must be an int, or have a fileno() method."); + return -1; + } + + if (fd < 0) { + PyErr_Format(PyExc_ValueError, + "file descriptor cannot be a negative integer (%i)", + fd); + return -1; + } + return fd; } /* From here on we need access to the real fgets and fread */ @@ -2618,79 +2618,79 @@ int PyObject_AsFileDescriptor(PyObject *o) char * Py_UniversalNewlineFgets(char *buf, int n, FILE *stream, PyObject *fobj) { - char *p = buf; - int c; - int newlinetypes = 0; - int skipnextlf = 0; - int univ_newline = 1; - - if (fobj) { - if (!PyFile_Check(fobj)) { - errno = ENXIO; /* What can you do... */ - return NULL; - } - univ_newline = ((PyFileObject *)fobj)->f_univ_newline; - if ( !univ_newline ) - return fgets(buf, n, stream); - newlinetypes = ((PyFileObject *)fobj)->f_newlinetypes; - skipnextlf = ((PyFileObject *)fobj)->f_skipnextlf; - } - FLOCKFILE(stream); - c = 'x'; /* Shut up gcc warning */ - while (--n > 0 && (c = GETC(stream)) != EOF ) { - if (skipnextlf ) { - skipnextlf = 0; - if (c == '\n') { - /* Seeing a \n here with skipnextlf true - ** means we saw a \r before. - */ - newlinetypes |= NEWLINE_CRLF; - c = GETC(stream); - if (c == EOF) break; - } else { - /* - ** Note that c == EOF also brings us here, - ** so we're okay if the last char in the file - ** is a CR. - */ - newlinetypes |= NEWLINE_CR; - } - } - if (c == '\r') { - /* A \r is translated into a \n, and we skip - ** an adjacent \n, if any. We don't set the - ** newlinetypes flag until we've seen the next char. - */ - skipnextlf = 1; - c = '\n'; - } else if ( c == '\n') { - newlinetypes |= NEWLINE_LF; - } - *p++ = c; - if (c == '\n') break; - } - if ( c == EOF && skipnextlf ) - newlinetypes |= NEWLINE_CR; - FUNLOCKFILE(stream); - *p = '\0'; - if (fobj) { - ((PyFileObject *)fobj)->f_newlinetypes = newlinetypes; - ((PyFileObject *)fobj)->f_skipnextlf = skipnextlf; - } else if ( skipnextlf ) { - /* If we have no file object we cannot save the - ** skipnextlf flag. We have to readahead, which - ** will cause a pause if we're reading from an - ** interactive stream, but that is very unlikely - ** unless we're doing something silly like - ** execfile("/dev/tty"). - */ - c = GETC(stream); - if ( c != '\n' ) - ungetc(c, stream); - } - if (p == buf) - return NULL; - return buf; + char *p = buf; + int c; + int newlinetypes = 0; + int skipnextlf = 0; + int univ_newline = 1; + + if (fobj) { + if (!PyFile_Check(fobj)) { + errno = ENXIO; /* What can you do... */ + return NULL; + } + univ_newline = ((PyFileObject *)fobj)->f_univ_newline; + if ( !univ_newline ) + return fgets(buf, n, stream); + newlinetypes = ((PyFileObject *)fobj)->f_newlinetypes; + skipnextlf = ((PyFileObject *)fobj)->f_skipnextlf; + } + FLOCKFILE(stream); + c = 'x'; /* Shut up gcc warning */ + while (--n > 0 && (c = GETC(stream)) != EOF ) { + if (skipnextlf ) { + skipnextlf = 0; + if (c == '\n') { + /* Seeing a \n here with skipnextlf true + ** means we saw a \r before. + */ + newlinetypes |= NEWLINE_CRLF; + c = GETC(stream); + if (c == EOF) break; + } else { + /* + ** Note that c == EOF also brings us here, + ** so we're okay if the last char in the file + ** is a CR. + */ + newlinetypes |= NEWLINE_CR; + } + } + if (c == '\r') { + /* A \r is translated into a \n, and we skip + ** an adjacent \n, if any. We don't set the + ** newlinetypes flag until we've seen the next char. + */ + skipnextlf = 1; + c = '\n'; + } else if ( c == '\n') { + newlinetypes |= NEWLINE_LF; + } + *p++ = c; + if (c == '\n') break; + } + if ( c == EOF && skipnextlf ) + newlinetypes |= NEWLINE_CR; + FUNLOCKFILE(stream); + *p = '\0'; + if (fobj) { + ((PyFileObject *)fobj)->f_newlinetypes = newlinetypes; + ((PyFileObject *)fobj)->f_skipnextlf = skipnextlf; + } else if ( skipnextlf ) { + /* If we have no file object we cannot save the + ** skipnextlf flag. We have to readahead, which + ** will cause a pause if we're reading from an + ** interactive stream, but that is very unlikely + ** unless we're doing something silly like + ** execfile("/dev/tty"). + */ + c = GETC(stream); + if ( c != '\n' ) + ungetc(c, stream); + } + if (p == buf) + return NULL; + return buf; } /* @@ -2705,74 +2705,74 @@ Py_UniversalNewlineFgets(char *buf, int n, FILE *stream, PyObject *fobj) */ size_t Py_UniversalNewlineFread(char *buf, size_t n, - FILE *stream, PyObject *fobj) + FILE *stream, PyObject *fobj) { - char *dst = buf; - PyFileObject *f = (PyFileObject *)fobj; - int newlinetypes, skipnextlf; - - assert(buf != NULL); - assert(stream != NULL); - - if (!fobj || !PyFile_Check(fobj)) { - errno = ENXIO; /* What can you do... */ - return 0; - } - if (!f->f_univ_newline) - return fread(buf, 1, n, stream); - newlinetypes = f->f_newlinetypes; - skipnextlf = f->f_skipnextlf; - /* Invariant: n is the number of bytes remaining to be filled - * in the buffer. - */ - while (n) { - size_t nread; - int shortread; - char *src = dst; - - nread = fread(dst, 1, n, stream); - assert(nread <= n); - if (nread == 0) - break; - - n -= nread; /* assuming 1 byte out for each in; will adjust */ - shortread = n != 0; /* true iff EOF or error */ - while (nread--) { - char c = *src++; - if (c == '\r') { - /* Save as LF and set flag to skip next LF. */ - *dst++ = '\n'; - skipnextlf = 1; - } - else if (skipnextlf && c == '\n') { - /* Skip LF, and remember we saw CR LF. */ - skipnextlf = 0; - newlinetypes |= NEWLINE_CRLF; - ++n; - } - else { - /* Normal char to be stored in buffer. Also - * update the newlinetypes flag if either this - * is an LF or the previous char was a CR. - */ - if (c == '\n') - newlinetypes |= NEWLINE_LF; - else if (skipnextlf) - newlinetypes |= NEWLINE_CR; - *dst++ = c; - skipnextlf = 0; - } - } - if (shortread) { - /* If this is EOF, update type flags. */ - if (skipnextlf && feof(stream)) - newlinetypes |= NEWLINE_CR; - break; - } - } - f->f_newlinetypes = newlinetypes; - f->f_skipnextlf = skipnextlf; - return dst - buf; + char *dst = buf; + PyFileObject *f = (PyFileObject *)fobj; + int newlinetypes, skipnextlf; + + assert(buf != NULL); + assert(stream != NULL); + + if (!fobj || !PyFile_Check(fobj)) { + errno = ENXIO; /* What can you do... */ + return 0; + } + if (!f->f_univ_newline) + return fread(buf, 1, n, stream); + newlinetypes = f->f_newlinetypes; + skipnextlf = f->f_skipnextlf; + /* Invariant: n is the number of bytes remaining to be filled + * in the buffer. + */ + while (n) { + size_t nread; + int shortread; + char *src = dst; + + nread = fread(dst, 1, n, stream); + assert(nread <= n); + if (nread == 0) + break; + + n -= nread; /* assuming 1 byte out for each in; will adjust */ + shortread = n != 0; /* true iff EOF or error */ + while (nread--) { + char c = *src++; + if (c == '\r') { + /* Save as LF and set flag to skip next LF. */ + *dst++ = '\n'; + skipnextlf = 1; + } + else if (skipnextlf && c == '\n') { + /* Skip LF, and remember we saw CR LF. */ + skipnextlf = 0; + newlinetypes |= NEWLINE_CRLF; + ++n; + } + else { + /* Normal char to be stored in buffer. Also + * update the newlinetypes flag if either this + * is an LF or the previous char was a CR. + */ + if (c == '\n') + newlinetypes |= NEWLINE_LF; + else if (skipnextlf) + newlinetypes |= NEWLINE_CR; + *dst++ = c; + skipnextlf = 0; + } + } + if (shortread) { + /* If this is EOF, update type flags. */ + if (skipnextlf && feof(stream)) + newlinetypes |= NEWLINE_CR; + break; + } + } + f->f_newlinetypes = newlinetypes; + f->f_skipnextlf = skipnextlf; + return dst - buf; } #ifdef __cplusplus |