Added clearerr() to clear EOF state

Objects/fileobject.c

 /* File object implementation */
 
 #define PY_SSIZE_T_CLEAN
 #include "Python.h"
 #include "structmember.h"
 
 #ifdef HAVE_SYS_TYPES_H
 #include <sys/types.h>
 #endif /* HAVE_SYS_TYPES_H */
 
@@ skipping 853 matching lines @@
         if (v == NULL)
                 return NULL;
         bytesread = 0;
         for (;;) {
                 Py_BEGIN_ALLOW_THREADS
                 errno = 0;
                 chunksize = Py_UniversalNewlineFread(BUF(v) + bytesread,
                           buffersize - bytesread, f->f_fp, (PyObject *)f);
                 Py_END_ALLOW_THREADS
                 if (chunksize == 0) {
-                        if (!ferror(f->f_fp))
+                        if (!PyErr_ExceptionMatches(PyExc_IOError))
                                 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))
+                        if (bytesread > 0 && BLOCKED_ERRNO(errno)) {
+                                PyErr_Clear();
                                 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);
@@ skipping 26 matching lines @@
         if (!PyArg_ParseTuple(args, "w#", &ptr, &ntodo))
                 return NULL;
         ndone = 0;
         while (ntodo > 0) {
                 Py_BEGIN_ALLOW_THREADS
                 errno = 0;
                 nnow = Py_UniversalNewlineFread(ptr+ndone, ntodo, f->f_fp,
                                                 (PyObject *)f);
                 Py_END_ALLOW_THREADS
                 if (nnow == 0) {
-                        if (!ferror(f->f_fp))
+                        if (!PyErr_ExceptionMatches(PyExc_IOError))
                                 break;
-                        PyErr_SetFromErrno(PyExc_IOError);
-                        clearerr(f->f_fp);
                         return NULL;
                 }
                 ndone += nnow;
                 ntodo -= nnow;
         }
         return PyInt_FromSsize_t(ndone);
 }
 
 /**************************************************************************
 Routine to get next line using platform fgets().
@@ skipping 471 matching lines @@
                 else {
                         Py_BEGIN_ALLOW_THREADS
                         errno = 0;
                         nread = Py_UniversalNewlineFread(buffer+nfilled,
                                 buffersize-nfilled, f->f_fp, (PyObject *)f);
                         Py_END_ALLOW_THREADS
                         shortread = (nread < buffersize-nfilled);
                 }
                 if (nread == 0) {
                         sizehint = 0;
-                        if (!ferror(f->f_fp))
+                        if (!PyErr_ExceptionMatches(PyExc_IOError))
                                 break;
-                        PyErr_SetFromErrno(PyExc_IOError);
-                        clearerr(f->f_fp);
                   error:
                         Py_DECREF(list);
                         list = NULL;
                         goto cleanup;
                 }
                 totalread += nread;
                 p = (char *)memchr(buffer+nfilled, '\n', nread);
                 if (p == NULL) {
                         /* Need a larger buffer to fit this line */
                         nfilled += nread;
@@ skipping 427 matching lines @@
         if ((f->f_buf = (char *)PyMem_Malloc(bufsize)) == NULL) {
                 PyErr_NoMemory();
                 return -1;
         }
         Py_BEGIN_ALLOW_THREADS
         errno = 0;
         chunksize = Py_UniversalNewlineFread(
                 f->f_buf, bufsize, f->f_fp, (PyObject *)f);
         Py_END_ALLOW_THREADS
         if (chunksize == 0) {
-                if (ferror(f->f_fp)) {
-                        PyErr_SetFromErrno(PyExc_IOError);
-                        clearerr(f->f_fp);
+                if (PyErr_ExceptionMatches(PyExc_IOError)) {
                         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'
@@ skipping 530 matching lines @@
 ** the whole conversion is skipped. Finally, the routine keeps track of
 ** the different types of newlines seen.
 */
 size_t
 Py_UniversalNewlineFread(char *buf, size_t n,
                          FILE *stream, PyObject *fobj)
 {
         char *dst = buf;
         PyFileObject *f = (PyFileObject *)fobj;
         int newlinetypes, skipnextlf;
+        size_t nread;
 
         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);
+        if (!f->f_univ_newline) {
+                nread = fread(buf, 1, n, stream);
+                if (nread == 0) {
+                        if (ferror(stream))
+                                PyErr_SetFromErrno(PyExc_IOError);
+                        clearerr(stream);
+                }
+                return nread;
+        }
         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)
+                if (nread == 0) {
+                        if (ferror(stream)) {
+                                clearerr(stream);
+                                PyErr_SetFromErrno(PyExc_IOError);
+                                return 0;
+                        }
+                        clearerr(stream);
                         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;
                         }
@@ skipping 24 matching lines @@
                 }
         }
         f->f_newlinetypes = newlinetypes;
         f->f_skipnextlf = skipnextlf;
         return dst - buf;
 }
 
 #ifdef __cplusplus
 }
 #endif