/* File object implementation */#include "Python.h"#include "structmember.h"#ifndef DONT_HAVE_SYS_TYPES_H#include <sys/types.h>#endif /* DONT_HAVE_SYS_TYPES_H */#ifdef MS_WINDOWS#define fileno _fileno/* can simulate truncate with Win32 API functions; see file_truncate */#define HAVE_FTRUNCATE#define WIN32_LEAN_AND_MEAN#include <windows.h>#endif#ifdef _MSC_VER/* Need GetVersion to see if on NT so safe to use _wfopen */#define WIN32_LEAN_AND_MEAN#include <windows.h>#endif /* _MSC_VER */#if defined(PYOS_OS2) && defined(PYCC_GCC)#include <io.h>#endif#define BUF(v) PyString_AS_STRING((PyStringObject *)v)#ifndef DONT_HAVE_ERRNO_H#include <errno.h>#endif#ifdef HAVE_GETC_UNLOCKED#define GETC(f) getc_unlocked(f)#define FLOCKFILE(f) flockfile(f)#define FUNLOCKFILE(f) funlockfile(f)#else#define GETC(f) getc(f)#define FLOCKFILE(f)#define FUNLOCKFILE(f)#endif/* Bits in f_newlinetypes */#define NEWLINE_UNKNOWN 0 /* No newline seen, yet */#define NEWLINE_CR 1 /* \r newline seen */#define NEWLINE_LF 2 /* \n newline seen */#define NEWLINE_CRLF 4 /* \r\n newline seen */FILE*PyFile_AsFile(PyObject*f){if(f==NULL||!PyFile_Check(f))returnNULL;elsereturn((PyFileObject*)f)->f_fp;}PyObject*PyFile_Name(PyObject*f){if(f==NULL||!PyFile_Check(f))returnNULL;elsereturn((PyFileObject*)f)->f_name;}/* On Unix, fopen will succeed for directories. In Python, there should be no file objects referring to directories, so we need a check. */staticPyFileObject*dircheck(PyFileObject*f){#if defined(HAVE_FSTAT) && defined(S_IFDIR) && defined(EISDIR)structstatbuf;if(f->f_fp==NULL)returnf;if(fstat(fileno(f->f_fp),&buf)==0&&S_ISDIR(buf.st_mode)){#ifdef HAVE_STRERRORchar*msg=strerror(EISDIR);#elsechar*msg="Is a directory";#endifPyObject*exc=PyObject_CallFunction(PyExc_IOError,"(is)",EISDIR,msg);PyErr_SetObject(PyExc_IOError,exc);Py_XDECREF(exc);returnNULL;}#endifreturnf;}staticPyObject*fill_file_fields(PyFileObject*f,FILE*fp,PyObject*name,char*mode,int(*close)(FILE*)){assert(name!=NULL);assert(f!=NULL);assert(PyFile_Check(f));assert(f->f_fp==NULL);Py_DECREF(f->f_name);Py_DECREF(f->f_mode);Py_DECREF(f->f_encoding);Py_INCREF(name);f->f_name=name;f->f_mode=PyString_FromString(mode);f->f_close=close;f->f_softspace=0;f->f_binary=strchr(mode,'b')!=NULL;f->f_buf=NULL;f->f_univ_newline=(strchr(mode,'U')!=NULL);f->f_newlinetypes=NEWLINE_UNKNOWN;f->f_skipnextlf=0;Py_INCREF(Py_None);f->f_encoding=Py_None;if(f->f_mode==NULL)returnNULL;f->f_fp=fp;f=dircheck(f);return(PyObject*)f;}staticPyObject*open_the_file(PyFileObject*f,char*name,char*mode){assert(f!=NULL);assert(PyFile_Check(f));#ifdef MS_WINDOWS/* windows ignores the passed name in order to support Unicode */assert(f->f_name!=NULL);#elseassert(name!=NULL);#endifassert(mode!=NULL);assert(f->f_fp==NULL);/* rexec.py can't stop a user from getting the file() constructor -- all they have to do is get *any* file object f, and then do type(f). Here we prevent them from doing damage with it. */if(PyEval_GetRestricted()){PyErr_SetString(PyExc_IOError,"file() constructor not accessible in restricted mode");returnNULL;}errno=0;if(strcmp(mode,"U")==0||strcmp(mode,"rU")==0)mode="rb";#ifdef MS_WINDOWSif(PyUnicode_Check(f->f_name)){PyObject*wmode;wmode=PyUnicode_DecodeASCII(mode,strlen(mode),NULL);if(f->f_name&&wmode){Py_BEGIN_ALLOW_THREADS/* PyUnicode_AS_UNICODE OK without thread lock as it is a simple dereference. */f->f_fp=_wfopen(PyUnicode_AS_UNICODE(f->f_name),PyUnicode_AS_UNICODE(wmode));Py_END_ALLOW_THREADS}Py_XDECREF(wmode);}#endifif(NULL==f->f_fp&&NULL!=name){Py_BEGIN_ALLOW_THREADSf->f_fp=fopen(name,mode);Py_END_ALLOW_THREADS}if(f->f_fp==NULL){#ifdef _MSC_VER/* MSVC 6 (Microsoft) leaves errno at 0 for bad mode strings, * across all Windows flavors. When it sets EINVAL varies * across Windows flavors, the exact conditions aren't * documented, and the answer lies in the OS's implementation * of Win32's CreateFile function (whose source is secret). * Seems the best we can do is map EINVAL to ENOENT. */if(errno==0)/* bad mode string */errno=EINVAL;elseif(errno==EINVAL)/* unknown, but not a mode string */errno=ENOENT;#endifif(errno==EINVAL)PyErr_Format(PyExc_IOError,"invalid mode: %s",mode);elsePyErr_SetFromErrnoWithFilenameObject(PyExc_IOError,f->f_name);f=NULL;}if(f!=NULL)f=dircheck(f);return(PyObject*)f;}PyObject*PyFile_FromFile(FILE*fp,char*name,char*mode,int(*close)(FILE*)){PyFileObject*f=(PyFileObject*)PyFile_Type.tp_new(&PyFile_Type,NULL,NULL);if(f!=NULL){PyObject*o_name=PyString_FromString(name);if(o_name==NULL)returnNULL;if(fill_file_fields(f,fp,o_name,mode,close)==NULL){Py_DECREF(f);f=NULL;}Py_DECREF(o_name);}return(PyObject*)f;}PyObject*PyFile_FromString(char*name,char*mode){externintfclose(FILE*);PyFileObject*f;f=(PyFileObject*)PyFile_FromFile((FILE*)NULL,name,mode,fclose);if(f!=NULL){if(open_the_file(f,name,mode)==NULL){Py_DECREF(f);f=NULL;}}return(PyObject*)f;}voidPyFile_SetBufSize(PyObject*f,intbufsize){PyFileObject*file=(PyFileObject*)f;if(bufsize>=0){inttype;switch(bufsize){case0:type=_IONBF;break;#ifdef HAVE_SETVBUFcase1:type=_IOLBF;bufsize=BUFSIZ;break;#endifdefault:type=_IOFBF;#ifndef HAVE_SETVBUFbufsize=BUFSIZ;#endifbreak;}fflush(file->f_fp);if(type==_IONBF){PyMem_Free(file->f_setbuf);file->f_setbuf=NULL;}else{file->f_setbuf=PyMem_Realloc(file->f_setbuf,bufsize);}#ifdef HAVE_SETVBUFsetvbuf(file->f_fp,file->f_setbuf,type,bufsize);#else /* !HAVE_SETVBUF */setbuf(file->f_fp,file->f_setbuf);#endif /* !HAVE_SETVBUF */}}/* Set the encoding used to output Unicode strings. Returh 1 on success, 0 on failure. */intPyFile_SetEncoding(PyObject*f,constchar*enc){PyFileObject*file=(PyFileObject*)f;PyObject*str=PyString_FromString(enc);assert(PyFile_Check(f));if(!str)return0;Py_DECREF(file->f_encoding);file->f_encoding=str;return1;}staticPyObject*err_closed(void){PyErr_SetString(PyExc_ValueError,"I/O operation on closed file");returnNULL;}staticvoiddrop_readahead(PyFileObject*);/* Methods */staticvoidfile_dealloc(PyFileObject*f){intsts=0;if(f->weakreflist!=NULL)PyObject_ClearWeakRefs((PyObject*)f);if(f->f_fp!=NULL&&f->f_close!=NULL){Py_BEGIN_ALLOW_THREADSsts=(*f->f_close)(f->f_fp);Py_END_ALLOW_THREADSif(sts==EOF)#ifdef HAVE_STRERRORPySys_WriteStderr("close failed: [Errno %d] %s\n",errno,strerror(errno));#elsePySys_WriteStderr("close failed: [Errno %d]\n",errno);#endif}PyMem_Free(f->f_setbuf);Py_XDECREF(f->f_name);Py_XDECREF(f->f_mode);Py_XDECREF(f->f_encoding);drop_readahead(f);f->ob_type->tp_free((PyObject*)f);}staticPyObject*file_repr(PyFileObject*f){if(PyUnicode_Check(f->f_name)){#ifdef Py_USING_UNICODEPyObject*ret=NULL;PyObject*name=PyUnicode_AsUnicodeEscapeString(f->f_name);constchar*name_str=name?PyString_AsString(name):"?";ret=PyString_FromFormat("<%s file u'%s', mode '%s' at %p>",f->f_fp==NULL?"closed":"open",name_str,PyString_AsString(f->f_mode),f);Py_XDECREF(name);returnret;#endif}else{returnPyString_FromFormat("<%s file '%s', mode '%s' at %p>",f->f_fp==NULL?"closed":"open",PyString_AsString(f->f_name),PyString_AsString(f->f_mode),f);}}staticPyObject*file_close(PyFileObject*f){intsts=0;if(f->f_fp!=NULL){if(f->f_close!=NULL){Py_BEGIN_ALLOW_THREADSerrno=0;sts=(*f->f_close)(f->f_fp);Py_END_ALLOW_THREADS}f->f_fp=NULL;}PyMem_Free(f->f_setbuf);f->f_setbuf=NULL;if(sts==EOF)returnPyErr_SetFromErrno(PyExc_IOError);if(sts!=0)returnPyInt_FromLong((long)sts);Py_INCREF(Py_None);returnPy_None;}/* Our very own off_t-like type, 64-bit if possible */#if !defined(HAVE_LARGEFILE_SUPPORT)typedefoff_tPy_off_t;#elif SIZEOF_OFF_T >= 8typedefoff_tPy_off_t;#elif SIZEOF_FPOS_T >= 8typedeffpos_tPy_off_t;#else#error "Large file support, but neither off_t nor fpos_t is large enough."#endif/* a portable fseek() function return 0 on success, non-zero on failure (with errno set) */staticint_portable_fseek(FILE*fp,Py_off_toffset,intwhence){#if !defined(HAVE_LARGEFILE_SUPPORT)returnfseek(fp,offset,whence);#elif defined(HAVE_FSEEKO) && SIZEOF_OFF_T >= 8returnfseeko(fp,offset,whence);#elif defined(HAVE_FSEEK64)returnfseek64(fp,offset,whence);#elif defined(__BEOS__)return_fseek(fp,offset,whence);#elif SIZEOF_FPOS_T >= 8/* lacking a 64-bit capable fseek(), use a 64-bit capable fsetpos() and fgetpos() to implement fseek()*/fpos_tpos;switch(whence){caseSEEK_END:#ifdef MS_WINDOWSfflush(fp);if(_lseeki64(fileno(fp),0,2)==-1)return-1;#elseif(fseek(fp,0,SEEK_END)!=0)return-1;#endif/* fall through */caseSEEK_CUR:if(fgetpos(fp,&pos)!=0)return-1;offset+=pos;break;/* case SEEK_SET: break; */}returnfsetpos(fp,&offset);#else#error "Large file support, but no way to fseek."#endif}/* a portable ftell() function Return -1 on failure with errno set appropriately, current file position on success */staticPy_off_t_portable_ftell(FILE*fp){#if !defined(HAVE_LARGEFILE_SUPPORT)returnftell(fp);#elif defined(HAVE_FTELLO) && SIZEOF_OFF_T >= 8returnftello(fp);#elif defined(HAVE_FTELL64)returnftell64(fp);#elif SIZEOF_FPOS_T >= 8fpos_tpos;if(fgetpos(fp,&pos)!=0)return-1;returnpos;#else#error "Large file support, but no way to ftell."#endif}staticPyObject*file_seek(PyFileObject*f,PyObject*args){intwhence;intret;Py_off_toffset;PyObject*offobj;if(f->f_fp==NULL)returnerr_closed();drop_readahead(f);whence=0;if(!PyArg_ParseTuple(args,"O|i:seek",&offobj,&whence))returnNULL;#if !defined(HAVE_LARGEFILE_SUPPORT)offset=PyInt_AsLong(offobj);#elseoffset=PyLong_Check(offobj)?PyLong_AsLongLong(offobj):PyInt_AsLong(offobj);#endifif(PyErr_Occurred())returnNULL;Py_BEGIN_ALLOW_THREADSerrno=0;ret=_portable_fseek(f->f_fp,offset,whence);Py_END_ALLOW_THREADSif(ret!=0){PyErr_SetFromErrno(PyExc_IOError);clearerr(f->f_fp);returnNULL;}f->f_skipnextlf=0;Py_INCREF(Py_None);returnPy_None;}#ifdef HAVE_FTRUNCATEstaticPyObject*file_truncate(PyFileObject*f,PyObject*args){Py_off_tnewsize;PyObject*newsizeobj=NULL;Py_off_tinitialpos;intret;if(f->f_fp==NULL)returnerr_closed();if(!PyArg_UnpackTuple(args,"truncate",0,1,&newsizeobj))returnNULL;/* Get current file position. If the file happens to be open for * update and the last operation was an input operation, C doesn't * define what the later fflush() will do, but we promise truncate() * won't change the current position (and fflush() *does* change it * then at least on Windows). The easiest thing is to capture * current pos now and seek back to it at the end. */Py_BEGIN_ALLOW_THREADSerrno=0;initialpos=_portable_ftell(f->f_fp);Py_END_ALLOW_THREADSif(initialpos==-1)gotoonioerror;/* Set newsize to current postion if newsizeobj NULL, else to the * specified value. */if(newsizeobj!=NULL){#if !defined(HAVE_LARGEFILE_SUPPORT)newsize=PyInt_AsLong(newsizeobj);#elsenewsize=PyLong_Check(newsizeobj)?PyLong_AsLongLong(newsizeobj):PyInt_AsLong(newsizeobj);#endifif(PyErr_Occurred())returnNULL;}else/* default to current position */newsize=initialpos;/* Flush the stream. We're mixing stream-level I/O with lower-level * I/O, and a flush may be necessary to synch both platform views * of the current file state. */Py_BEGIN_ALLOW_THREADSerrno=0;ret=fflush(f->f_fp);Py_END_ALLOW_THREADSif(ret!=0)gotoonioerror;#ifdef MS_WINDOWS/* MS _chsize doesn't work if newsize doesn't fit in 32 bits, so don't even try using it. */{HANDLEhFile;/* Have to move current pos to desired endpoint on Windows. */Py_BEGIN_ALLOW_THREADSerrno=0;ret=_portable_fseek(f->f_fp,newsize,SEEK_SET)!=0;Py_END_ALLOW_THREADSif(ret)gotoonioerror;/* Truncate. Note that this may grow the file! */Py_BEGIN_ALLOW_THREADSerrno=0;hFile=(HANDLE)_get_osfhandle(fileno(f->f_fp));ret=hFile==(HANDLE)-1;if(ret==0){ret=SetEndOfFile(hFile)==0;if(ret)errno=EACCES;}Py_END_ALLOW_THREADSif(ret)gotoonioerror;}#elsePy_BEGIN_ALLOW_THREADSerrno=0;ret=ftruncate(fileno(f->f_fp),newsize);Py_END_ALLOW_THREADSif(ret!=0)gotoonioerror;#endif /* !MS_WINDOWS *//* Restore original file position. */Py_BEGIN_ALLOW_THREADSerrno=0;ret=_portable_fseek(f->f_fp,initialpos,SEEK_SET)!=0;Py_END_ALLOW_THREADSif(ret)gotoonioerror;Py_INCREF(Py_None);returnPy_None;onioerror:PyErr_SetFromErrno(PyExc_IOError);clearerr(f->f_fp);returnNULL;}#endif /* HAVE_FTRUNCATE */staticPyObject*file_tell(PyFileObject*f){Py_off_tpos;if(f->f_fp==NULL)returnerr_closed();Py_BEGIN_ALLOW_THREADSerrno=0;pos=_portable_ftell(f->f_fp);Py_END_ALLOW_THREADSif(pos==-1){PyErr_SetFromErrno(PyExc_IOError);clearerr(f->f_fp);returnNULL;}if(f->f_skipnextlf){intc;c=GETC(f->f_fp);if(c=='\n'){pos++;f->f_skipnextlf=0;}elseif(c!=EOF)ungetc(c,f->f_fp);}#if !defined(HAVE_LARGEFILE_SUPPORT)returnPyInt_FromLong(pos);#elsereturnPyLong_FromLongLong(pos);#endif}staticPyObject*file_fileno(PyFileObject*f){if(f->f_fp==NULL)returnerr_closed();returnPyInt_FromLong((long)fileno(f->f_fp));}staticPyObject*file_flush(PyFileObject*f){intres;if(f->f_fp==NULL)returnerr_closed();Py_BEGIN_ALLOW_THREADSerrno=0;res=fflush(f->f_fp);Py_END_ALLOW_THREADSif(res!=0){PyErr_SetFromErrno(PyExc_IOError);clearerr(f->f_fp);returnNULL;}Py_INCREF(Py_None);returnPy_None;}staticPyObject*file_isatty(PyFileObject*f){longres;if(f->f_fp==NULL)returnerr_closed();Py_BEGIN_ALLOW_THREADSres=isatty((int)fileno(f->f_fp));Py_END_ALLOW_THREADSreturnPyBool_FromLong(res);}#if BUFSIZ < 8192#define SMALLCHUNK 8192#else#define SMALLCHUNK BUFSIZ#endif#if SIZEOF_INT < 4#define BIGCHUNK (512 * 32)#else#define BIGCHUNK (512 * 1024)#endifstaticsize_tnew_buffersize(PyFileObject*f,size_tcurrentsize){#ifdef HAVE_FSTAToff_tpos,end;structstatst;if(fstat(fileno(f->f_fp),&st)==0){end=st.st_size;/* The following is not a bug: we really need to call lseek() *and* ftell(). The reason is that some stdio libraries mistakenly flush their buffer when ftell() is called and the lseek() call it makes fails, thereby throwing away data that cannot be recovered in any way. To avoid this, we first test lseek(), and only call ftell() if lseek() works. We can't use the lseek() value either, because we need to take the amount of buffered data into account. (Yet another reason why stdio stinks. :-) */pos=lseek(fileno(f->f_fp),0L,SEEK_CUR);if(pos>=0){pos=ftell(f->f_fp);}if(pos<0)clearerr(f->f_fp);if(end>pos&&pos>=0)returncurrentsize+end-pos+1;/* Add 1 so if the file were to grow we'd notice. */}#endifif(currentsize>SMALLCHUNK){/* Keep doubling until we reach BIGCHUNK; then keep adding BIGCHUNK. */if(currentsize<=BIGCHUNK)returncurrentsize+currentsize;elsereturncurrentsize+BIGCHUNK;}returncurrentsize+SMALLCHUNK;}#if defined(EWOULDBLOCK) && defined(EAGAIN) && EWOULDBLOCK != EAGAIN#define BLOCKED_ERRNO(x) ((x) == EWOULDBLOCK || (x) == EAGAIN)#else#ifdef EWOULDBLOCK#define BLOCKED_ERRNO(x) ((x) == EWOULDBLOCK)#else#ifdef EAGAIN#define BLOCKED_ERRNO(x) ((x) == EAGAIN)#else#define BLOCKED_ERRNO(x) 0#endif#endif#endifstaticPyObject*file_read(PyFileObject*f,PyObject*args){longbytesrequested=-1;size_tbytesread,buffersize,chunksize;PyObject*v;if(f->f_fp==NULL)returnerr_closed();if(!PyArg_ParseTuple(args,"|l:read",&bytesrequested))returnNULL;if(bytesrequested<0)buffersize=new_buffersize(f,(size_t)0);elsebuffersize=bytesrequested;if(buffersize>INT_MAX){PyErr_SetString(PyExc_OverflowError,"requested number of bytes is more than a Python string can hold");returnNULL;}v=PyString_FromStringAndSize((char*)NULL,buffersize);if(v==NULL)returnNULL;bytesread=0;for(;;){Py_BEGIN_ALLOW_THREADSerrno=0;chunksize=Py_UniversalNewlineFread(BUF(v)+bytesread,buffersize-bytesread,f->f_fp,(PyObject*)f);Py_END_ALLOW_THREADSif(chunksize==0){if(!ferror(f->f_fp))break;clearerr(f->f_fp);/* When in non-blocking mode, data shouldn't * be discarded if a blocking signal was * received. That will also happen if * chunksize != 0, but bytesread < buffersize. */if(bytesread>0&&BLOCKED_ERRNO(errno))break;PyErr_SetFromErrno(PyExc_IOError);Py_DECREF(v);returnNULL;}bytesread+=chunksize;if(bytesread<buffersize){clearerr(f->f_fp);break;}if(bytesrequested<0){buffersize=new_buffersize(f,buffersize);if(_PyString_Resize(&v,buffersize)<0)returnNULL;}else{/* Got what was requested. */break;}}if(bytesread!=buffersize)_PyString_Resize(&v,bytesread);returnv;}staticPyObject*file_readinto(PyFileObject*f,PyObject*args){char*ptr;intntodo;size_tndone,nnow;if(f->f_fp==NULL)returnerr_closed();if(!PyArg_ParseTuple(args,"w#",&ptr,&ntodo))returnNULL;ndone=0;while(ntodo>0){Py_BEGIN_ALLOW_THREADSerrno=0;nnow=Py_UniversalNewlineFread(ptr+ndone,ntodo,f->f_fp,(PyObject*)f);Py_END_ALLOW_THREADSif(nnow==0){if(!ferror(f->f_fp))break;PyErr_SetFromErrno(PyExc_IOError);clearerr(f->f_fp);returnNULL;}ndone+=nnow;ntodo-=nnow;}returnPyInt_FromLong((long)ndone);}/**************************************************************************Routine to get next line using platform fgets().Under MSVC 6:+ MS threadsafe getc is very slow (multiple layers of function calls before+ after each character, to lock+unlock the stream).+ The stream-locking functions are MS-internal -- can't access them from user code.+ There's nothing Tim could find in the MS C or platform SDK libraries that can worm around this.+ MS fgets locks/unlocks only once per line; it's the only hook we have.So we use fgets for speed(!), despite that it's painful.MS realloc is also slow.Reports from other platforms on this method vs getc_unlocked (which MS doesn'thave): Linux a wash Solaris a wash Tru64 Unix getline_via_fgets significantly fasterCAUTION: The C std isn't clear about this: in those cases where fgetswrites something into the buffer, can it write into any position beyond therequired trailing null byte? MSVC 6 fgets does not, and no platform is (yet)known on which it does; and it would be a strange way to code fgets. Still,getline_via_fgets may not work correctly if it does. The std testtest_bufio.py should fail if platform fgets() routinely writes beyond thetrailing null byte. #define DONT_USE_FGETS_IN_GETLINE to disable this code.**************************************************************************//* Use this routine if told to, or by default on non-get_unlocked() * platforms unless told not to. Yikes! Let's spell that out: * On a platform with getc_unlocked(): * By default, use getc_unlocked(). * If you want to use fgets() instead, #define USE_FGETS_IN_GETLINE. * On a platform without getc_unlocked(): * By default, use fgets(). * If you don't want to use fgets(), #define DONT_USE_FGETS_IN_GETLINE. */#if !defined(USE_FGETS_IN_GETLINE) && !defined(HAVE_GETC_UNLOCKED)#define USE_FGETS_IN_GETLINE#endif#if defined(DONT_USE_FGETS_IN_GETLINE) && defined(USE_FGETS_IN_GETLINE)#undef USE_FGETS_IN_GETLINE#endif#ifdef USE_FGETS_IN_GETLINEstaticPyObject*getline_via_fgets(FILE*fp){/* INITBUFSIZE is the maximum line length that lets us get away with the fast * no-realloc, one-fgets()-call path. Boosting it isn't free, because we have * to fill this much of the buffer with a known value in order to figure out * how much of the buffer fgets() overwrites. So if INITBUFSIZE is larger * than "most" lines, we waste time filling unused buffer slots. 100 is * surely adequate for most peoples' email archives, chewing over source code, * etc -- "regular old text files". * MAXBUFSIZE is the maximum line length that lets us get away with the less * fast (but still zippy) no-realloc, two-fgets()-call path. See above for * cautions about boosting that. 300 was chosen because the worst real-life * text-crunching job reported on Python-Dev was a mail-log crawler where over * half the lines were 254 chars. */#define INITBUFSIZE 100#define MAXBUFSIZE 300char*p;/* temp */charbuf[MAXBUFSIZE];PyObject*v;/* the string object result */char*pvfree;/* address of next free slot */char*pvend;/* address one beyond last free slot */size_tnfree;/* # of free buffer slots; pvend-pvfree */size_ttotal_v_size;/* total # of slots in buffer */size_tincrement;/* amount to increment the buffer */size_tprev_v_size;/* Optimize for normal case: avoid _PyString_Resize if at all * possible via first reading into stack buffer "buf". */total_v_size=INITBUFSIZE;/* start small and pray */pvfree=buf;for(;;){Py_BEGIN_ALLOW_THREADSpvend=buf+total_v_size;nfree=pvend-pvfree;memset(pvfree,'\n',nfree);p=fgets(pvfree,nfree,fp);Py_END_ALLOW_THREADSif(p==NULL){clearerr(fp);if(PyErr_CheckSignals())returnNULL;v=PyString_FromStringAndSize(buf,pvfree-buf);returnv;}/* fgets read *something* */p=memchr(pvfree,'\n',nfree);if(p!=NULL){/* Did the \n come from fgets or from us? * Since fgets stops at the first \n, and then writes * \0, if it's from fgets a \0 must be next. But if * that's so, it could not have come from us, since * the \n's we filled the buffer with have only more * \n's to the right. */if(p+1<pvend&&*(p+1)=='\0'){/* It's from fgets: we win! In particular, * we haven't done any mallocs yet, and can * build the final result on the first try. */++p;/* include \n from fgets */}else{/* Must be from us: fgets didn't fill the * buffer and didn't find a newline, so it * must be the last and newline-free line of * the file. */assert(p>pvfree&&*(p-1)=='\0');--p;/* don't include \0 from fgets */}v=PyString_FromStringAndSize(buf,p-buf);returnv;}/* yuck: fgets overwrote all the newlines, i.e. the entire * buffer. So this line isn't over yet, or maybe it is but * we're exactly at EOF. If we haven't already, try using the * rest of the stack buffer. */assert(*(pvend-1)=='\0');if(pvfree==buf){pvfree=pvend-1;/* overwrite trailing null */total_v_size=MAXBUFSIZE;}elsebreak;}/* The stack buffer isn't big enough; malloc a string object and read * into its buffer. */total_v_size=MAXBUFSIZE<<1;v=PyString_FromStringAndSize((char*)NULL,(int)total_v_size);if(v==NULL)returnv;/* copy over everything except the last null byte */memcpy(BUF(v),buf,MAXBUFSIZE-1);pvfree=BUF(v)+MAXBUFSIZE-1;/* Keep reading stuff into v; if it ever ends successfully, break * after setting p one beyond the end of the line. The code here is * very much like the code above, except reads into v's buffer; see * the code above for detailed comments about the logic. */for(;;){Py_BEGIN_ALLOW_THREADSpvend=BUF(v)+total_v_size;nfree=pvend-pvfree;memset(pvfree,'\n',nfree);p=fgets(pvfree,nfree,fp);Py_END_ALLOW_THREADSif(p==NULL){clearerr(fp);if(PyErr_CheckSignals()){Py_DECREF(v);returnNULL;}p=pvfree;break;}p=memchr(pvfree,'\n',nfree);if(p!=NULL){if(p+1<pvend&&*(p+1)=='\0'){/* \n came from fgets */++p;break;}/* \n came from us; last line of file, no newline */assert(p>pvfree&&*(p-1)=='\0');--p;break;}/* expand buffer and try again */assert(*(pvend-1)=='\0');increment=total_v_size>>2;/* mild exponential growth */prev_v_size=total_v_size;total_v_size+=increment;/* check for overflow */if(total_v_size<=prev_v_size||total_v_size>INT_MAX){PyErr_SetString(PyExc_OverflowError,"line is longer than a Python string can hold");Py_DECREF(v);returnNULL;}if(_PyString_Resize(&v,(int)total_v_size)<0)returnNULL;/* overwrite the trailing null byte */pvfree=BUF(v)+(prev_v_size-1);}if(BUF(v)+total_v_size!=p)_PyString_Resize(&v,p-BUF(v));returnv;#undef INITBUFSIZE#undef MAXBUFSIZE}#endif /* ifdef USE_FGETS_IN_GETLINE *//* Internal routine to get a line. Size argument interpretation: > 0: max length; <= 0: read arbitrary line*/staticPyObject*get_line(PyFileObject*f,intn){FILE*fp=f->f_fp;intc;char*buf,*end;size_ttotal_v_size;/* total # of slots in buffer */size_tused_v_size;/* # used slots in buffer */size_tincrement;/* amount to increment the buffer */PyObject*v;intnewlinetypes=f->f_newlinetypes;intskipnextlf=f->f_skipnextlf;intuniv_newline=f->f_univ_newline;#if defined(USE_FGETS_IN_GETLINE)if(n<=0&&!univ_newline)returngetline_via_fgets(fp);#endiftotal_v_size=n>0?n:100;v=PyString_FromStringAndSize((char*)NULL,total_v_size);if(v==NULL)returnNULL;buf=BUF(v);end=buf+total_v_size;for(;;){Py_BEGIN_ALLOW_THREADSFLOCKFILE(fp);if(univ_newline){c='x';/* Shut up gcc warning */while(buf!=end&&(c=GETC(fp))!=EOF){if(skipnextlf){skipnextlf=0;if(c=='\n'){/* Seeing a \n here with * skipnextlf true means we * saw a \r before. */newlinetypes|=NEWLINE_CRLF;c=GETC(fp);if(c==EOF)break;}else{newlinetypes|=NEWLINE_CR;}}if(c=='\r'){skipnextlf=1;c='\n';}elseif(c=='\n')newlinetypes|=NEWLINE_LF;*buf++=c;if(c=='\n')break;}if(c==EOF&&skipnextlf)newlinetypes|=NEWLINE_CR;}else/* If not universal newlines use the normal loop */while((c=GETC(fp))!=EOF&&(*buf++=c)!='\n'&&buf!=end);FUNLOCKFILE(fp);Py_END_ALLOW_THREADSf->f_newlinetypes=newlinetypes;f->f_skipnextlf=skipnextlf;if(c=='\n')break;if(c==EOF){if(ferror(fp)){PyErr_SetFromErrno(PyExc_IOError);clearerr(fp);Py_DECREF(v);returnNULL;}clearerr(fp);if(PyErr_CheckSignals()){Py_DECREF(v);returnNULL;}break;}/* Must be because buf == end */if(n>0)break;used_v_size=total_v_size;increment=total_v_size>>2;/* mild exponential growth */total_v_size+=increment;if(total_v_size>INT_MAX){PyErr_SetString(PyExc_OverflowError,"line is longer than a Python string can hold");Py_DECREF(v);returnNULL;}if(_PyString_Resize(&v,total_v_size)<0)returnNULL;buf=BUF(v)+used_v_size;end=BUF(v)+total_v_size;}used_v_size=buf-BUF(v);if(used_v_size!=total_v_size)_PyString_Resize(&v,used_v_size);returnv;}/* External C interface */PyObject*PyFile_GetLine(PyObject*f,intn){PyObject*result;if(f==NULL){PyErr_BadInternalCall();returnNULL;}if(PyFile_Check(f)){if(((PyFileObject*)f)->f_fp==NULL)returnerr_closed();result=get_line((PyFileObject*)f,n);}else{PyObject*reader;PyObject*args;reader=PyObject_GetAttrString(f,"readline");if(reader==NULL)returnNULL;if(n<=0)args=PyTuple_New(0);elseargs=Py_BuildValue("(i)",n);if(args==NULL){Py_DECREF(reader);returnNULL;}result=PyEval_CallObject(reader,args);Py_DECREF(reader);Py_DECREF(args);if(result!=NULL&&!PyString_Check(result)&&!PyUnicode_Check(result)){Py_DECREF(result);result=NULL;PyErr_SetString(PyExc_TypeError,"object.readline() returned non-string");}}if(n<0&&result!=NULL&&PyString_Check(result)){char*s=PyString_AS_STRING(result);intlen=PyString_GET_SIZE(result);if(len==0){Py_DECREF(result);result=NULL;PyErr_SetString(PyExc_EOFError,"EOF when reading a line");}elseif(s[len-1]=='\n'){if(result->ob_refcnt==1)_PyString_Resize(&result,len-1);else{PyObject*v;v=PyString_FromStringAndSize(s,len-1);Py_DECREF(result);result=v;}}}#ifdef Py_USING_UNICODEif(n<0&&result!=NULL&&PyUnicode_Check(result)){Py_UNICODE*s=PyUnicode_AS_UNICODE(result);intlen=PyUnicode_GET_SIZE(result);if(len==0){Py_DECREF(result);result=NULL;PyErr_SetString(PyExc_EOFError,"EOF when reading a line");}elseif(s[len-1]=='\n'){if(result->ob_refcnt==1)PyUnicode_Resize(&result,len-1);else{PyObject*v;v=PyUnicode_FromUnicode(s,len-1);Py_DECREF(result);result=v;}}}#endifreturnresult;}/* Python method */staticPyObject*file_readline(PyFileObject*f,PyObject*args){intn=-1;if(f->f_fp==NULL)returnerr_closed();if(!PyArg_ParseTuple(args,"|i:readline",&n))returnNULL;if(n==0)returnPyString_FromString("");if(n<0)n=0;returnget_line(f,n);}staticPyObject*file_readlines(PyFileObject*f,PyObject*args){longsizehint=0;PyObject*list;PyObject*line;charsmall_buffer[SMALLCHUNK];char*buffer=small_buffer;size_tbuffersize=SMALLCHUNK;PyObject*big_buffer=NULL;size_tnfilled=0;size_tnread;size_ttotalread=0;char*p,*q,*end;interr;intshortread=0;if(f->f_fp==NULL)returnerr_closed();if(!PyArg_ParseTuple(args,"|l:readlines",&sizehint))returnNULL;if((list=PyList_New(0))==NULL)returnNULL;for(;;){if(shortread)nread=0;else{Py_BEGIN_ALLOW_THREADSerrno=0;nread=Py_UniversalNewlineFread(buffer+nfilled,buffersize-nfilled,f->f_fp,(PyObject*)f);Py_END_ALLOW_THREADSshortread=(nread<buffersize-nfilled);}if(nread==0){sizehint=0;if(!ferror(f->f_fp))break;PyErr_SetFromErrno(PyExc_IOError);clearerr(f->f_fp);error:Py_DECREF(list);list=NULL;gotocleanup;}totalread+=nread;p=memchr(buffer+nfilled,'\n',nread);if(p==NULL){/* Need a larger buffer to fit this line */nfilled+=nread;buffersize*=2;if(buffersize>INT_MAX){PyErr_SetString(PyExc_OverflowError,"line is longer than a Python string can hold");gotoerror;}if(big_buffer==NULL){/* Create the big buffer */big_buffer=PyString_FromStringAndSize(NULL,buffersize);if(big_buffer==NULL)gotoerror;buffer=PyString_AS_STRING(big_buffer);memcpy(buffer,small_buffer,nfilled);}else{/* Grow the big buffer */if(_PyString_Resize(&big_buffer,buffersize)<0)gotoerror;buffer=PyString_AS_STRING(big_buffer);}continue;}end=buffer+nfilled+nread;q=buffer;do{/* Process complete lines */p++;line=PyString_FromStringAndSize(q,p-q);if(line==NULL)gotoerror;err=PyList_Append(list,line);Py_DECREF(line);if(err!=0)gotoerror;q=p;p=memchr(q,'\n',end-q);}while(p!=NULL);/* Move the remaining incomplete line to the start */nfilled=end-q;memmove(buffer,q,nfilled);if(sizehint>0)if(totalread>=(size_t)sizehint)break;}if(nfilled!=0){/* Partial last line */line=PyString_FromStringAndSize(buffer,nfilled);if(line==NULL)gotoerror;if(sizehint>0){/* Need to complete the last line */PyObject*rest=get_line(f,0);if(rest==NULL){Py_DECREF(line);gotoerror;}PyString_Concat(&line,rest);Py_DECREF(rest);if(line==NULL)gotoerror;}err=PyList_Append(list,line);Py_DECREF(line);if(err!=0)gotoerror;}cleanup:Py_XDECREF(big_buffer);returnlist;}staticPyObject*file_write(PyFileObject*f,PyObject*args){char*s;intn,n2;if(f->f_fp==NULL)returnerr_closed();if(!PyArg_ParseTuple(args,f->f_binary?"s#":"t#",&s,&n))returnNULL;f->f_softspace=0;Py_BEGIN_ALLOW_THREADSerrno=0;n2=fwrite(s,1,n,f->f_fp);Py_END_ALLOW_THREADSif(n2!=n){PyErr_SetFromErrno(PyExc_IOError);clearerr(f->f_fp);returnNULL;}Py_INCREF(Py_None);returnPy_None;}staticPyObject*file_writelines(PyFileObject*f,PyObject*seq){#define CHUNKSIZE 1000PyObject*list,*line;PyObject*it;/* iter(seq) */PyObject*result;inti,j,index,len,nwritten,islist;assert(seq!=NULL);if(f->f_fp==NULL)returnerr_closed();result=NULL;list=NULL;islist=PyList_Check(seq);if(islist)it=NULL;else{it=PyObject_GetIter(seq);if(it==NULL){PyErr_SetString(PyExc_TypeError,"writelines() requires an iterable argument");returnNULL;}/* From here on, fail by going to error, to reclaim "it". */list=PyList_New(CHUNKSIZE);if(list==NULL)gotoerror;}/* Strategy: slurp CHUNKSIZE lines into a private list, checking that they are all strings, then write that list without holding the interpreter lock, then come back for more. */for(index=0;;index+=CHUNKSIZE){if(islist){Py_XDECREF(list);list=PyList_GetSlice(seq,index,index+CHUNKSIZE);if(list==NULL)gotoerror;j=PyList_GET_SIZE(list);}else{for(j=0;j<CHUNKSIZE;j++){line=PyIter_Next(it);if(line==NULL){if(PyErr_Occurred())gotoerror;break;}PyList_SetItem(list,j,line);}}if(j==0)break;/* Check that all entries are indeed strings. If not, apply the same rules as for file.write() and convert the results to strings. This is slow, but seems to be the only way since all conversion APIs could potentially execute Python code. */for(i=0;i<j;i++){PyObject*v=PyList_GET_ITEM(list,i);if(!PyString_Check(v)){constchar*buffer;intlen;if(((f->f_binary&&PyObject_AsReadBuffer(v,(constvoid**)&buffer,&len))||PyObject_AsCharBuffer(v,&buffer,&len))){PyErr_SetString(PyExc_TypeError,"writelines() argument must be a sequence of strings");gotoerror;}line=PyString_FromStringAndSize(buffer,len);if(line==NULL)gotoerror;Py_DECREF(v);PyList_SET_ITEM(list,i,line);}}/* Since we are releasing the global lock, the following code may *not* execute Python code. */Py_BEGIN_ALLOW_THREADSf->f_softspace=0;errno=0;for(i=0;i<j;i++){line=PyList_GET_ITEM(list,i);len=PyString_GET_SIZE(line);nwritten=fwrite(PyString_AS_STRING(line),1,len,f->f_fp);if(nwritten!=len){Py_BLOCK_THREADSPyErr_SetFromErrno(PyExc_IOError);clearerr(f->f_fp);gotoerror;}}Py_END_ALLOW_THREADSif(j<CHUNKSIZE)break;}Py_INCREF(Py_None);result=Py_None;error:Py_XDECREF(list);Py_XDECREF(it);returnresult;#undef CHUNKSIZE}staticPyObject*file_getiter(PyFileObject*f){if(f->f_fp==NULL)returnerr_closed();Py_INCREF(f);return(PyObject*)f;}PyDoc_STRVAR(readline_doc,"readline([size]) -> next line from the file, as a string.\n""\n""Retain newline. A non-negative size argument limits the maximum\n""number of bytes to return (an incomplete line may be returned then).\n""Return an empty string at EOF.");PyDoc_STRVAR(read_doc,"read([size]) -> read at most size bytes, returned as a string.\n""\n""If the size argument is negative or omitted, read until EOF is reached.\n""Notice that when in non-blocking mode, less data than what was requested\n""may be returned, even if no size parameter was given.");PyDoc_STRVAR(write_doc,"write(str) -> None. Write string str to file.\n""\n""Note that due to buffering, flush() or close() may be needed before\n""the file on disk reflects the data written.");PyDoc_STRVAR(fileno_doc,"fileno() -> integer \"file descriptor\".\n""\n""This is needed for lower-level file interfaces, such os.read().");PyDoc_STRVAR(seek_doc,"seek(offset[, whence]) -> None. Move to new file position.\n""\n""Argument offset is a byte count. Optional argument whence defaults to\n""0 (offset from start of file, offset should be >= 0); other values are 1\n""(move relative to current position, positive or negative), and 2 (move\n""relative to end of file, usually negative, although many platforms allow\n""seeking beyond the end of a file). If the file is opened in text mode,\n""only offsets returned by tell() are legal. Use of other offsets causes\n""undefined behavior.""\n""Note that not all file objects are seekable.");#ifdef HAVE_FTRUNCATEPyDoc_STRVAR(truncate_doc,"truncate([size]) -> None. Truncate the file to at most size bytes.\n""\n""Size defaults to the current file position, as returned by tell().");#endifPyDoc_STRVAR(tell_doc,"tell() -> current file position, an integer (may be a long integer).");PyDoc_STRVAR(readinto_doc,"readinto() -> Undocumented. Don't use this; it may go away.");PyDoc_STRVAR(readlines_doc,"readlines([size]) -> list of strings, each a line from the file.\n""\n""Call readline() repeatedly and return a list of the lines so read.\n""The optional size argument, if given, is an approximate bound on the\n""total number of bytes in the lines returned.");PyDoc_STRVAR(xreadlines_doc,"xreadlines() -> returns self.\n""\n""For backward compatibility. File objects now include the performance\n""optimizations previously implemented in the xreadlines module.");PyDoc_STRVAR(writelines_doc,"writelines(sequence_of_strings) -> None. Write the strings to the file.\n""\n""Note that newlines are not added. The sequence can be any iterable object\n""producing strings. This is equivalent to calling write() for each string.");PyDoc_STRVAR(flush_doc,"flush() -> None. Flush the internal I/O buffer.");PyDoc_STRVAR(close_doc,"close() -> None or (perhaps) an integer. Close the file.\n""\n""Sets data attribute .closed to True. A closed file cannot be used for\n""further I/O operations. close() may be called more than once without\n""error. Some kinds of file objects (for example, opened by popen())\n""may return an exit status upon closing.");PyDoc_STRVAR(isatty_doc,"isatty() -> true or false. True if the file is connected to a tty device.");staticPyMethodDeffile_methods[]={{"readline",(PyCFunction)file_readline,METH_VARARGS,readline_doc},{"read",(PyCFunction)file_read,METH_VARARGS,read_doc},{"write",(PyCFunction)file_write,METH_VARARGS,write_doc},{"fileno",(PyCFunction)file_fileno,METH_NOARGS,fileno_doc},{"seek",(PyCFunction)file_seek,METH_VARARGS,seek_doc},#ifdef HAVE_FTRUNCATE{"truncate",(PyCFunction)file_truncate,METH_VARARGS,truncate_doc},#endif{"tell",(PyCFunction)file_tell,METH_NOARGS,tell_doc},{"readinto",(PyCFunction)file_readinto,METH_VARARGS,readinto_doc},{"readlines",(PyCFunction)file_readlines,METH_VARARGS,readlines_doc},{"xreadlines",(PyCFunction)file_getiter,METH_NOARGS,xreadlines_doc},{"writelines",(PyCFunction)file_writelines,METH_O,writelines_doc},{"flush",(PyCFunction)file_flush,METH_NOARGS,flush_doc},{"close",(PyCFunction)file_close,METH_NOARGS,close_doc},{"isatty",(PyCFunction)file_isatty,METH_NOARGS,isatty_doc},{NULL,NULL}/* sentinel */};#define OFF(x) offsetof(PyFileObject, x)staticPyMemberDeffile_memberlist[]={{"softspace",T_INT,OFF(f_softspace),0,"flag indicating that a space needs to be printed; used by print"},{"mode",T_OBJECT,OFF(f_mode),RO,"file mode ('r', 'U', 'w', 'a', possibly with 'b' or '+' added)"},{"name",T_OBJECT,OFF(f_name),RO,"file name"},{"encoding",T_OBJECT,OFF(f_encoding),RO,"file encoding"},/* getattr(f, "closed") is implemented without this table */{NULL}/* Sentinel */};staticPyObject*get_closed(PyFileObject*f,void*closure){returnPyBool_FromLong((long)(f->f_fp==0));}staticPyObject*get_newlines(PyFileObject*f,void*closure){switch(f->f_newlinetypes){caseNEWLINE_UNKNOWN:Py_INCREF(Py_None);returnPy_None;caseNEWLINE_CR:returnPyString_FromString("\r");caseNEWLINE_LF:returnPyString_FromString("\n");caseNEWLINE_CR|NEWLINE_LF:returnPy_BuildValue("(ss)","\r","\n");caseNEWLINE_CRLF:returnPyString_FromString("\r\n");caseNEWLINE_CR|NEWLINE_CRLF:returnPy_BuildValue("(ss)","\r","\r\n");caseNEWLINE_LF|NEWLINE_CRLF:returnPy_BuildValue("(ss)","\n","\r\n");caseNEWLINE_CR|NEWLINE_LF|NEWLINE_CRLF:returnPy_BuildValue("(sss)","\r","\n","\r\n");default:PyErr_Format(PyExc_SystemError,"Unknown newlines value 0x%x\n",f->f_newlinetypes);returnNULL;}}staticPyGetSetDeffile_getsetlist[]={{"closed",(getter)get_closed,NULL,"True if the file is closed"},{"newlines",(getter)get_newlines,NULL,"end-of-line convention used in this file"},{0},};staticvoiddrop_readahead(PyFileObject*f){if(f->f_buf!=NULL){PyMem_Free(f->f_buf);f->f_buf=NULL;}}/* Make sure that file has a readahead buffer with at least one byte (unless at EOF) and no more than bufsize. Returns negative value on error, will set MemoryError if bufsize bytes cannot be allocated. */staticintreadahead(PyFileObject*f,intbufsize){intchunksize;if(f->f_buf!=NULL){if((f->f_bufend-f->f_bufptr)>=1)return0;elsedrop_readahead(f);}if((f->f_buf=PyMem_Malloc(bufsize))==NULL){PyErr_NoMemory();return-1;}Py_BEGIN_ALLOW_THREADSerrno=0;chunksize=Py_UniversalNewlineFread(f->f_buf,bufsize,f->f_fp,(PyObject*)f);Py_END_ALLOW_THREADSif(chunksize==0){if(ferror(f->f_fp)){PyErr_SetFromErrno(PyExc_IOError);clearerr(f->f_fp);drop_readahead(f);return-1;}}f->f_bufptr=f->f_buf;f->f_bufend=f->f_buf+chunksize;return0;}/* Used by file_iternext. The returned string will start with 'skip' uninitialized bytes followed by the remainder of the line. Don't be horrified by the recursive call: maximum recursion depth is limited by logarithmic buffer growth to about 50 even when reading a 1gb line. */staticPyStringObject*readahead_get_line_skip(PyFileObject*f,intskip,intbufsize){PyStringObject*s;char*bufptr;char*buf;intlen;if(f->f_buf==NULL)if(readahead(f,bufsize)<0)returnNULL;len=f->f_bufend-f->f_bufptr;if(len==0)return(PyStringObject*)PyString_FromStringAndSize(NULL,skip);bufptr=memchr(f->f_bufptr,'\n',len);if(bufptr!=NULL){bufptr++;/* Count the '\n' */len=bufptr-f->f_bufptr;s=(PyStringObject*)PyString_FromStringAndSize(NULL,skip+len);if(s==NULL)returnNULL;memcpy(PyString_AS_STRING(s)+skip,f->f_bufptr,len);f->f_bufptr=bufptr;if(bufptr==f->f_bufend)drop_readahead(f);}else{bufptr=f->f_bufptr;buf=f->f_buf;f->f_buf=NULL;/* Force new readahead buffer */s=readahead_get_line_skip(f,skip+len,bufsize+(bufsize>>2));if(s==NULL){PyMem_Free(buf);returnNULL;}memcpy(PyString_AS_STRING(s)+skip,bufptr,len);PyMem_Free(buf);}returns;}/* A larger buffer size may actually decrease performance. */#define READAHEAD_BUFSIZE 8192staticPyObject*file_iternext(PyFileObject*f){PyStringObject*l;if(f->f_fp==NULL)returnerr_closed();l=readahead_get_line_skip(f,0,READAHEAD_BUFSIZE);if(l==NULL||PyString_GET_SIZE(l)==0){Py_XDECREF(l);returnNULL;}return(PyObject*)l;}staticPyObject*file_new(PyTypeObject*type,PyObject*args,PyObject*kwds){PyObject*self;staticPyObject*not_yet_string;assert(type!=NULL&&type->tp_alloc!=NULL);if(not_yet_string==NULL){not_yet_string=PyString_FromString("<uninitialized file>");if(not_yet_string==NULL)returnNULL;}self=type->tp_alloc(type,0);if(self!=NULL){/* Always fill in the name and mode, so that nobody else needs to special-case NULLs there. */Py_INCREF(not_yet_string);((PyFileObject*)self)->f_name=not_yet_string;Py_INCREF(not_yet_string);((PyFileObject*)self)->f_mode=not_yet_string;Py_INCREF(Py_None);((PyFileObject*)self)->f_encoding=Py_None;((PyFileObject*)self)->weakreflist=NULL;}returnself;}staticintfile_init(PyObject*self,PyObject*args,PyObject*kwds){PyFileObject*foself=(PyFileObject*)self;intret=0;staticchar*kwlist[]={"name","mode","buffering",0};char*name=NULL;char*mode="r";intbufsize=-1;intwideargument=0;assert(PyFile_Check(self));if(foself->f_fp!=NULL){/* Have to close the existing file first. */PyObject*closeresult=file_close(foself);if(closeresult==NULL)return-1;Py_DECREF(closeresult);}#ifdef Py_WIN_WIDE_FILENAMESif(GetVersion()<0x80000000){/* On NT, so wide API available */PyObject*po;if(PyArg_ParseTupleAndKeywords(args,kwds,"U|si:file",kwlist,&po,&mode,&bufsize)){wideargument=1;if(fill_file_fields(foself,NULL,po,mode,fclose)==NULL)gotoError;}else{/* Drop the argument parsing error as narrow strings are also valid. */PyErr_Clear();}}#endifif(!wideargument){PyObject*o_name;if(!PyArg_ParseTupleAndKeywords(args,kwds,"et|si:file",kwlist,Py_FileSystemDefaultEncoding,&name,&mode,&bufsize))return-1;/* We parse again to get the name as a PyObject */if(!PyArg_ParseTupleAndKeywords(args,kwds,"O|si:file",kwlist,&o_name,&mode,&bufsize))gotoError;if(fill_file_fields(foself,NULL,o_name,mode,fclose)==NULL)gotoError;}if(open_the_file(foself,name,mode)==NULL)gotoError;foself->f_setbuf=NULL;PyFile_SetBufSize(self,bufsize);gotoDone;Error:ret=-1;/* fall through */Done:PyMem_Free(name);/* free the encoded string */returnret;}PyDoc_VAR(file_doc)=PyDoc_STR("file(name[, mode[, buffering]]) -> file object\n""\n""Open a file. The mode can be 'r', 'w' or 'a' for reading (default),\n""writing or appending. The file will be created if it doesn't exist\n""when opened for writing or appending; it will be truncated when\n""opened for writing. Add a 'b' to the mode for binary files.\n""Add a '+' to the mode to allow simultaneous reading and writing.\n""If the buffering argument is given, 0 means unbuffered, 1 means line\n""buffered, and larger numbers specify the buffer size.\n")PyDoc_STR("Add a 'U' to mode to open the file for input with universal newline\n""support. Any line ending in the input file will be seen as a '\\n'\n""in Python. Also, a file so opened gains the attribute 'newlines';\n""the value for this attribute is one of None (no newline read yet),\n""'\\r', '\\n', '\\r\\n' or a tuple containing all the newline types seen.\n""\n""'U' cannot be combined with 'w' or '+' mode.\n")PyDoc_STR("\n""Note: open() is an alias for file().");PyTypeObjectPyFile_Type={PyObject_HEAD_INIT(&PyType_Type)0,"file",sizeof(PyFileObject),0,(destructor)file_dealloc,/* tp_dealloc */0,/* tp_print */0,/* tp_getattr */0,/* tp_setattr */0,/* tp_compare */(reprfunc)file_repr,/* tp_repr */0,/* tp_as_number */0,/* tp_as_sequence */0,/* tp_as_mapping */0,/* tp_hash */0,/* tp_call */0,/* tp_str */PyObject_GenericGetAttr,/* tp_getattro *//* softspace is writable: we must supply tp_setattro */PyObject_GenericSetAttr,/* tp_setattro */0,/* tp_as_buffer */Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_WEAKREFS,/* tp_flags */file_doc,/* tp_doc */0,/* tp_traverse */0,/* tp_clear */0,/* tp_richcompare */offsetof(PyFileObject,weakreflist),/* tp_weaklistoffset */(getiterfunc)file_getiter,/* tp_iter */(iternextfunc)file_iternext,/* tp_iternext */file_methods,/* tp_methods */file_memberlist,/* tp_members */file_getsetlist,/* tp_getset */0,/* tp_base */0,/* tp_dict */0,/* tp_descr_get */0,/* tp_descr_set */0,/* tp_dictoffset */(initproc)file_init,/* tp_init */PyType_GenericAlloc,/* tp_alloc */file_new,/* tp_new */PyObject_Del,/* tp_free */};/* Interface for the 'soft space' between print items. */intPyFile_SoftSpace(PyObject*f,intnewflag){intoldflag=0;if(f==NULL){/* Do nothing */}elseif(PyFile_Check(f)){oldflag=((PyFileObject*)f)->f_softspace;((PyFileObject*)f)->f_softspace=newflag;}else{PyObject*v;v=PyObject_GetAttrString(f,"softspace");if(v==NULL)PyErr_Clear();else{if(PyInt_Check(v))oldflag=PyInt_AsLong(v);Py_DECREF(v);}v=PyInt_FromLong((long)newflag);if(v==NULL)PyErr_Clear();else{if(PyObject_SetAttrString(f,"softspace",v)!=0)PyErr_Clear();Py_DECREF(v);}}returnoldflag;}/* Interfaces to write objects/strings to file-like objects */intPyFile_WriteObject(PyObject*v,PyObject*f,intflags){PyObject*writer,*value,*args,*result;if(f==NULL){PyErr_SetString(PyExc_TypeError,"writeobject with NULL file");return-1;}elseif(PyFile_Check(f)){FILE*fp=PyFile_AsFile(f);#ifdef Py_USING_UNICODEPyObject*enc=((PyFileObject*)f)->f_encoding;intresult;#endifif(fp==NULL){err_closed();return-1;}#ifdef Py_USING_UNICODEif((flags&Py_PRINT_RAW)&&PyUnicode_Check(v)&&enc!=Py_None){char*cenc=PyString_AS_STRING(enc);value=PyUnicode_AsEncodedString(v,cenc,"strict");if(value==NULL)return-1;}else{value=v;Py_INCREF(value);}result=PyObject_Print(value,fp,flags);Py_DECREF(value);returnresult;#elsereturnPyObject_Print(v,fp,flags);#endif}writer=PyObject_GetAttrString(f,"write");if(writer==NULL)return-1;if(flags&Py_PRINT_RAW){if(PyUnicode_Check(v)){value=v;Py_INCREF(value);}elsevalue=PyObject_Str(v);}elsevalue=PyObject_Repr(v);if(value==NULL){Py_DECREF(writer);return-1;}args=PyTuple_Pack(1,value);if(args==NULL){Py_DECREF(value);Py_DECREF(writer);return-1;}result=PyEval_CallObject(writer,args);Py_DECREF(args);Py_DECREF(value);Py_DECREF(writer);if(result==NULL)return-1;Py_DECREF(result);return0;}intPyFile_WriteString(constchar*s,PyObject*f){if(f==NULL){/* Should be caused by a pre-existing error */if(!PyErr_Occurred())PyErr_SetString(PyExc_SystemError,"null file for PyFile_WriteString");return-1;}elseif(PyFile_Check(f)){FILE*fp=PyFile_AsFile(f);if(fp==NULL){err_closed();return-1;}fputs(s,fp);return0;}elseif(!PyErr_Occurred()){PyObject*v=PyString_FromString(s);interr;if(v==NULL)return-1;err=PyFile_WriteObject(v,f,Py_PRINT_RAW);Py_DECREF(v);returnerr;}elsereturn-1;}/* Try to get a file-descriptor from a Python object. If the object is an integer or long integer, its value is returned. If not, the object's fileno() method is called if it exists; the method must return an integer or long integer, which is returned as the file descriptor value. -1 is returned on failure.*/intPyObject_AsFileDescriptor(PyObject*o){intfd;PyObject*meth;if(PyInt_Check(o)){fd=PyInt_AsLong(o);}elseif(PyLong_Check(o)){fd=PyLong_AsLong(o);}elseif((meth=PyObject_GetAttrString(o,"fileno"))!=NULL){PyObject*fno=PyEval_CallObject(meth,NULL);Py_DECREF(meth);if(fno==NULL)return-1;if(PyInt_Check(fno)){fd=PyInt_AsLong(fno);Py_DECREF(fno);}elseif(PyLong_Check(fno)){fd=PyLong_AsLong(fno);Py_DECREF(fno);}else{PyErr_SetString(PyExc_TypeError,"fileno() returned a non-integer");Py_DECREF(fno);return-1;}}else{PyErr_SetString(PyExc_TypeError,"argument must be an int, or have a fileno() method.");return-1;}if(fd<0){PyErr_Format(PyExc_ValueError,"file descriptor cannot be a negative integer (%i)",fd);return-1;}returnfd;}/* From here on we need access to the real fgets and fread */#undef fgets#undef fread/*** Py_UniversalNewlineFgets is an fgets variation that understands** all of \r, \n and \r\n conventions.** The stream should be opened in binary mode.** If fobj is NULL the routine always does newline conversion, and** it may peek one char ahead to gobble the second char in \r\n.** If fobj is non-NULL it must be a PyFileObject. In this case there** is no readahead but in stead a flag is used to skip a following** \n on the next read. Also, if the file is open in binary mode** the whole conversion is skipped. Finally, the routine keeps track of** the different types of newlines seen.** Note that we need no error handling: fgets() treats error and eof** identically.*/char*Py_UniversalNewlineFgets(char*buf,intn,FILE*stream,PyObject*fobj){char*p=buf;intc;intnewlinetypes=0;intskipnextlf=0;intuniv_newline=1;if(fobj){if(!PyFile_Check(fobj)){errno=ENXIO;/* What can you do... */returnNULL;}univ_newline=((PyFileObject*)fobj)->f_univ_newline;if(!univ_newline)returnfgets(buf,n,stream);newlinetypes=((PyFileObject*)fobj)->f_newlinetypes;skipnextlf=((PyFileObject*)fobj)->f_skipnextlf;}FLOCKFILE(stream);c='x';/* Shut up gcc warning */while(--n>0&&(c=GETC(stream))!=EOF){if(skipnextlf){skipnextlf=0;if(c=='\n'){/* Seeing a \n here with skipnextlf true ** means we saw a \r before. */newlinetypes|=NEWLINE_CRLF;c=GETC(stream);if(c==EOF)break;}else{/* ** Note that c == EOF also brings us here, ** so we're okay if the last char in the file ** is a CR. */newlinetypes|=NEWLINE_CR;}}if(c=='\r'){/* A \r is translated into a \n, and we skip ** an adjacent \n, if any. We don't set the ** newlinetypes flag until we've seen the next char. */skipnextlf=1;c='\n';}elseif(c=='\n'){newlinetypes|=NEWLINE_LF;}*p++=c;if(c=='\n')break;}if(c==EOF&&skipnextlf)newlinetypes|=NEWLINE_CR;FUNLOCKFILE(stream);*p='\0';if(fobj){((PyFileObject*)fobj)->f_newlinetypes=newlinetypes;((PyFileObject*)fobj)->f_skipnextlf=skipnextlf;}elseif(skipnextlf){/* If we have no file object we cannot save the ** skipnextlf flag. We have to readahead, which ** will cause a pause if we're reading from an ** interactive stream, but that is very unlikely ** unless we're doing something silly like ** execfile("/dev/tty"). */c=GETC(stream);if(c!='\n')ungetc(c,stream);}if(p==buf)returnNULL;returnbuf;}/*** Py_UniversalNewlineFread is an fread variation that understands** all of \r, \n and \r\n conventions.** The stream should be opened in binary mode.** fobj must be a PyFileObject. In this case there** is no readahead but in stead a flag is used to skip a following** \n on the next read. Also, if the file is open in binary mode** the whole conversion is skipped. Finally, the routine keeps track of** the different types of newlines seen.*/size_tPy_UniversalNewlineFread(char*buf,size_tn,FILE*stream,PyObject*fobj){char*dst=buf;PyFileObject*f=(PyFileObject*)fobj;intnewlinetypes,skipnextlf;assert(buf!=NULL);assert(stream!=NULL);if(!fobj||!PyFile_Check(fobj)){errno=ENXIO;/* What can you do... */return0;}if(!f->f_univ_newline)returnfread(buf,1,n,stream);newlinetypes=f->f_newlinetypes;skipnextlf=f->f_skipnextlf;/* Invariant: n is the number of bytes remaining to be filled * in the buffer. */while(n){size_tnread;intshortread;char*src=dst;nread=fread(dst,1,n,stream);assert(nread<=n);if(nread==0)break;n-=nread;/* assuming 1 byte out for each in; will adjust */shortread=n!=0;/* true iff EOF or error */while(nread--){charc=*src++;if(c=='\r'){/* Save as LF and set flag to skip next LF. */*dst++='\n';skipnextlf=1;}elseif(skipnextlf&&c=='\n'){/* Skip LF, and remember we saw CR LF. */skipnextlf=0;newlinetypes|=NEWLINE_CRLF;++n;}else{/* Normal char to be stored in buffer. Also * update the newlinetypes flag if either this * is an LF or the previous char was a CR. */if(c=='\n')newlinetypes|=NEWLINE_LF;elseif(skipnextlf)newlinetypes|=NEWLINE_CR;*dst++=c;skipnextlf=0;}}if(shortread){/* If this is EOF, update type flags. */if(skipnextlf&&feof(stream))newlinetypes|=NEWLINE_CR;break;}}f->f_newlinetypes=newlinetypes;f->f_skipnextlf=skipnextlf;returndst-buf;}