14710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* File object implementation */ 24710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PY_SSIZE_T_CLEAN 44710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#include "Python.h" 54710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#include "structmember.h" 64710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 74710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef HAVE_SYS_TYPES_H 84710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#include <sys/types.h> 94710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif /* HAVE_SYS_TYPES_H */ 104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef MS_WINDOWS 124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define fileno _fileno 134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* can simulate truncate with Win32 API functions; see file_truncate */ 144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define HAVE_FTRUNCATE 154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define WIN32_LEAN_AND_MEAN 164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#include <windows.h> 174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if defined(PYOS_OS2) && defined(PYCC_GCC) 204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#include <io.h> 214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define BUF(v) PyString_AS_STRING((PyStringObject *)v) 244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef HAVE_ERRNO_H 264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#include <errno.h> 274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef HAVE_GETC_UNLOCKED 304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define GETC(f) getc_unlocked(f) 314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define FLOCKFILE(f) flockfile(f) 324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define FUNLOCKFILE(f) funlockfile(f) 334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define GETC(f) getc(f) 354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define FLOCKFILE(f) 364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define FUNLOCKFILE(f) 374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Bits in f_newlinetypes */ 404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define NEWLINE_UNKNOWN 0 /* No newline seen, yet */ 414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define NEWLINE_CR 1 /* \r newline seen */ 424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define NEWLINE_LF 2 /* \n newline seen */ 434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define NEWLINE_CRLF 4 /* \r\n newline seen */ 444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* 464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * These macros release the GIL while preventing the f_close() function being 474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * called in the interval between them. For that purpose, a running total of 484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * the number of currently running unlocked code sections is kept in 494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * the unlocked_count field of the PyFileObject. The close() method raises 504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * an IOError if that field is non-zero. See issue #815646, #595601. 514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define FILE_BEGIN_ALLOW_THREADS(fobj) \ 544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ \ 554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fobj->unlocked_count++; \ 564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_BEGIN_ALLOW_THREADS 574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define FILE_END_ALLOW_THREADS(fobj) \ 594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_END_ALLOW_THREADS \ 604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fobj->unlocked_count--; \ 614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(fobj->unlocked_count >= 0); \ 624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define FILE_ABORT_ALLOW_THREADS(fobj) \ 654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_BLOCK_THREADS \ 664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fobj->unlocked_count--; \ 674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(fobj->unlocked_count >= 0); 684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef __cplusplus 704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmextern "C" { 714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmFILE * 744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyFile_AsFile(PyObject *f) 754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f == NULL || !PyFile_Check(f)) 774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return ((PyFileObject *)f)->f_fp; 804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmvoid PyFile_IncUseCount(PyFileObject *fobj) 834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fobj->unlocked_count++; 854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmvoid PyFile_DecUseCount(PyFileObject *fobj) 884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fobj->unlocked_count--; 904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(fobj->unlocked_count >= 0); 914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyFile_Name(PyObject *f) 954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f == NULL || !PyFile_Check(f)) 974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return ((PyFileObject *)f)->f_name; 1004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 1014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* This is a safe wrapper around PyObject_Print to print to the FILE 1034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm of a PyFileObject. PyObject_Print releases the GIL but knows nothing 1044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm about PyFileObject. */ 1054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int 1064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfile_PyObject_Print(PyObject *op, PyFileObject *f, int flags) 1074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 1084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int result; 1094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFile_IncUseCount(f); 1104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = PyObject_Print(op, f->f_fp, flags); 1114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFile_DecUseCount(f); 1124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return result; 1134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 1144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* On Unix, fopen will succeed for directories. 1164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm In Python, there should be no file objects referring to 1174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm directories, so we need a check. */ 1184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyFileObject* 1204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdircheck(PyFileObject* f) 1214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 1224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if defined(HAVE_FSTAT) && defined(S_IFDIR) && defined(EISDIR) 1234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm struct stat buf; 1244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_fp == NULL) 1254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return f; 1264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (fstat(fileno(f->f_fp), &buf) == 0 && 1274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm S_ISDIR(buf.st_mode)) { 1284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *msg = strerror(EISDIR); 1294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *exc = PyObject_CallFunction(PyExc_IOError, "(isO)", 1304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm EISDIR, msg, f->f_name); 1314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetObject(PyExc_IOError, exc); 1324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(exc); 1334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 1344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 1354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 1364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return f; 1374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 1384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 1414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfill_file_fields(PyFileObject *f, FILE *fp, PyObject *name, char *mode, 1424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int (*close)(FILE *)) 1434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 1444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(name != NULL); 1454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(f != NULL); 1464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(PyFile_Check(f)); 1474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(f->f_fp == NULL); 1484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(f->f_name); 1504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(f->f_mode); 1514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(f->f_encoding); 1524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(f->f_errors); 1534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(name); 1554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_name = name; 1564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_mode = PyString_FromString(mode); 1584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_close = close; 1604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_softspace = 0; 1614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_binary = strchr(mode,'b') != NULL; 1624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_buf = NULL; 1634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_univ_newline = (strchr(mode, 'U') != NULL); 1644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_newlinetypes = NEWLINE_UNKNOWN; 1654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_skipnextlf = 0; 1664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(Py_None); 1674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_encoding = Py_None; 1684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(Py_None); 1694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_errors = Py_None; 1704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->readable = f->writable = 0; 1714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (strchr(mode, 'r') != NULL || f->f_univ_newline) 1724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->readable = 1; 1734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (strchr(mode, 'w') != NULL || strchr(mode, 'a') != NULL) 1744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->writable = 1; 1754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (strchr(mode, '+') != NULL) 1764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->readable = f->writable = 1; 1774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_mode == NULL) 1794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 1804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_fp = fp; 1814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f = dircheck(f); 1824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *) f; 1834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 1844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if defined _MSC_VER && _MSC_VER >= 1400 && defined(__STDC_SECURE_LIB__) 1864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define Py_VERIFY_WINNT 1874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* The CRT on windows compiled with Visual Studio 2005 and higher may 1884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * assert if given invalid mode strings. This is all fine and well 1894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * in static languages like C where the mode string is typcially hard 1904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * coded. But in Python, were we pass in the mode string from the user, 1914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * we need to verify it first manually 1924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 1934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int _PyVerify_Mode_WINNT(const char *mode) 1944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 1954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* See if mode string is valid on Windows to avoid hard assertions */ 1964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* remove leading spacese */ 1974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int singles = 0; 1984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int pairs = 0; 1994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int encoding = 0; 2004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm const char *s, *c; 2014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while(*mode == ' ') /* strip initial spaces */ 2034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++mode; 2044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!strchr("rwa", *mode)) /* must start with one of these */ 2054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 2064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (*++mode) { 2074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (*mode == ' ' || *mode == 'N') /* ignore spaces and N */ 2084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 2094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = "+TD"; /* each of this can appear only once */ 2104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = strchr(s, *mode); 2114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (c) { 2124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ptrdiff_t idx = s-c; 2134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (singles & (1<<idx)) 2144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 2154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm singles |= (1<<idx); 2164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 2174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 2184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = "btcnSR"; /* only one of each letter in the pairs allowed */ 2194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = strchr(s, *mode); 2204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (c) { 2214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ptrdiff_t idx = (s-c)/2; 2224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (pairs & (1<<idx)) 2234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 2244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pairs |= (1<<idx); 2254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 2264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 2274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (*mode == ',') { 2284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm encoding = 1; 2294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 2304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 2314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; /* found an invalid char */ 2324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 2334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (encoding) { 2354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *e[] = {"UTF-8", "UTF-16LE", "UNICODE"}; 2364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (*mode == ' ') 2374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++mode; 2384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* find 'ccs =' */ 2394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (strncmp(mode, "ccs", 3)) 2404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 2414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm mode += 3; 2424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (*mode == ' ') 2434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++mode; 2444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (*mode != '=') 2454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 2464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (*mode == ' ') 2474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++mode; 2484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for(encoding = 0; encoding<_countof(e); ++encoding) { 2494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_t l = strlen(e[encoding]); 2504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!strncmp(mode, e[encoding], l)) { 2514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm mode += l; /* found a valid encoding */ 2524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 2534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 2544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 2554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (encoding == _countof(e)) 2564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 2574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 2584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* skip trailing spaces */ 2594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (*mode == ' ') 2604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++mode; 2614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return *mode == '\0'; /* must be at the end of the string */ 2634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 2644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 2654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* check for known incorrect mode strings - problem is, platforms are 2674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm free to accept any mode characters they like and are supposed to 2684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ignore stuff they don't understand... write or append mode with 2694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm universal newline support is expressly forbidden by PEP 278. 2704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Additionally, remove the 'U' from the mode string as platforms 2714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm won't know what it is. Non-zero return signals an exception */ 2724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint 2734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm_PyFile_SanitizeMode(char *mode) 2744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 2754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *upos; 2764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_t len = strlen(mode); 2774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!len) { 2794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_ValueError, "empty mode string"); 2804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 2814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 2824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm upos = strchr(mode, 'U'); 2844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (upos) { 2854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memmove(upos, upos+1, len-(upos-mode)); /* incl null char */ 2864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (mode[0] == 'w' || mode[0] == 'a') { 2884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_ValueError, "universal newline " 2894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "mode can only be used with modes " 2904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "starting with 'r'"); 2914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 2924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 2934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (mode[0] != 'r') { 2954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memmove(mode+1, mode, strlen(mode)+1); 2964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm mode[0] = 'r'; 2974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 2984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!strchr(mode, 'b')) { 3004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memmove(mode+2, mode+1, strlen(mode)); 3014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm mode[1] = 'b'; 3024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else if (mode[0] != 'r' && mode[0] != 'w' && mode[0] != 'a') { 3044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_ValueError, "mode string must begin with " 3054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "one of 'r', 'w', 'a' or 'U', not '%.200s'", mode); 3064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 3074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef Py_VERIFY_WINNT 3094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* additional checks on NT with visual studio 2005 and higher */ 3104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!_PyVerify_Mode_WINNT(mode)) { 3114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_ValueError, "Invalid mode ('%.50s')", mode); 3124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 3134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 3154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 3164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 3174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 3194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmopen_the_file(PyFileObject *f, char *name, char *mode) 3204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 3214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *newmode; 3224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(f != NULL); 3234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(PyFile_Check(f)); 3244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef MS_WINDOWS 3254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* windows ignores the passed name in order to support Unicode */ 3264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(f->f_name != NULL); 3274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 3284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(name != NULL); 3294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 3304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(mode != NULL); 3314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(f->f_fp == NULL); 3324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* probably need to replace 'U' by 'rb' */ 3344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newmode = PyMem_MALLOC(strlen(mode) + 3); 3354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!newmode) { 3364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_NoMemory(); 3374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 3384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm strcpy(newmode, mode); 3404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (_PyFile_SanitizeMode(newmode)) { 3424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f = NULL; 3434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto cleanup; 3444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* rexec.py can't stop a user from getting the file() constructor -- 3474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm all they have to do is get *any* file object f, and then do 3484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm type(f). Here we prevent them from doing damage with it. */ 3494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyEval_GetRestricted()) { 3504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_IOError, 3514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "file() constructor not accessible in restricted mode"); 3524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f = NULL; 3534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto cleanup; 3544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = 0; 3564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef MS_WINDOWS 3584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyUnicode_Check(f->f_name)) { 3594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *wmode; 3604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm wmode = PyUnicode_DecodeASCII(newmode, strlen(newmode), NULL); 3614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_name && wmode) { 3624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_BEGIN_ALLOW_THREADS(f) 3634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* PyUnicode_AS_UNICODE OK without thread 3644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm lock as it is a simple dereference. */ 3654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_fp = _wfopen(PyUnicode_AS_UNICODE(f->f_name), 3664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyUnicode_AS_UNICODE(wmode)); 3674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_END_ALLOW_THREADS(f) 3684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(wmode); 3704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 3724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (NULL == f->f_fp && NULL != name) { 3734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_BEGIN_ALLOW_THREADS(f) 3744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_fp = fopen(name, newmode); 3754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_END_ALLOW_THREADS(f) 3764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_fp == NULL) { 3794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if defined _MSC_VER && (_MSC_VER < 1400 || !defined(__STDC_SECURE_LIB__)) 3804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* MSVC 6 (Microsoft) leaves errno at 0 for bad mode strings, 3814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * across all Windows flavors. When it sets EINVAL varies 3824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * across Windows flavors, the exact conditions aren't 3834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * documented, and the answer lies in the OS's implementation 3844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * of Win32's CreateFile function (whose source is secret). 3854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * Seems the best we can do is map EINVAL to ENOENT. 3864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * Starting with Visual Studio .NET 2005, EINVAL is correctly 3874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * set by our CRT error handler (set in exceptions.c.) 3884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 3894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (errno == 0) /* bad mode string */ 3904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = EINVAL; 3914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (errno == EINVAL) /* unknown, but not a mode string */ 3924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = ENOENT; 3934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 3944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* EINVAL is returned when an invalid filename or 3954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * an invalid mode is supplied. */ 3964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (errno == EINVAL) { 3974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *v; 3984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char message[100]; 3994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyOS_snprintf(message, 100, 4004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "invalid mode ('%.50s') or filename", mode); 4014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = Py_BuildValue("(isO)", errno, message, f->f_name); 4024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v != NULL) { 4034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetObject(PyExc_IOError, v); 4044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 4054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 4084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetFromErrnoWithFilenameObject(PyExc_IOError, f->f_name); 4094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f = NULL; 4104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f != NULL) 4124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f = dircheck(f); 4134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmcleanup: 4154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyMem_FREE(newmode); 4164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)f; 4184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 4194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 4214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclose_the_file(PyFileObject *f) 4224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 4234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int sts = 0; 4244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int (*local_close)(FILE *); 4254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE *local_fp = f->f_fp; 4264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *local_setbuf = f->f_setbuf; 4274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (local_fp != NULL) { 4284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm local_close = f->f_close; 4294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (local_close != NULL && f->unlocked_count > 0) { 4304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->ob_refcnt > 0) { 4314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_IOError, 4324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "close() called during concurrent " 4334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "operation on the same file object."); 4344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else { 4354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* This should not happen unless someone is 4364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * carelessly playing with the PyFileObject 4374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * struct fields and/or its associated FILE 4384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * pointer. */ 4394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_SystemError, 4404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "PyFileObject locking error in " 4414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "destructor (refcnt <= 0 at close)."); 4424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 4444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* NULL out the FILE pointer before releasing the GIL, because 4464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * it will not be valid anymore after the close() function is 4474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * called. */ 4484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_fp = NULL; 4494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (local_close != NULL) { 4504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Issue #9295: must temporarily reset f_setbuf so that another 4514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm thread doesn't free it when running file_close() concurrently. 4524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Otherwise this close() will crash when flushing the buffer. */ 4534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_setbuf = NULL; 4544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_BEGIN_ALLOW_THREADS 4554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = 0; 4564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sts = (*local_close)(local_fp); 4574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_END_ALLOW_THREADS 4584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_setbuf = local_setbuf; 4594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (sts == EOF) 4604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyErr_SetFromErrno(PyExc_IOError); 4614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (sts != 0) 4624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyInt_FromLong((long)sts); 4634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_RETURN_NONE; 4664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 4674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 4694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyFile_FromFile(FILE *fp, char *name, char *mode, int (*close)(FILE *)) 4704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 4714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFileObject *f = (PyFileObject *)PyFile_Type.tp_new(&PyFile_Type, 4724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm NULL, NULL); 4734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f != NULL) { 4744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *o_name = PyString_FromString(name); 4754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (o_name == NULL) 4764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 4774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (fill_file_fields(f, fp, o_name, mode, close) == NULL) { 4784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(f); 4794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f = NULL; 4804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(o_name); 4824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *) f; 4844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 4854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 4874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyFile_FromString(char *name, char *mode) 4884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 4894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm extern int fclose(FILE *); 4904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFileObject *f; 4914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f = (PyFileObject *)PyFile_FromFile((FILE *)NULL, name, mode, fclose); 4934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f != NULL) { 4944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (open_the_file(f, name, mode) == NULL) { 4954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(f); 4964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f = NULL; 4974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)f; 5004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 5014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmvoid 5034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyFile_SetBufSize(PyObject *f, int bufsize) 5044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 5054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFileObject *file = (PyFileObject *)f; 5064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (bufsize >= 0) { 5074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int type; 5084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm switch (bufsize) { 5094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case 0: 5104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm type = _IONBF; 5114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 5124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef HAVE_SETVBUF 5134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case 1: 5144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm type = _IOLBF; 5154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bufsize = BUFSIZ; 5164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 5174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 5184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm default: 5194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm type = _IOFBF; 5204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifndef HAVE_SETVBUF 5214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bufsize = BUFSIZ; 5224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 5234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 5244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 5254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fflush(file->f_fp); 5264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (type == _IONBF) { 5274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyMem_Free(file->f_setbuf); 5284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm file->f_setbuf = NULL; 5294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else { 5304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm file->f_setbuf = (char *)PyMem_Realloc(file->f_setbuf, 5314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bufsize); 5324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 5334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef HAVE_SETVBUF 5344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm setvbuf(file->f_fp, file->f_setbuf, type, bufsize); 5354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else /* !HAVE_SETVBUF */ 5364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm setbuf(file->f_fp, file->f_setbuf); 5374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif /* !HAVE_SETVBUF */ 5384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 5394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 5404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Set the encoding used to output Unicode strings. 5424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Return 1 on success, 0 on failure. */ 5434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint 5454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyFile_SetEncoding(PyObject *f, const char *enc) 5464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 5474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyFile_SetEncodingAndErrors(f, enc, NULL); 5484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 5494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint 5514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyFile_SetEncodingAndErrors(PyObject *f, const char *enc, char* errors) 5524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 5534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFileObject *file = (PyFileObject*)f; 5544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *str, *oerrors; 5554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(PyFile_Check(f)); 5574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm str = PyString_FromString(enc); 5584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!str) 5594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 5604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (errors) { 5614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm oerrors = PyString_FromString(errors); 5624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!oerrors) { 5634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(str); 5644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 5654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 5664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else { 5674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm oerrors = Py_None; 5684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(Py_None); 5694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 5704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(file->f_encoding); 5714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm file->f_encoding = str; 5724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(file->f_errors); 5734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm file->f_errors = oerrors; 5744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 1; 5754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 5764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 5784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmerr_closed(void) 5794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 5804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_ValueError, "I/O operation on closed file"); 5814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 5824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 5834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 5854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmerr_mode(char *action) 5864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 5874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_IOError, "File not open for %s", action); 5884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 5894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 5904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Refuse regular file I/O if there's data in the iteration-buffer. 5924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * Mixing them would cause data to arrive out of order, as the read* 5934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * methods don't use the iteration buffer. */ 5944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 5954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmerr_iterbuffered(void) 5964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 5974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_ValueError, 5984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "Mixing iteration and read methods would lose data"); 5994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 6004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 6014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic void drop_readahead(PyFileObject *); 6034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Methods */ 6054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic void 6074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfile_dealloc(PyFileObject *f) 6084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 6094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *ret; 6104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->weakreflist != NULL) 6114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject_ClearWeakRefs((PyObject *) f); 6124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ret = close_the_file(f); 6134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!ret) { 6144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PySys_WriteStderr("close failed in file object destructor:\n"); 6154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Print(); 6164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 6174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 6184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(ret); 6194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 6204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyMem_Free(f->f_setbuf); 6214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(f->f_name); 6224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(f->f_mode); 6234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(f->f_encoding); 6244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(f->f_errors); 6254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm drop_readahead(f); 6264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_TYPE(f)->tp_free((PyObject *)f); 6274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 6284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 6304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfile_repr(PyFileObject *f) 6314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 6324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyUnicode_Check(f->f_name)) { 6334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef Py_USING_UNICODE 6344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *ret = NULL; 6354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *name = PyUnicode_AsUnicodeEscapeString(f->f_name); 6364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm const char *name_str = name ? PyString_AsString(name) : "?"; 6374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ret = PyString_FromFormat("<%s file u'%s', mode '%s' at %p>", 6384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_fp == NULL ? "closed" : "open", 6394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm name_str, 6404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_AsString(f->f_mode), 6414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f); 6424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(name); 6434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return ret; 6444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 6454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else { 6464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyString_FromFormat("<%s file '%s', mode '%s' at %p>", 6474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_fp == NULL ? "closed" : "open", 6484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_AsString(f->f_name), 6494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_AsString(f->f_mode), 6504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f); 6514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 6524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 6534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 6554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfile_close(PyFileObject *f) 6564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 6574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *sts = close_the_file(f); 6584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (sts) { 6594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyMem_Free(f->f_setbuf); 6604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_setbuf = NULL; 6614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 6624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return sts; 6634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 6644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Our very own off_t-like type, 64-bit if possible */ 6674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if !defined(HAVE_LARGEFILE_SUPPORT) 6684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmtypedef off_t Py_off_t; 6694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#elif SIZEOF_OFF_T >= 8 6704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmtypedef off_t Py_off_t; 6714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#elif SIZEOF_FPOS_T >= 8 6724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmtypedef fpos_t Py_off_t; 6734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 6744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#error "Large file support, but neither off_t nor fpos_t is large enough." 6754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 6764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* a portable fseek() function 6794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0 on success, non-zero on failure (with errno set) */ 6804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int 6814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm_portable_fseek(FILE *fp, Py_off_t offset, int whence) 6824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 6834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if !defined(HAVE_LARGEFILE_SUPPORT) 6844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return fseek(fp, offset, whence); 6854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#elif defined(HAVE_FSEEKO) && SIZEOF_OFF_T >= 8 6864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return fseeko(fp, offset, whence); 6874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#elif defined(HAVE_FSEEK64) 6884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return fseek64(fp, offset, whence); 6894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#elif defined(__BEOS__) 6904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return _fseek(fp, offset, whence); 6914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#elif SIZEOF_FPOS_T >= 8 6924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* lacking a 64-bit capable fseek(), use a 64-bit capable fsetpos() 6934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm and fgetpos() to implement fseek()*/ 6944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fpos_t pos; 6954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm switch (whence) { 6964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case SEEK_END: 6974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef MS_WINDOWS 6984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fflush(fp); 6994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (_lseeki64(fileno(fp), 0, 2) == -1) 7004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 7014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 7024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (fseek(fp, 0, SEEK_END) != 0) 7034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 7044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 7054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* fall through */ 7064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case SEEK_CUR: 7074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (fgetpos(fp, &pos) != 0) 7084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 7094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm offset += pos; 7104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 7114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* case SEEK_SET: break; */ 7124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 7134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return fsetpos(fp, &offset); 7144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 7154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#error "Large file support, but no way to fseek." 7164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 7174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 7184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* a portable ftell() function 7214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Return -1 on failure with errno set appropriately, current file 7224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm position on success */ 7234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic Py_off_t 7244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm_portable_ftell(FILE* fp) 7254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 7264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if !defined(HAVE_LARGEFILE_SUPPORT) 7274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return ftell(fp); 7284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#elif defined(HAVE_FTELLO) && SIZEOF_OFF_T >= 8 7294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return ftello(fp); 7304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#elif defined(HAVE_FTELL64) 7314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return ftell64(fp); 7324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#elif SIZEOF_FPOS_T >= 8 7334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fpos_t pos; 7344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (fgetpos(fp, &pos) != 0) 7354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 7364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return pos; 7374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 7384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#error "Large file support, but no way to ftell." 7394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 7404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 7414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 7444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfile_seek(PyFileObject *f, PyObject *args) 7454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 7464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int whence; 7474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int ret; 7484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_off_t offset; 7494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *offobj, *off_index; 7504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_fp == NULL) 7524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_closed(); 7534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm drop_readahead(f); 7544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm whence = 0; 7554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyArg_ParseTuple(args, "O|i:seek", &offobj, &whence)) 7564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 7574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm off_index = PyNumber_Index(offobj); 7584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!off_index) { 7594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyFloat_Check(offobj)) 7604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 7614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Deprecated in 2.6 */ 7624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Clear(); 7634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyErr_WarnEx(PyExc_DeprecationWarning, 7644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "integer argument expected, got float", 7654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1) < 0) 7664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 7674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm off_index = offobj; 7684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(offobj); 7694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 7704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if !defined(HAVE_LARGEFILE_SUPPORT) 7714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm offset = PyInt_AsLong(off_index); 7724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 7734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm offset = PyLong_Check(off_index) ? 7744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLong_AsLongLong(off_index) : PyInt_AsLong(off_index); 7754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 7764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(off_index); 7774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyErr_Occurred()) 7784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 7794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_BEGIN_ALLOW_THREADS(f) 7814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = 0; 7824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ret = _portable_fseek(f->f_fp, offset, whence); 7834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_END_ALLOW_THREADS(f) 7844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (ret != 0) { 7864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetFromErrno(PyExc_IOError); 7874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm clearerr(f->f_fp); 7884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 7894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 7904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_skipnextlf = 0; 7914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(Py_None); 7924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return Py_None; 7934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 7944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef HAVE_FTRUNCATE 7974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 7984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfile_truncate(PyFileObject *f, PyObject *args) 7994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 8004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_off_t newsize; 8014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *newsizeobj = NULL; 8024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_off_t initialpos; 8034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int ret; 8044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_fp == NULL) 8064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_closed(); 8074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!f->writable) 8084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_mode("writing"); 8094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyArg_UnpackTuple(args, "truncate", 0, 1, &newsizeobj)) 8104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 8114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Get current file position. If the file happens to be open for 8134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * update and the last operation was an input operation, C doesn't 8144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * define what the later fflush() will do, but we promise truncate() 8154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * won't change the current position (and fflush() *does* change it 8164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * then at least on Windows). The easiest thing is to capture 8174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * current pos now and seek back to it at the end. 8184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 8194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_BEGIN_ALLOW_THREADS(f) 8204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = 0; 8214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm initialpos = _portable_ftell(f->f_fp); 8224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_END_ALLOW_THREADS(f) 8234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (initialpos == -1) 8244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto onioerror; 8254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Set newsize to current postion if newsizeobj NULL, else to the 8274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * specified value. 8284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 8294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (newsizeobj != NULL) { 8304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if !defined(HAVE_LARGEFILE_SUPPORT) 8314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newsize = PyInt_AsLong(newsizeobj); 8324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 8334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newsize = PyLong_Check(newsizeobj) ? 8344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLong_AsLongLong(newsizeobj) : 8354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyInt_AsLong(newsizeobj); 8364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 8374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyErr_Occurred()) 8384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 8394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 8404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else /* default to current position */ 8414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newsize = initialpos; 8424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Flush the stream. We're mixing stream-level I/O with lower-level 8444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * I/O, and a flush may be necessary to synch both platform views 8454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * of the current file state. 8464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 8474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_BEGIN_ALLOW_THREADS(f) 8484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = 0; 8494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ret = fflush(f->f_fp); 8504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_END_ALLOW_THREADS(f) 8514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (ret != 0) 8524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto onioerror; 8534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef MS_WINDOWS 8554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* MS _chsize doesn't work if newsize doesn't fit in 32 bits, 8564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm so don't even try using it. */ 8574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { 8584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm HANDLE hFile; 8594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Have to move current pos to desired endpoint on Windows. */ 8614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_BEGIN_ALLOW_THREADS(f) 8624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = 0; 8634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ret = _portable_fseek(f->f_fp, newsize, SEEK_SET) != 0; 8644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_END_ALLOW_THREADS(f) 8654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (ret) 8664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto onioerror; 8674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Truncate. Note that this may grow the file! */ 8694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_BEGIN_ALLOW_THREADS(f) 8704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = 0; 8714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm hFile = (HANDLE)_get_osfhandle(fileno(f->f_fp)); 8724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ret = hFile == (HANDLE)-1; 8734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (ret == 0) { 8744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ret = SetEndOfFile(hFile) == 0; 8754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (ret) 8764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = EACCES; 8774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 8784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_END_ALLOW_THREADS(f) 8794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (ret) 8804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto onioerror; 8814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 8824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 8834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_BEGIN_ALLOW_THREADS(f) 8844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = 0; 8854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ret = ftruncate(fileno(f->f_fp), newsize); 8864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_END_ALLOW_THREADS(f) 8874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (ret != 0) 8884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto onioerror; 8894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif /* !MS_WINDOWS */ 8904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Restore original file position. */ 8924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_BEGIN_ALLOW_THREADS(f) 8934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = 0; 8944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ret = _portable_fseek(f->f_fp, initialpos, SEEK_SET) != 0; 8954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_END_ALLOW_THREADS(f) 8964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (ret) 8974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto onioerror; 8984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(Py_None); 9004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return Py_None; 9014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmonioerror: 9034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetFromErrno(PyExc_IOError); 9044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm clearerr(f->f_fp); 9054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 9064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 9074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif /* HAVE_FTRUNCATE */ 9084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 9104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfile_tell(PyFileObject *f) 9114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 9124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_off_t pos; 9134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_fp == NULL) 9154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_closed(); 9164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_BEGIN_ALLOW_THREADS(f) 9174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = 0; 9184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pos = _portable_ftell(f->f_fp); 9194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_END_ALLOW_THREADS(f) 9204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (pos == -1) { 9224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetFromErrno(PyExc_IOError); 9234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm clearerr(f->f_fp); 9244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 9254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 9264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_skipnextlf) { 9274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int c; 9284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = GETC(f->f_fp); 9294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (c == '\n') { 9304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_newlinetypes |= NEWLINE_CRLF; 9314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pos++; 9324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_skipnextlf = 0; 9334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else if (c != EOF) ungetc(c, f->f_fp); 9344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 9354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if !defined(HAVE_LARGEFILE_SUPPORT) 9364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyInt_FromLong(pos); 9374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 9384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyLong_FromLongLong(pos); 9394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 9404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 9414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 9434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfile_fileno(PyFileObject *f) 9444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 9454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_fp == NULL) 9464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_closed(); 9474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyInt_FromLong((long) fileno(f->f_fp)); 9484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 9494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 9514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfile_flush(PyFileObject *f) 9524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 9534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int res; 9544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_fp == NULL) 9564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_closed(); 9574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_BEGIN_ALLOW_THREADS(f) 9584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = 0; 9594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = fflush(f->f_fp); 9604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_END_ALLOW_THREADS(f) 9614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (res != 0) { 9624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetFromErrno(PyExc_IOError); 9634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm clearerr(f->f_fp); 9644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 9654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 9664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(Py_None); 9674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return Py_None; 9684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 9694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 9714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfile_isatty(PyFileObject *f) 9724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 9734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long res; 9744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_fp == NULL) 9754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_closed(); 9764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_BEGIN_ALLOW_THREADS(f) 9774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = isatty((int)fileno(f->f_fp)); 9784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_END_ALLOW_THREADS(f) 9794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyBool_FromLong(res); 9804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 9814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if BUFSIZ < 8192 9844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define SMALLCHUNK 8192 9854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 9864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define SMALLCHUNK BUFSIZ 9874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 9884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if SIZEOF_INT < 4 9904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define BIGCHUNK (512 * 32) 9914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 9924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define BIGCHUNK (512 * 1024) 9934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 9944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic size_t 9964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmnew_buffersize(PyFileObject *f, size_t currentsize) 9974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 9984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef HAVE_FSTAT 9994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm off_t pos, end; 10004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm struct stat st; 10014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (fstat(fileno(f->f_fp), &st) == 0) { 10024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm end = st.st_size; 10034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* The following is not a bug: we really need to call lseek() 10044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *and* ftell(). The reason is that some stdio libraries 10054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm mistakenly flush their buffer when ftell() is called and 10064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm the lseek() call it makes fails, thereby throwing away 10074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm data that cannot be recovered in any way. To avoid this, 10084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm we first test lseek(), and only call ftell() if lseek() 10094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm works. We can't use the lseek() value either, because we 10104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm need to take the amount of buffered data into account. 10114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (Yet another reason why stdio stinks. :-) */ 10124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pos = lseek(fileno(f->f_fp), 0L, SEEK_CUR); 10134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (pos >= 0) { 10144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pos = ftell(f->f_fp); 10154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (pos < 0) 10174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm clearerr(f->f_fp); 10184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (end > pos && pos >= 0) 10194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return currentsize + end - pos + 1; 10204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Add 1 so if the file were to grow we'd notice. */ 10214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 10234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (currentsize > SMALLCHUNK) { 10244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Keep doubling until we reach BIGCHUNK; 10254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm then keep adding BIGCHUNK. */ 10264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (currentsize <= BIGCHUNK) 10274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return currentsize + currentsize; 10284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 10294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return currentsize + BIGCHUNK; 10304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return currentsize + SMALLCHUNK; 10324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 10334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if defined(EWOULDBLOCK) && defined(EAGAIN) && EWOULDBLOCK != EAGAIN 10354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define BLOCKED_ERRNO(x) ((x) == EWOULDBLOCK || (x) == EAGAIN) 10364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 10374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef EWOULDBLOCK 10384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define BLOCKED_ERRNO(x) ((x) == EWOULDBLOCK) 10394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 10404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef EAGAIN 10414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define BLOCKED_ERRNO(x) ((x) == EAGAIN) 10424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 10434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define BLOCKED_ERRNO(x) 0 10444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 10454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 10464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 10474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 10494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfile_read(PyFileObject *f, PyObject *args) 10504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 10514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long bytesrequested = -1; 10524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_t bytesread, buffersize, chunksize; 10534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *v; 10544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_fp == NULL) 10564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_closed(); 10574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!f->readable) 10584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_mode("reading"); 10594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* refuse to mix with f.next() */ 10604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_buf != NULL && 10614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (f->f_bufend - f->f_bufptr) > 0 && 10624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_buf[0] != '\0') 10634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_iterbuffered(); 10644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyArg_ParseTuple(args, "|l:read", &bytesrequested)) 10654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 10664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (bytesrequested < 0) 10674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm buffersize = new_buffersize(f, (size_t)0); 10684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 10694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm buffersize = bytesrequested; 10704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (buffersize > PY_SSIZE_T_MAX) { 10714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_OverflowError, 10724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "requested number of bytes is more than a Python string can hold"); 10734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 10744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = PyString_FromStringAndSize((char *)NULL, buffersize); 10764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v == NULL) 10774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 10784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bytesread = 0; 10794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (;;) { 10804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_BEGIN_ALLOW_THREADS(f) 10814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = 0; 10824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm chunksize = Py_UniversalNewlineFread(BUF(v) + bytesread, 10834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm buffersize - bytesread, f->f_fp, (PyObject *)f); 10844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_END_ALLOW_THREADS(f) 10854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (chunksize == 0) { 10864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!ferror(f->f_fp)) 10874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 10884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm clearerr(f->f_fp); 10894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* When in non-blocking mode, data shouldn't 10904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * be discarded if a blocking signal was 10914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * received. That will also happen if 10924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * chunksize != 0, but bytesread < buffersize. */ 10934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (bytesread > 0 && BLOCKED_ERRNO(errno)) 10944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 10954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetFromErrno(PyExc_IOError); 10964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 10974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 10984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bytesread += chunksize; 11004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (bytesread < buffersize) { 11014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm clearerr(f->f_fp); 11024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 11034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 11044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (bytesrequested < 0) { 11054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm buffersize = new_buffersize(f, buffersize); 11064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (_PyString_Resize(&v, buffersize) < 0) 11074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 11084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else { 11094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Got what was requested. */ 11104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 11114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 11124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 11134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (bytesread != buffersize && _PyString_Resize(&v, bytesread)) 11144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 11154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return v; 11164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 11174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 11194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfile_readinto(PyFileObject *f, PyObject *args) 11204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 11214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *ptr; 11224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t ntodo; 11234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t ndone, nnow; 11244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_buffer pbuf; 11254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_fp == NULL) 11274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_closed(); 11284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!f->readable) 11294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_mode("reading"); 11304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* refuse to mix with f.next() */ 11314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_buf != NULL && 11324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (f->f_bufend - f->f_bufptr) > 0 && 11334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_buf[0] != '\0') 11344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_iterbuffered(); 11354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyArg_ParseTuple(args, "w*", &pbuf)) 11364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 11374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ptr = pbuf.buf; 11384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ntodo = pbuf.len; 11394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ndone = 0; 11404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (ntodo > 0) { 11414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_BEGIN_ALLOW_THREADS(f) 11424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = 0; 11434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nnow = Py_UniversalNewlineFread(ptr+ndone, ntodo, f->f_fp, 11444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (PyObject *)f); 11454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_END_ALLOW_THREADS(f) 11464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (nnow == 0) { 11474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!ferror(f->f_fp)) 11484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 11494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetFromErrno(PyExc_IOError); 11504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm clearerr(f->f_fp); 11514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyBuffer_Release(&pbuf); 11524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 11534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 11544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ndone += nnow; 11554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ntodo -= nnow; 11564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 11574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyBuffer_Release(&pbuf); 11584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyInt_FromSsize_t(ndone); 11594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 11604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/************************************************************************** 11624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmRoutine to get next line using platform fgets(). 11634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmUnder MSVC 6: 11654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm+ MS threadsafe getc is very slow (multiple layers of function calls before+ 11674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm after each character, to lock+unlock the stream). 11684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm+ The stream-locking functions are MS-internal -- can't access them from user 11694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm code. 11704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm+ There's nothing Tim could find in the MS C or platform SDK libraries that 11714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm can worm around this. 11724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm+ MS fgets locks/unlocks only once per line; it's the only hook we have. 11734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmSo we use fgets for speed(!), despite that it's painful. 11754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmMS realloc is also slow. 11774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmReports from other platforms on this method vs getc_unlocked (which MS doesn't 11794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmhave): 11804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Linux a wash 11814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Solaris a wash 11824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Tru64 Unix getline_via_fgets significantly faster 11834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmCAUTION: The C std isn't clear about this: in those cases where fgets 11854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmwrites something into the buffer, can it write into any position beyond the 11864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmrequired trailing null byte? MSVC 6 fgets does not, and no platform is (yet) 11874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmknown on which it does; and it would be a strange way to code fgets. Still, 11884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmgetline_via_fgets may not work correctly if it does. The std test 11894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmtest_bufio.py should fail if platform fgets() routinely writes beyond the 11904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmtrailing null byte. #define DONT_USE_FGETS_IN_GETLINE to disable this code. 11914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm**************************************************************************/ 11924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Use this routine if told to, or by default on non-get_unlocked() 11944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * platforms unless told not to. Yikes! Let's spell that out: 11954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * On a platform with getc_unlocked(): 11964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * By default, use getc_unlocked(). 11974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * If you want to use fgets() instead, #define USE_FGETS_IN_GETLINE. 11984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * On a platform without getc_unlocked(): 11994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * By default, use fgets(). 12004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * If you don't want to use fgets(), #define DONT_USE_FGETS_IN_GETLINE. 12014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 12024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if !defined(USE_FGETS_IN_GETLINE) && !defined(HAVE_GETC_UNLOCKED) 12034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define USE_FGETS_IN_GETLINE 12044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 12054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if defined(DONT_USE_FGETS_IN_GETLINE) && defined(USE_FGETS_IN_GETLINE) 12074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#undef USE_FGETS_IN_GETLINE 12084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 12094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef USE_FGETS_IN_GETLINE 12114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject* 12124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmgetline_via_fgets(PyFileObject *f, FILE *fp) 12134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 12144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* INITBUFSIZE is the maximum line length that lets us get away with the fast 12154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * no-realloc, one-fgets()-call path. Boosting it isn't free, because we have 12164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * to fill this much of the buffer with a known value in order to figure out 12174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * how much of the buffer fgets() overwrites. So if INITBUFSIZE is larger 12184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * than "most" lines, we waste time filling unused buffer slots. 100 is 12194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * surely adequate for most peoples' email archives, chewing over source code, 12204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * etc -- "regular old text files". 12214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * MAXBUFSIZE is the maximum line length that lets us get away with the less 12224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * fast (but still zippy) no-realloc, two-fgets()-call path. See above for 12234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * cautions about boosting that. 300 was chosen because the worst real-life 12244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * text-crunching job reported on Python-Dev was a mail-log crawler where over 12254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * half the lines were 254 chars. 12264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 12274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define INITBUFSIZE 100 12284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define MAXBUFSIZE 300 12294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char* p; /* temp */ 12304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char buf[MAXBUFSIZE]; 12314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject* v; /* the string object result */ 12324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char* pvfree; /* address of next free slot */ 12334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char* pvend; /* address one beyond last free slot */ 12344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_t nfree; /* # of free buffer slots; pvend-pvfree */ 12354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_t total_v_size; /* total # of slots in buffer */ 12364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_t increment; /* amount to increment the buffer */ 12374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_t prev_v_size; 12384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Optimize for normal case: avoid _PyString_Resize if at all 12404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * possible via first reading into stack buffer "buf". 12414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 12424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm total_v_size = INITBUFSIZE; /* start small and pray */ 12434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pvfree = buf; 12444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (;;) { 12454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_BEGIN_ALLOW_THREADS(f) 12464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pvend = buf + total_v_size; 12474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nfree = pvend - pvfree; 12484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memset(pvfree, '\n', nfree); 12494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(nfree < INT_MAX); /* Should be atmost MAXBUFSIZE */ 12504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm p = fgets(pvfree, (int)nfree, fp); 12514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_END_ALLOW_THREADS(f) 12524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (p == NULL) { 12544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm clearerr(fp); 12554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyErr_CheckSignals()) 12564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 12574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = PyString_FromStringAndSize(buf, pvfree - buf); 12584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return v; 12594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 12604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* fgets read *something* */ 12614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm p = memchr(pvfree, '\n', nfree); 12624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (p != NULL) { 12634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Did the \n come from fgets or from us? 12644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * Since fgets stops at the first \n, and then writes 12654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * \0, if it's from fgets a \0 must be next. But if 12664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * that's so, it could not have come from us, since 12674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * the \n's we filled the buffer with have only more 12684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * \n's to the right. 12694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 12704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (p+1 < pvend && *(p+1) == '\0') { 12714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* It's from fgets: we win! In particular, 12724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * we haven't done any mallocs yet, and can 12734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * build the final result on the first try. 12744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 12754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++p; /* include \n from fgets */ 12764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 12774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 12784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Must be from us: fgets didn't fill the 12794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * buffer and didn't find a newline, so it 12804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * must be the last and newline-free line of 12814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * the file. 12824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 12834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(p > pvfree && *(p-1) == '\0'); 12844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm --p; /* don't include \0 from fgets */ 12854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 12864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = PyString_FromStringAndSize(buf, p - buf); 12874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return v; 12884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 12894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* yuck: fgets overwrote all the newlines, i.e. the entire 12904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * buffer. So this line isn't over yet, or maybe it is but 12914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * we're exactly at EOF. If we haven't already, try using the 12924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * rest of the stack buffer. 12934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 12944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(*(pvend-1) == '\0'); 12954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (pvfree == buf) { 12964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pvfree = pvend - 1; /* overwrite trailing null */ 12974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm total_v_size = MAXBUFSIZE; 12984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 12994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 13004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 13014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 13024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* The stack buffer isn't big enough; malloc a string object and read 13044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * into its buffer. 13054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 13064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm total_v_size = MAXBUFSIZE << 1; 13074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = PyString_FromStringAndSize((char*)NULL, (int)total_v_size); 13084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v == NULL) 13094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return v; 13104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* copy over everything except the last null byte */ 13114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memcpy(BUF(v), buf, MAXBUFSIZE-1); 13124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pvfree = BUF(v) + MAXBUFSIZE - 1; 13134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Keep reading stuff into v; if it ever ends successfully, break 13154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * after setting p one beyond the end of the line. The code here is 13164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * very much like the code above, except reads into v's buffer; see 13174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * the code above for detailed comments about the logic. 13184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 13194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (;;) { 13204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_BEGIN_ALLOW_THREADS(f) 13214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pvend = BUF(v) + total_v_size; 13224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nfree = pvend - pvfree; 13234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memset(pvfree, '\n', nfree); 13244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(nfree < INT_MAX); 13254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm p = fgets(pvfree, (int)nfree, fp); 13264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_END_ALLOW_THREADS(f) 13274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (p == NULL) { 13294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm clearerr(fp); 13304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyErr_CheckSignals()) { 13314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 13324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 13334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 13344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm p = pvfree; 13354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 13364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 13374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm p = memchr(pvfree, '\n', nfree); 13384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (p != NULL) { 13394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (p+1 < pvend && *(p+1) == '\0') { 13404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* \n came from fgets */ 13414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++p; 13424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 13434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 13444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* \n came from us; last line of file, no newline */ 13454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(p > pvfree && *(p-1) == '\0'); 13464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm --p; 13474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 13484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 13494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* expand buffer and try again */ 13504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(*(pvend-1) == '\0'); 13514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm increment = total_v_size >> 2; /* mild exponential growth */ 13524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm prev_v_size = total_v_size; 13534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm total_v_size += increment; 13544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* check for overflow */ 13554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (total_v_size <= prev_v_size || 13564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm total_v_size > PY_SSIZE_T_MAX) { 13574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_OverflowError, 13584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "line is longer than a Python string can hold"); 13594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 13604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 13614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 13624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (_PyString_Resize(&v, (int)total_v_size) < 0) 13634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 13644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* overwrite the trailing null byte */ 13654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pvfree = BUF(v) + (prev_v_size - 1); 13664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 13674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (BUF(v) + total_v_size != p && _PyString_Resize(&v, p - BUF(v))) 13684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 13694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return v; 13704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#undef INITBUFSIZE 13714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#undef MAXBUFSIZE 13724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 13734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif /* ifdef USE_FGETS_IN_GETLINE */ 13744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Internal routine to get a line. 13764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Size argument interpretation: 13774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm > 0: max length; 13784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm <= 0: read arbitrary line 13794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm*/ 13804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 13824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmget_line(PyFileObject *f, int n) 13834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 13844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE *fp = f->f_fp; 13854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int c; 13864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *buf, *end; 13874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_t total_v_size; /* total # of slots in buffer */ 13884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_t used_v_size; /* # used slots in buffer */ 13894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_t increment; /* amount to increment the buffer */ 13904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *v; 13914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int newlinetypes = f->f_newlinetypes; 13924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int skipnextlf = f->f_skipnextlf; 13934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int univ_newline = f->f_univ_newline; 13944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if defined(USE_FGETS_IN_GETLINE) 13964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (n <= 0 && !univ_newline ) 13974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return getline_via_fgets(f, fp); 13984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 13994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm total_v_size = n > 0 ? n : 100; 14004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = PyString_FromStringAndSize((char *)NULL, total_v_size); 14014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v == NULL) 14024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 14034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm buf = BUF(v); 14044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm end = buf + total_v_size; 14054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (;;) { 14074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_BEGIN_ALLOW_THREADS(f) 14084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FLOCKFILE(fp); 14094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (univ_newline) { 14104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = 'x'; /* Shut up gcc warning */ 14114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while ( buf != end && (c = GETC(fp)) != EOF ) { 14124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (skipnextlf ) { 14134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm skipnextlf = 0; 14144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (c == '\n') { 14154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Seeing a \n here with 14164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * skipnextlf true means we 14174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * saw a \r before. 14184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 14194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newlinetypes |= NEWLINE_CRLF; 14204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = GETC(fp); 14214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (c == EOF) break; 14224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else { 14234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newlinetypes |= NEWLINE_CR; 14244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 14254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 14264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (c == '\r') { 14274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm skipnextlf = 1; 14284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = '\n'; 14294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else if ( c == '\n') 14304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newlinetypes |= NEWLINE_LF; 14314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *buf++ = c; 14324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (c == '\n') break; 14334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 14344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ( c == EOF && skipnextlf ) 14354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newlinetypes |= NEWLINE_CR; 14364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else /* If not universal newlines use the normal loop */ 14374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while ((c = GETC(fp)) != EOF && 14384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (*buf++ = c) != '\n' && 14394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm buf != end) 14404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ; 14414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FUNLOCKFILE(fp); 14424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_END_ALLOW_THREADS(f) 14434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_newlinetypes = newlinetypes; 14444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_skipnextlf = skipnextlf; 14454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (c == '\n') 14464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 14474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (c == EOF) { 14484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (ferror(fp)) { 14494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetFromErrno(PyExc_IOError); 14504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm clearerr(fp); 14514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 14524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 14534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 14544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm clearerr(fp); 14554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyErr_CheckSignals()) { 14564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 14574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 14584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 14594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 14604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 14614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Must be because buf == end */ 14624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (n > 0) 14634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 14644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm used_v_size = total_v_size; 14654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm increment = total_v_size >> 2; /* mild exponential growth */ 14664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm total_v_size += increment; 14674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (total_v_size > PY_SSIZE_T_MAX) { 14684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_OverflowError, 14694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "line is longer than a Python string can hold"); 14704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 14714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 14724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 14734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (_PyString_Resize(&v, total_v_size) < 0) 14744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 14754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm buf = BUF(v) + used_v_size; 14764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm end = BUF(v) + total_v_size; 14774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 14784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm used_v_size = buf - BUF(v); 14804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (used_v_size != total_v_size && _PyString_Resize(&v, used_v_size)) 14814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 14824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return v; 14834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 14844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* External C interface */ 14864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 14884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyFile_GetLine(PyObject *f, int n) 14894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 14904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *result; 14914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f == NULL) { 14934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_BadInternalCall(); 14944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 14954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 14964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyFile_Check(f)) { 14984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFileObject *fo = (PyFileObject *)f; 14994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (fo->f_fp == NULL) 15004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_closed(); 15014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!fo->readable) 15024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_mode("reading"); 15034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* refuse to mix with f.next() */ 15044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (fo->f_buf != NULL && 15054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (fo->f_bufend - fo->f_bufptr) > 0 && 15064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fo->f_buf[0] != '\0') 15074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_iterbuffered(); 15084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = get_line(fo, n); 15094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 15114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *reader; 15124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *args; 15134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm reader = PyObject_GetAttrString(f, "readline"); 15154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (reader == NULL) 15164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 15174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (n <= 0) 15184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm args = PyTuple_New(0); 15194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 15204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm args = Py_BuildValue("(i)", n); 15214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (args == NULL) { 15224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(reader); 15234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 15244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = PyEval_CallObject(reader, args); 15264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(reader); 15274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(args); 15284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (result != NULL && !PyString_Check(result) && 15294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm !PyUnicode_Check(result)) { 15304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(result); 15314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = NULL; 15324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, 15334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "object.readline() returned non-string"); 15344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (n < 0 && result != NULL && PyString_Check(result)) { 15384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *s = PyString_AS_STRING(result); 15394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t len = PyString_GET_SIZE(result); 15404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (len == 0) { 15414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(result); 15424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = NULL; 15434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_EOFError, 15444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "EOF when reading a line"); 15454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (s[len-1] == '\n') { 15474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (result->ob_refcnt == 1) { 15484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (_PyString_Resize(&result, len-1)) 15494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 15504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 15524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *v; 15534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = PyString_FromStringAndSize(s, len-1); 15544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(result); 15554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = v; 15564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef Py_USING_UNICODE 15604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (n < 0 && result != NULL && PyUnicode_Check(result)) { 15614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_UNICODE *s = PyUnicode_AS_UNICODE(result); 15624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t len = PyUnicode_GET_SIZE(result); 15634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (len == 0) { 15644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(result); 15654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = NULL; 15664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_EOFError, 15674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "EOF when reading a line"); 15684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (s[len-1] == '\n') { 15704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (result->ob_refcnt == 1) 15714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyUnicode_Resize(&result, len-1); 15724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 15734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *v; 15744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = PyUnicode_FromUnicode(s, len-1); 15754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(result); 15764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = v; 15774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 15814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return result; 15824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 15834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Python method */ 15854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 15874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfile_readline(PyFileObject *f, PyObject *args) 15884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 15894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int n = -1; 15904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_fp == NULL) 15924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_closed(); 15934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!f->readable) 15944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_mode("reading"); 15954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* refuse to mix with f.next() */ 15964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_buf != NULL && 15974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (f->f_bufend - f->f_bufptr) > 0 && 15984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_buf[0] != '\0') 15994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_iterbuffered(); 16004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyArg_ParseTuple(args, "|i:readline", &n)) 16014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 16024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (n == 0) 16034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyString_FromString(""); 16044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (n < 0) 16054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = 0; 16064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return get_line(f, n); 16074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 16084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 16104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfile_readlines(PyFileObject *f, PyObject *args) 16114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 16124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long sizehint = 0; 16134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *list = NULL; 16144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *line; 16154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char small_buffer[SMALLCHUNK]; 16164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *buffer = small_buffer; 16174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_t buffersize = SMALLCHUNK; 16184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *big_buffer = NULL; 16194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_t nfilled = 0; 16204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_t nread; 16214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_t totalread = 0; 16224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *p, *q, *end; 16234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int err; 16244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int shortread = 0; 16254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_fp == NULL) 16274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_closed(); 16284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!f->readable) 16294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_mode("reading"); 16304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* refuse to mix with f.next() */ 16314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_buf != NULL && 16324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (f->f_bufend - f->f_bufptr) > 0 && 16334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_buf[0] != '\0') 16344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_iterbuffered(); 16354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyArg_ParseTuple(args, "|l:readlines", &sizehint)) 16364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 16374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((list = PyList_New(0)) == NULL) 16384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 16394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (;;) { 16404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (shortread) 16414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nread = 0; 16424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 16434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_BEGIN_ALLOW_THREADS(f) 16444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = 0; 16454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nread = Py_UniversalNewlineFread(buffer+nfilled, 16464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm buffersize-nfilled, f->f_fp, (PyObject *)f); 16474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_END_ALLOW_THREADS(f) 16484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm shortread = (nread < buffersize-nfilled); 16494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 16504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (nread == 0) { 16514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sizehint = 0; 16524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!ferror(f->f_fp)) 16534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 16544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetFromErrno(PyExc_IOError); 16554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm clearerr(f->f_fp); 16564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 16574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 16584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm totalread += nread; 16594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm p = (char *)memchr(buffer+nfilled, '\n', nread); 16604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (p == NULL) { 16614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Need a larger buffer to fit this line */ 16624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nfilled += nread; 16634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm buffersize *= 2; 16644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (buffersize > PY_SSIZE_T_MAX) { 16654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_OverflowError, 16664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "line is longer than a Python string can hold"); 16674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 16684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 16694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (big_buffer == NULL) { 16704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Create the big buffer */ 16714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm big_buffer = PyString_FromStringAndSize( 16724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm NULL, buffersize); 16734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (big_buffer == NULL) 16744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 16754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm buffer = PyString_AS_STRING(big_buffer); 16764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memcpy(buffer, small_buffer, nfilled); 16774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 16784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 16794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Grow the big buffer */ 16804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ( _PyString_Resize(&big_buffer, buffersize) < 0 ) 16814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 16824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm buffer = PyString_AS_STRING(big_buffer); 16834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 16844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 16854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 16864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm end = buffer+nfilled+nread; 16874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm q = buffer; 16884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm do { 16894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Process complete lines */ 16904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm p++; 16914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm line = PyString_FromStringAndSize(q, p-q); 16924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (line == NULL) 16934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 16944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyList_Append(list, line); 16954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(line); 16964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err != 0) 16974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 16984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm q = p; 16994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm p = (char *)memchr(q, '\n', end-q); 17004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } while (p != NULL); 17014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Move the remaining incomplete line to the start */ 17024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nfilled = end-q; 17034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memmove(buffer, q, nfilled); 17044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (sizehint > 0) 17054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (totalread >= (size_t)sizehint) 17064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 17074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 17084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (nfilled != 0) { 17094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Partial last line */ 17104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm line = PyString_FromStringAndSize(buffer, nfilled); 17114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (line == NULL) 17124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 17134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (sizehint > 0) { 17144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Need to complete the last line */ 17154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *rest = get_line(f, 0); 17164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (rest == NULL) { 17174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(line); 17184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 17194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 17204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_Concat(&line, rest); 17214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(rest); 17224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (line == NULL) 17234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 17244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 17254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyList_Append(list, line); 17264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(line); 17274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err != 0) 17284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 17294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 17304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmcleanup: 17324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(big_buffer); 17334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return list; 17344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmerror: 17364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_CLEAR(list); 17374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto cleanup; 17384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 17394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 17414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfile_write(PyFileObject *f, PyObject *args) 17424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 17434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_buffer pbuf; 17444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm const char *s; 17454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t n, n2; 17464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *encoded = NULL; 17474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_fp == NULL) 17494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_closed(); 17504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!f->writable) 17514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_mode("writing"); 17524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_binary) { 17534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyArg_ParseTuple(args, "s*", &pbuf)) 17544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 17554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = pbuf.buf; 17564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = pbuf.len; 17574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 17584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 17594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm const char *encoding, *errors; 17604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *text; 17614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyArg_ParseTuple(args, "O", &text)) 17624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 17634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyString_Check(text)) { 17654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = PyString_AS_STRING(text); 17664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = PyString_GET_SIZE(text); 17674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else if (PyUnicode_Check(text)) { 17684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_encoding != Py_None) 17694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm encoding = PyString_AS_STRING(f->f_encoding); 17704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 17714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm encoding = PyUnicode_GetDefaultEncoding(); 17724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_errors != Py_None) 17734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errors = PyString_AS_STRING(f->f_errors); 17744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 17754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errors = "strict"; 17764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm encoded = PyUnicode_AsEncodedString(text, encoding, errors); 17774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (encoded == NULL) 17784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 17794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = PyString_AS_STRING(encoded); 17804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = PyString_GET_SIZE(encoded); 17814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else { 17824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyObject_AsCharBuffer(text, &s, &n)) 17834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 17844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 17854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 17864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_softspace = 0; 17874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_BEGIN_ALLOW_THREADS(f) 17884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = 0; 17894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n2 = fwrite(s, 1, n, f->f_fp); 17904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_END_ALLOW_THREADS(f) 17914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(encoded); 17924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_binary) 17934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyBuffer_Release(&pbuf); 17944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (n2 != n) { 17954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetFromErrno(PyExc_IOError); 17964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm clearerr(f->f_fp); 17974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 17984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 17994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(Py_None); 18004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return Py_None; 18014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 18024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 18044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfile_writelines(PyFileObject *f, PyObject *seq) 18054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 18064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define CHUNKSIZE 1000 18074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *list, *line; 18084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *it; /* iter(seq) */ 18094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *result; 18104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int index, islist; 18114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i, j, nwritten, len; 18124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(seq != NULL); 18144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_fp == NULL) 18154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_closed(); 18164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!f->writable) 18174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_mode("writing"); 18184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = NULL; 18204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm list = NULL; 18214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm islist = PyList_Check(seq); 18224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (islist) 18234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm it = NULL; 18244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 18254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm it = PyObject_GetIter(seq); 18264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (it == NULL) { 18274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, 18284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "writelines() requires an iterable argument"); 18294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 18304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 18314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* From here on, fail by going to error, to reclaim "it". */ 18324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm list = PyList_New(CHUNKSIZE); 18334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (list == NULL) 18344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 18354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 18364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Strategy: slurp CHUNKSIZE lines into a private list, 18384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm checking that they are all strings, then write that list 18394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm without holding the interpreter lock, then come back for more. */ 18404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (index = 0; ; index += CHUNKSIZE) { 18414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (islist) { 18424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(list); 18434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm list = PyList_GetSlice(seq, index, index+CHUNKSIZE); 18444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (list == NULL) 18454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 18464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm j = PyList_GET_SIZE(list); 18474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 18484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 18494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (j = 0; j < CHUNKSIZE; j++) { 18504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm line = PyIter_Next(it); 18514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (line == NULL) { 18524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyErr_Occurred()) 18534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 18544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 18554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 18564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyList_SetItem(list, j, line); 18574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 18584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* The iterator might have closed the file on us. */ 18594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_fp == NULL) { 18604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err_closed(); 18614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 18624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 18634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 18644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (j == 0) 18654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 18664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Check that all entries are indeed strings. If not, 18684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm apply the same rules as for file.write() and 18694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm convert the results to strings. This is slow, but 18704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm seems to be the only way since all conversion APIs 18714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm could potentially execute Python code. */ 18724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < j; i++) { 18734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *v = PyList_GET_ITEM(list, i); 18744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyString_Check(v)) { 18754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm const char *buffer; 18764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (((f->f_binary && 18774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject_AsReadBuffer(v, 18784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (const void**)&buffer, 18794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm &len)) || 18804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject_AsCharBuffer(v, 18814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm &buffer, 18824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm &len))) { 18834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, 18844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "writelines() argument must be a sequence of strings"); 18854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 18864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 18874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm line = PyString_FromStringAndSize(buffer, 18884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm len); 18894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (line == NULL) 18904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 18914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 18924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyList_SET_ITEM(list, i, line); 18934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 18944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 18954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Since we are releasing the global lock, the 18974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm following code may *not* execute Python code. */ 18984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_softspace = 0; 18994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_BEGIN_ALLOW_THREADS(f) 19004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = 0; 19014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < j; i++) { 19024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm line = PyList_GET_ITEM(list, i); 19034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm len = PyString_GET_SIZE(line); 19044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nwritten = fwrite(PyString_AS_STRING(line), 19054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1, len, f->f_fp); 19064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (nwritten != len) { 19074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_ABORT_ALLOW_THREADS(f) 19084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetFromErrno(PyExc_IOError); 19094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm clearerr(f->f_fp); 19104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 19114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 19124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 19134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_END_ALLOW_THREADS(f) 19144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 19154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (j < CHUNKSIZE) 19164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 19174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 19184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 19194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(Py_None); 19204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = Py_None; 19214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm error: 19224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(list); 19234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(it); 19244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return result; 19254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#undef CHUNKSIZE 19264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 19274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 19284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 19294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfile_self(PyFileObject *f) 19304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 19314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_fp == NULL) 19324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_closed(); 19334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(f); 19344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)f; 19354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 19364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 19374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 19384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfile_xreadlines(PyFileObject *f) 19394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 19404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyErr_WarnPy3k("f.xreadlines() not supported in 3.x, " 19414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "try 'for line in f' instead", 1) < 0) 19424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 19434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return file_self(f); 19444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 19454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 19464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 19474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfile_exit(PyObject *f, PyObject *args) 19484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 19494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *ret = PyObject_CallMethod(f, "close", NULL); 19504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!ret) 19514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* If error occurred, pass through */ 19524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 19534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(ret); 19544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* We cannot return the result of close since a true 19554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * value will be interpreted as "yes, swallow the 19564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * exception if one was raised inside the with block". */ 19574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_RETURN_NONE; 19584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 19594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 19604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyDoc_STRVAR(readline_doc, 19614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"readline([size]) -> next line from the file, as a string.\n" 19624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"\n" 19634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"Retain newline. A non-negative size argument limits the maximum\n" 19644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"number of bytes to return (an incomplete line may be returned then).\n" 19654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"Return an empty string at EOF."); 19664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 19674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyDoc_STRVAR(read_doc, 19684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"read([size]) -> read at most size bytes, returned as a string.\n" 19694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"\n" 19704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"If the size argument is negative or omitted, read until EOF is reached.\n" 19714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"Notice that when in non-blocking mode, less data than what was requested\n" 19724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"may be returned, even if no size parameter was given."); 19734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 19744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyDoc_STRVAR(write_doc, 19754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"write(str) -> None. Write string str to file.\n" 19764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"\n" 19774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"Note that due to buffering, flush() or close() may be needed before\n" 19784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"the file on disk reflects the data written."); 19794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 19804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyDoc_STRVAR(fileno_doc, 19814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"fileno() -> integer \"file descriptor\".\n" 19824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"\n" 19834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"This is needed for lower-level file interfaces, such os.read()."); 19844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 19854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyDoc_STRVAR(seek_doc, 19864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"seek(offset[, whence]) -> None. Move to new file position.\n" 19874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"\n" 19884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"Argument offset is a byte count. Optional argument whence defaults to\n" 19894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"0 (offset from start of file, offset should be >= 0); other values are 1\n" 19904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"(move relative to current position, positive or negative), and 2 (move\n" 19914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"relative to end of file, usually negative, although many platforms allow\n" 19924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"seeking beyond the end of a file). If the file is opened in text mode,\n" 19934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"only offsets returned by tell() are legal. Use of other offsets causes\n" 19944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"undefined behavior." 19954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"\n" 19964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"Note that not all file objects are seekable."); 19974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 19984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef HAVE_FTRUNCATE 19994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyDoc_STRVAR(truncate_doc, 20004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"truncate([size]) -> None. Truncate the file to at most size bytes.\n" 20014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"\n" 20024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"Size defaults to the current file position, as returned by tell()."); 20034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 20044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyDoc_STRVAR(tell_doc, 20064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"tell() -> current file position, an integer (may be a long integer)."); 20074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyDoc_STRVAR(readinto_doc, 20094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"readinto() -> Undocumented. Don't use this; it may go away."); 20104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyDoc_STRVAR(readlines_doc, 20124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"readlines([size]) -> list of strings, each a line from the file.\n" 20134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"\n" 20144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"Call readline() repeatedly and return a list of the lines so read.\n" 20154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"The optional size argument, if given, is an approximate bound on the\n" 20164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"total number of bytes in the lines returned."); 20174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyDoc_STRVAR(xreadlines_doc, 20194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"xreadlines() -> returns self.\n" 20204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"\n" 20214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"For backward compatibility. File objects now include the performance\n" 20224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"optimizations previously implemented in the xreadlines module."); 20234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyDoc_STRVAR(writelines_doc, 20254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"writelines(sequence_of_strings) -> None. Write the strings to the file.\n" 20264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"\n" 20274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"Note that newlines are not added. The sequence can be any iterable object\n" 20284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"producing strings. This is equivalent to calling write() for each string."); 20294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyDoc_STRVAR(flush_doc, 20314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"flush() -> None. Flush the internal I/O buffer."); 20324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyDoc_STRVAR(close_doc, 20344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"close() -> None or (perhaps) an integer. Close the file.\n" 20354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"\n" 20364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"Sets data attribute .closed to True. A closed file cannot be used for\n" 20374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"further I/O operations. close() may be called more than once without\n" 20384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"error. Some kinds of file objects (for example, opened by popen())\n" 20394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"may return an exit status upon closing."); 20404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyDoc_STRVAR(isatty_doc, 20424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"isatty() -> true or false. True if the file is connected to a tty device."); 20434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyDoc_STRVAR(enter_doc, 20454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "__enter__() -> self."); 20464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyDoc_STRVAR(exit_doc, 20484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "__exit__(*excinfo) -> None. Closes the file."); 20494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyMethodDef file_methods[] = { 20514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"readline", (PyCFunction)file_readline, METH_VARARGS, readline_doc}, 20524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"read", (PyCFunction)file_read, METH_VARARGS, read_doc}, 20534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"write", (PyCFunction)file_write, METH_VARARGS, write_doc}, 20544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"fileno", (PyCFunction)file_fileno, METH_NOARGS, fileno_doc}, 20554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"seek", (PyCFunction)file_seek, METH_VARARGS, seek_doc}, 20564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef HAVE_FTRUNCATE 20574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"truncate", (PyCFunction)file_truncate, METH_VARARGS, truncate_doc}, 20584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 20594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"tell", (PyCFunction)file_tell, METH_NOARGS, tell_doc}, 20604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"readinto", (PyCFunction)file_readinto, METH_VARARGS, readinto_doc}, 20614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"readlines", (PyCFunction)file_readlines, METH_VARARGS, readlines_doc}, 20624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"xreadlines",(PyCFunction)file_xreadlines, METH_NOARGS, xreadlines_doc}, 20634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"writelines",(PyCFunction)file_writelines, METH_O, writelines_doc}, 20644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"flush", (PyCFunction)file_flush, METH_NOARGS, flush_doc}, 20654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"close", (PyCFunction)file_close, METH_NOARGS, close_doc}, 20664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"isatty", (PyCFunction)file_isatty, METH_NOARGS, isatty_doc}, 20674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"__enter__", (PyCFunction)file_self, METH_NOARGS, enter_doc}, 20684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"__exit__", (PyCFunction)file_exit, METH_VARARGS, exit_doc}, 20694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {NULL, NULL} /* sentinel */ 20704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm}; 20714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define OFF(x) offsetof(PyFileObject, x) 20734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyMemberDef file_memberlist[] = { 20754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"mode", T_OBJECT, OFF(f_mode), RO, 20764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "file mode ('r', 'U', 'w', 'a', possibly with 'b' or '+' added)"}, 20774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"name", T_OBJECT, OFF(f_name), RO, 20784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "file name"}, 20794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"encoding", T_OBJECT, OFF(f_encoding), RO, 20804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "file encoding"}, 20814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"errors", T_OBJECT, OFF(f_errors), RO, 20824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "Unicode error handler"}, 20834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* getattr(f, "closed") is implemented without this table */ 20844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {NULL} /* Sentinel */ 20854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm}; 20864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 20884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmget_closed(PyFileObject *f, void *closure) 20894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 20904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyBool_FromLong((long)(f->f_fp == 0)); 20914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 20924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 20934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmget_newlines(PyFileObject *f, void *closure) 20944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 20954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm switch (f->f_newlinetypes) { 20964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case NEWLINE_UNKNOWN: 20974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(Py_None); 20984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return Py_None; 20994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case NEWLINE_CR: 21004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyString_FromString("\r"); 21014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case NEWLINE_LF: 21024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyString_FromString("\n"); 21034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case NEWLINE_CR|NEWLINE_LF: 21044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return Py_BuildValue("(ss)", "\r", "\n"); 21054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case NEWLINE_CRLF: 21064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyString_FromString("\r\n"); 21074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case NEWLINE_CR|NEWLINE_CRLF: 21084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return Py_BuildValue("(ss)", "\r", "\r\n"); 21094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case NEWLINE_LF|NEWLINE_CRLF: 21104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return Py_BuildValue("(ss)", "\n", "\r\n"); 21114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case NEWLINE_CR|NEWLINE_LF|NEWLINE_CRLF: 21124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return Py_BuildValue("(sss)", "\r", "\n", "\r\n"); 21134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm default: 21144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_SystemError, 21154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "Unknown newlines value 0x%x\n", 21164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_newlinetypes); 21174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 21184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 21204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 21224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmget_softspace(PyFileObject *f, void *closure) 21234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 21244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyErr_WarnPy3k("file.softspace not supported in 3.x", 1) < 0) 21254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 21264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyInt_FromLong(f->f_softspace); 21274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 21284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int 21304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmset_softspace(PyFileObject *f, PyObject *value) 21314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 21324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int new; 21334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyErr_WarnPy3k("file.softspace not supported in 3.x", 1) < 0) 21344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 21354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (value == NULL) { 21374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, 21384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "can't delete softspace attribute"); 21394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 21404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm new = PyInt_AsLong(value); 21434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (new == -1 && PyErr_Occurred()) 21444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 21454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_softspace = new; 21464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 21474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 21484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyGetSetDef file_getsetlist[] = { 21504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"closed", (getter)get_closed, NULL, "True if the file is closed"}, 21514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"newlines", (getter)get_newlines, NULL, 21524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "end-of-line convention used in this file"}, 21534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"softspace", (getter)get_softspace, (setter)set_softspace, 21544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "flag indicating that a space needs to be printed; used by print"}, 21554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {0}, 21564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm}; 21574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic void 21594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdrop_readahead(PyFileObject *f) 21604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 21614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_buf != NULL) { 21624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyMem_Free(f->f_buf); 21634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_buf = NULL; 21644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 21664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Make sure that file has a readahead buffer with at least one byte 21684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (unless at EOF) and no more than bufsize. Returns negative value on 21694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm error, will set MemoryError if bufsize bytes cannot be allocated. */ 21704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int 21714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmreadahead(PyFileObject *f, int bufsize) 21724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 21734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t chunksize; 21744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_buf != NULL) { 21764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if( (f->f_bufend - f->f_bufptr) >= 1) 21774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 21784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 21794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm drop_readahead(f); 21804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((f->f_buf = (char *)PyMem_Malloc(bufsize)) == NULL) { 21824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_NoMemory(); 21834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 21844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_BEGIN_ALLOW_THREADS(f) 21864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = 0; 21874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm chunksize = Py_UniversalNewlineFread( 21884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_buf, bufsize, f->f_fp, (PyObject *)f); 21894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_END_ALLOW_THREADS(f) 21904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (chunksize == 0) { 21914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (ferror(f->f_fp)) { 21924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetFromErrno(PyExc_IOError); 21934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm clearerr(f->f_fp); 21944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm drop_readahead(f); 21954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 21964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_bufptr = f->f_buf; 21994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_bufend = f->f_buf + chunksize; 22004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 22014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 22024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Used by file_iternext. The returned string will start with 'skip' 22044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm uninitialized bytes followed by the remainder of the line. Don't be 22054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm horrified by the recursive call: maximum recursion depth is limited by 22064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm logarithmic buffer growth to about 50 even when reading a 1gb line. */ 22074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyStringObject * 22094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmreadahead_get_line_skip(PyFileObject *f, int skip, int bufsize) 22104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 22114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyStringObject* s; 22124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *bufptr; 22134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *buf; 22144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t len; 22154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_buf == NULL) 22174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (readahead(f, bufsize) < 0) 22184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 22194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm len = f->f_bufend - f->f_bufptr; 22214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (len == 0) 22224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyStringObject *) 22234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_FromStringAndSize(NULL, skip); 22244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bufptr = (char *)memchr(f->f_bufptr, '\n', len); 22254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (bufptr != NULL) { 22264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bufptr++; /* Count the '\n' */ 22274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm len = bufptr - f->f_bufptr; 22284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = (PyStringObject *) 22294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_FromStringAndSize(NULL, skip+len); 22304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (s == NULL) 22314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 22324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memcpy(PyString_AS_STRING(s)+skip, f->f_bufptr, len); 22334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_bufptr = bufptr; 22344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (bufptr == f->f_bufend) 22354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm drop_readahead(f); 22364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else { 22374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bufptr = f->f_bufptr; 22384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm buf = f->f_buf; 22394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_buf = NULL; /* Force new readahead buffer */ 22404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(skip+len < INT_MAX); 22414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = readahead_get_line_skip( 22424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f, (int)(skip+len), bufsize + (bufsize>>2) ); 22434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (s == NULL) { 22444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyMem_Free(buf); 22454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 22464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 22474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memcpy(PyString_AS_STRING(s)+skip, bufptr, len); 22484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyMem_Free(buf); 22494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 22504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return s; 22514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 22524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* A larger buffer size may actually decrease performance. */ 22544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define READAHEAD_BUFSIZE 8192 22554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 22574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfile_iternext(PyFileObject *f) 22584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 22594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyStringObject* l; 22604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_fp == NULL) 22624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_closed(); 22634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!f->readable) 22644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err_mode("reading"); 22654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm l = readahead_get_line_skip(f, 0, READAHEAD_BUFSIZE); 22674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (l == NULL || PyString_GET_SIZE(l) == 0) { 22684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(l); 22694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 22704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 22714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)l; 22724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 22734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 22764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfile_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 22774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 22784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *self; 22794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm static PyObject *not_yet_string; 22804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(type != NULL && type->tp_alloc != NULL); 22824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (not_yet_string == NULL) { 22844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm not_yet_string = PyString_InternFromString("<uninitialized file>"); 22854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (not_yet_string == NULL) 22864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 22874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 22884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self = type->tp_alloc(type, 0); 22904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (self != NULL) { 22914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Always fill in the name and mode, so that nobody else 22924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm needs to special-case NULLs there. */ 22934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(not_yet_string); 22944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((PyFileObject *)self)->f_name = not_yet_string; 22954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(not_yet_string); 22964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((PyFileObject *)self)->f_mode = not_yet_string; 22974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(Py_None); 22984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((PyFileObject *)self)->f_encoding = Py_None; 22994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(Py_None); 23004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((PyFileObject *)self)->f_errors = Py_None; 23014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((PyFileObject *)self)->weakreflist = NULL; 23024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((PyFileObject *)self)->unlocked_count = 0; 23034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 23044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return self; 23054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 23064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int 23084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfile_init(PyObject *self, PyObject *args, PyObject *kwds) 23094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 23104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFileObject *foself = (PyFileObject *)self; 23114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int ret = 0; 23124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm static char *kwlist[] = {"name", "mode", "buffering", 0}; 23134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *name = NULL; 23144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *mode = "r"; 23154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int bufsize = -1; 23164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int wideargument = 0; 23174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef MS_WINDOWS 23184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *po; 23194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 23204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(PyFile_Check(self)); 23224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (foself->f_fp != NULL) { 23234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Have to close the existing file first. */ 23244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *closeresult = file_close(foself); 23254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (closeresult == NULL) 23264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 23274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(closeresult); 23284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 23294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef MS_WINDOWS 23314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyArg_ParseTupleAndKeywords(args, kwds, "U|si:file", 23324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm kwlist, &po, &mode, &bufsize)) { 23334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm wideargument = 1; 23344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (fill_file_fields(foself, NULL, po, mode, 23354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fclose) == NULL) 23364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Error; 23374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else { 23384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Drop the argument parsing error as narrow 23394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm strings are also valid. */ 23404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Clear(); 23414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 23424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 23434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!wideargument) { 23454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *o_name; 23464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyArg_ParseTupleAndKeywords(args, kwds, "et|si:file", kwlist, 23484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_FileSystemDefaultEncoding, 23494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm &name, 23504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm &mode, &bufsize)) 23514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 23524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* We parse again to get the name as a PyObject */ 23544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|si:file", 23554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm kwlist, &o_name, &mode, 23564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm &bufsize)) 23574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Error; 23584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (fill_file_fields(foself, NULL, o_name, mode, 23604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fclose) == NULL) 23614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Error; 23624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 23634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (open_the_file(foself, name, mode) == NULL) 23644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Error; 23654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm foself->f_setbuf = NULL; 23664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFile_SetBufSize(self, bufsize); 23674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Done; 23684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmError: 23704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ret = -1; 23714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* fall through */ 23724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmDone: 23734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyMem_Free(name); /* free the encoded string */ 23744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return ret; 23754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 23764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyDoc_VAR(file_doc) = 23784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyDoc_STR( 23794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"file(name[, mode[, buffering]]) -> file object\n" 23804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"\n" 23814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"Open a file. The mode can be 'r', 'w' or 'a' for reading (default),\n" 23824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"writing or appending. The file will be created if it doesn't exist\n" 23834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"when opened for writing or appending; it will be truncated when\n" 23844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"opened for writing. Add a 'b' to the mode for binary files.\n" 23854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"Add a '+' to the mode to allow simultaneous reading and writing.\n" 23864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"If the buffering argument is given, 0 means unbuffered, 1 means line\n" 23874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"buffered, and larger numbers specify the buffer size. The preferred way\n" 23884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"to open a file is with the builtin open() function.\n" 23894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm) 23904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyDoc_STR( 23914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"Add a 'U' to mode to open the file for input with universal newline\n" 23924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"support. Any line ending in the input file will be seen as a '\\n'\n" 23934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"in Python. Also, a file so opened gains the attribute 'newlines';\n" 23944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"the value for this attribute is one of None (no newline read yet),\n" 23954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"'\\r', '\\n', '\\r\\n' or a tuple containing all the newline types seen.\n" 23964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"\n" 23974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"'U' cannot be combined with 'w' or '+' mode.\n" 23984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm); 23994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 24004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyTypeObject PyFile_Type = { 24014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyVarObject_HEAD_INIT(&PyType_Type, 0) 24024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "file", 24034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sizeof(PyFileObject), 24044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, 24054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (destructor)file_dealloc, /* tp_dealloc */ 24064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_print */ 24074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_getattr */ 24084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_setattr */ 24094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_compare */ 24104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (reprfunc)file_repr, /* tp_repr */ 24114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_as_number */ 24124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_as_sequence */ 24134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_as_mapping */ 24144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_hash */ 24154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_call */ 24164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_str */ 24174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject_GenericGetAttr, /* tp_getattro */ 24184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* softspace is writable: we must supply tp_setattro */ 24194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject_GenericSetAttr, /* tp_setattro */ 24204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_as_buffer */ 24214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */ 24224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm file_doc, /* tp_doc */ 24234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_traverse */ 24244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_clear */ 24254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_richcompare */ 24264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm offsetof(PyFileObject, weakreflist), /* tp_weaklistoffset */ 24274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (getiterfunc)file_self, /* tp_iter */ 24284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (iternextfunc)file_iternext, /* tp_iternext */ 24294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm file_methods, /* tp_methods */ 24304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm file_memberlist, /* tp_members */ 24314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm file_getsetlist, /* tp_getset */ 24324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_base */ 24334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_dict */ 24344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_descr_get */ 24354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_descr_set */ 24364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_dictoffset */ 24374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm file_init, /* tp_init */ 24384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyType_GenericAlloc, /* tp_alloc */ 24394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm file_new, /* tp_new */ 24404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject_Del, /* tp_free */ 24414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm}; 24424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 24434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Interface for the 'soft space' between print items. */ 24444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 24454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint 24464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyFile_SoftSpace(PyObject *f, int newflag) 24474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 24484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long oldflag = 0; 24494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f == NULL) { 24504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Do nothing */ 24514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyFile_Check(f)) { 24534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm oldflag = ((PyFileObject *)f)->f_softspace; 24544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((PyFileObject *)f)->f_softspace = newflag; 24554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 24574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *v; 24584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = PyObject_GetAttrString(f, "softspace"); 24594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v == NULL) 24604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Clear(); 24614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 24624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyInt_Check(v)) 24634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm oldflag = PyInt_AsLong(v); 24644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(oldflag < INT_MAX); 24654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 24664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = PyInt_FromLong((long)newflag); 24684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v == NULL) 24694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Clear(); 24704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 24714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyObject_SetAttrString(f, "softspace", v) != 0) 24724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Clear(); 24734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 24744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (int)oldflag; 24774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 24784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 24794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Interfaces to write objects/strings to file-like objects */ 24804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 24814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint 24824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyFile_WriteObject(PyObject *v, PyObject *f, int flags) 24834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 24844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *writer, *value, *args, *result; 24854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f == NULL) { 24864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, "writeobject with NULL file"); 24874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 24884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyFile_Check(f)) { 24904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFileObject *fobj = (PyFileObject *) f; 24914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef Py_USING_UNICODE 24924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *enc = fobj->f_encoding; 24934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int result; 24944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 24954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (fobj->f_fp == NULL) { 24964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err_closed(); 24974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 24984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef Py_USING_UNICODE 25004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((flags & Py_PRINT_RAW) && 25014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyUnicode_Check(v) && enc != Py_None) { 25024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *cenc = PyString_AS_STRING(enc); 25034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *errors = fobj->f_errors == Py_None ? 25044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "strict" : PyString_AS_STRING(fobj->f_errors); 25054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm value = PyUnicode_AsEncodedString(v, cenc, errors); 25064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (value == NULL) 25074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 25084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else { 25094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm value = v; 25104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(value); 25114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 25124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = file_PyObject_Print(value, fobj, flags); 25134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(value); 25144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return result; 25154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 25164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return file_PyObject_Print(v, fobj, flags); 25174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 25184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 25194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm writer = PyObject_GetAttrString(f, "write"); 25204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (writer == NULL) 25214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 25224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (flags & Py_PRINT_RAW) { 25234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyUnicode_Check(v)) { 25244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm value = v; 25254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(value); 25264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else 25274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm value = PyObject_Str(v); 25284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 25294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 25304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm value = PyObject_Repr(v); 25314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (value == NULL) { 25324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(writer); 25334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 25344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 25354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm args = PyTuple_Pack(1, value); 25364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (args == NULL) { 25374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(value); 25384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(writer); 25394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 25404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 25414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = PyEval_CallObject(writer, args); 25424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(args); 25434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(value); 25444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(writer); 25454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (result == NULL) 25464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 25474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(result); 25484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 25494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 25504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint 25524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyFile_WriteString(const char *s, PyObject *f) 25534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 25544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f == NULL) { 25564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Should be caused by a pre-existing error */ 25574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyErr_Occurred()) 25584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_SystemError, 25594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "null file for PyFile_WriteString"); 25604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 25614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 25624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyFile_Check(f)) { 25634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFileObject *fobj = (PyFileObject *) f; 25644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE *fp = PyFile_AsFile(f); 25654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (fp == NULL) { 25664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err_closed(); 25674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 25684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 25694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_BEGIN_ALLOW_THREADS(fobj) 25704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fputs(s, fp); 25714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE_END_ALLOW_THREADS(fobj) 25724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 25734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 25744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (!PyErr_Occurred()) { 25754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *v = PyString_FromString(s); 25764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int err; 25774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v == NULL) 25784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 25794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyFile_WriteObject(v, f, Py_PRINT_RAW); 25804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 25814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err; 25824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 25834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 25844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 25854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 25864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Try to get a file-descriptor from a Python object. If the object 25884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm is an integer or long integer, its value is returned. If not, the 25894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm object's fileno() method is called if it exists; the method must return 25904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm an integer or long integer, which is returned as the file descriptor value. 25914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm -1 is returned on failure. 25924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm*/ 25934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint PyObject_AsFileDescriptor(PyObject *o) 25954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 25964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int fd; 25974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *meth; 25984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyInt_Check(o)) { 26004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fd = PyInt_AsLong(o); 26014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyLong_Check(o)) { 26034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fd = PyLong_AsLong(o); 26044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if ((meth = PyObject_GetAttrString(o, "fileno")) != NULL) 26064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { 26074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *fno = PyEval_CallObject(meth, NULL); 26084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(meth); 26094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (fno == NULL) 26104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 26114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 26124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyInt_Check(fno)) { 26134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fd = PyInt_AsLong(fno); 26144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(fno); 26154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyLong_Check(fno)) { 26174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fd = PyLong_AsLong(fno); 26184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(fno); 26194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 26214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, 26224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "fileno() returned a non-integer"); 26234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(fno); 26244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 26254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 26284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, 26294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "argument must be an int, or have a fileno() method."); 26304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 26314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 26334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (fd < 0) { 26344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_ValueError, 26354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "file descriptor cannot be a negative integer (%i)", 26364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fd); 26374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 26384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return fd; 26404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 26414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 26424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* From here on we need access to the real fgets and fread */ 26434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#undef fgets 26444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#undef fread 26454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 26464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* 26474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm** Py_UniversalNewlineFgets is an fgets variation that understands 26484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm** all of \r, \n and \r\n conventions. 26494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm** The stream should be opened in binary mode. 26504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm** If fobj is NULL the routine always does newline conversion, and 26514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm** it may peek one char ahead to gobble the second char in \r\n. 26524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm** If fobj is non-NULL it must be a PyFileObject. In this case there 26534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm** is no readahead but in stead a flag is used to skip a following 26544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm** \n on the next read. Also, if the file is open in binary mode 26554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm** the whole conversion is skipped. Finally, the routine keeps track of 26564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm** the different types of newlines seen. 26574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm** Note that we need no error handling: fgets() treats error and eof 26584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm** identically. 26594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm*/ 26604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmchar * 26614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPy_UniversalNewlineFgets(char *buf, int n, FILE *stream, PyObject *fobj) 26624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 26634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *p = buf; 26644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int c; 26654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int newlinetypes = 0; 26664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int skipnextlf = 0; 26674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int univ_newline = 1; 26684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 26694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (fobj) { 26704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyFile_Check(fobj)) { 26714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = ENXIO; /* What can you do... */ 26724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 26734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm univ_newline = ((PyFileObject *)fobj)->f_univ_newline; 26754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ( !univ_newline ) 26764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return fgets(buf, n, stream); 26774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newlinetypes = ((PyFileObject *)fobj)->f_newlinetypes; 26784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm skipnextlf = ((PyFileObject *)fobj)->f_skipnextlf; 26794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FLOCKFILE(stream); 26814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = 'x'; /* Shut up gcc warning */ 26824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (--n > 0 && (c = GETC(stream)) != EOF ) { 26834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (skipnextlf ) { 26844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm skipnextlf = 0; 26854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (c == '\n') { 26864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Seeing a \n here with skipnextlf true 26874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ** means we saw a \r before. 26884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 26894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newlinetypes |= NEWLINE_CRLF; 26904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = GETC(stream); 26914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (c == EOF) break; 26924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else { 26934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* 26944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ** Note that c == EOF also brings us here, 26954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ** so we're okay if the last char in the file 26964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ** is a CR. 26974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 26984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newlinetypes |= NEWLINE_CR; 26994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (c == '\r') { 27024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* A \r is translated into a \n, and we skip 27034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ** an adjacent \n, if any. We don't set the 27044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ** newlinetypes flag until we've seen the next char. 27054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 27064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm skipnextlf = 1; 27074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = '\n'; 27084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else if ( c == '\n') { 27094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newlinetypes |= NEWLINE_LF; 27104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *p++ = c; 27124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (c == '\n') break; 27134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ( c == EOF && skipnextlf ) 27154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newlinetypes |= NEWLINE_CR; 27164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FUNLOCKFILE(stream); 27174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *p = '\0'; 27184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (fobj) { 27194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((PyFileObject *)fobj)->f_newlinetypes = newlinetypes; 27204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((PyFileObject *)fobj)->f_skipnextlf = skipnextlf; 27214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else if ( skipnextlf ) { 27224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* If we have no file object we cannot save the 27234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ** skipnextlf flag. We have to readahead, which 27244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ** will cause a pause if we're reading from an 27254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ** interactive stream, but that is very unlikely 27264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ** unless we're doing something silly like 27274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ** execfile("/dev/tty"). 27284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 27294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = GETC(stream); 27304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ( c != '\n' ) 27314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ungetc(c, stream); 27324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (p == buf) 27344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 27354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return buf; 27364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 27374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* 27394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm** Py_UniversalNewlineFread is an fread variation that understands 27404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm** all of \r, \n and \r\n conventions. 27414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm** The stream should be opened in binary mode. 27424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm** fobj must be a PyFileObject. In this case there 27434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm** is no readahead but in stead a flag is used to skip a following 27444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm** \n on the next read. Also, if the file is open in binary mode 27454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm** the whole conversion is skipped. Finally, the routine keeps track of 27464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm** the different types of newlines seen. 27474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm*/ 27484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmsize_t 27494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPy_UniversalNewlineFread(char *buf, size_t n, 27504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE *stream, PyObject *fobj) 27514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 27524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *dst = buf; 27534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFileObject *f = (PyFileObject *)fobj; 27544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int newlinetypes, skipnextlf; 27554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(buf != NULL); 27574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(stream != NULL); 27584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!fobj || !PyFile_Check(fobj)) { 27604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = ENXIO; /* What can you do... */ 27614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 27624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!f->f_univ_newline) 27644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return fread(buf, 1, n, stream); 27654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newlinetypes = f->f_newlinetypes; 27664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm skipnextlf = f->f_skipnextlf; 27674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Invariant: n is the number of bytes remaining to be filled 27684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * in the buffer. 27694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 27704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (n) { 27714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_t nread; 27724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int shortread; 27734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *src = dst; 27744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nread = fread(dst, 1, n, stream); 27764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(nread <= n); 27774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (nread == 0) 27784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 27794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n -= nread; /* assuming 1 byte out for each in; will adjust */ 27814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm shortread = n != 0; /* true iff EOF or error */ 27824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (nread--) { 27834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char c = *src++; 27844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (c == '\r') { 27854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Save as LF and set flag to skip next LF. */ 27864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *dst++ = '\n'; 27874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm skipnextlf = 1; 27884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (skipnextlf && c == '\n') { 27904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Skip LF, and remember we saw CR LF. */ 27914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm skipnextlf = 0; 27924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newlinetypes |= NEWLINE_CRLF; 27934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++n; 27944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 27964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Normal char to be stored in buffer. Also 27974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * update the newlinetypes flag if either this 27984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * is an LF or the previous char was a CR. 27994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 28004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (c == '\n') 28014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newlinetypes |= NEWLINE_LF; 28024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (skipnextlf) 28034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newlinetypes |= NEWLINE_CR; 28044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *dst++ = c; 28054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm skipnextlf = 0; 28064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 28074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 28084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (shortread) { 28094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* If this is EOF, update type flags. */ 28104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (skipnextlf && feof(stream)) 28114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newlinetypes |= NEWLINE_CR; 28124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 28134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 28144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 28154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_newlinetypes = newlinetypes; 28164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_skipnextlf = skipnextlf; 28174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return dst - buf; 28184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 28194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef __cplusplus 28214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 28224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 2823