hg/stx-libbasic: comparison FileStream.st

equal deleted inserted replaced

-:ae1fcb227a45
+:5a86b95bebbb
 #ifdef transputer
 # include <iocntrl.h>
 # ifndef fileno
 /* kludge: inmos forgot fileno */
 #  define fileno(f)     ((f)->__file)
 # endif
 #else /* not transputer */
 # include <sys/types.h>
 # include <sys/stat.h>
 "
 This class provides access to the operating systems underlying file
 system (i.e. its an interface to the stdio library).
 Notice, that on some systems, the standard I/O library has performance
 problems when a file is opened for readwrite.
 For best results, open files either readonly or writeonly.
 Also notice, that some OperatingSystems do not fully support
 positioning a file stream.
 For example, poor VMS does not allow positioning onto arbitrary
 	newFile openWithMode:'w' attributes:#('rfm=fix' 'fsz=100').
 since all of the above is private protocol, and it is considered bad style to
 access these from user programs, we recommend subclassing FileStream as
 something like VMSFixedRecordFileStream, and redefine the instance creation
 method(s) there as appropriate.
 This will retain VMS specifics in one place and enhance maintanability.
 "
 ! !
 !FileStream class methodsFor:'initialization'!
 newStream := self new pathName:filename.
 ^ newStream openForReading.
 "
 FileStream readonlyFileNamed:'dAsGiBtEsNiChT'
 "
 !
 readonlyFileNamed:filename in:aDirectory
 "return a readonly FileStream for existing file named filename, aString
 in earlier versions of ST/X, failed file open operations
 returned nil - now, an error is raised.
 The old behavior is simulated by providing an exception
 handler, which proceeds with nil:
-OpenError ignoreIn:[
+	OpenError ignoreIn:[
-'old code expecting nil return values on errors when doing an open'.
+	    'old code expecting nil return values on errors when doing an open'.
-('/dasGIBtEsbeStimmtNiChT' asFilename readStream) isNil ifTrue:[
+	    ('/dasGIBtEsbeStimmtNiChT' asFilename readStream) isNil ifTrue:[
-self warn:'open failed'.
+		self warn:'open failed'.
-].
+	    ].
-]
+	]
 "
 LastErrorNumber := lastErrorNumber.
 ^ super openError.
 "the sendfile() system call currently (2004-05-07) handles only descriptors that
 support mmap-like operations as from-fd.
 Therefore, this method is reimplemented here (from ExternalStream)"
 outStream isExternalStream ifTrue:[
-pos := self position0Based.
+	pos := self position0Based.
-n := self size - pos.
+	n := self size - pos.
-nWritten := OperatingSystem
+	nWritten := OperatingSystem
-copyFromFd:(self fileDescriptor)
+	    copyFromFd:(self fileDescriptor)
-toFd:(outStream fileDescriptor)
+	    toFd:(outStream fileDescriptor)
-startIndex:pos
+	    startIndex:pos
-count:n.
+	    count:n.
-nWritten = n ifTrue:[
+	nWritten = n ifTrue:[
-^ self
+	    ^ self
-].
+	].
-nWritten > 0 ifTrue:[
+	nWritten > 0 ifTrue:[
-self position0Based:pos+nWritten.
+	    self position0Based:pos+nWritten.
-].
+	].
 ].
 ^ super copyToEndInto:outStream.
 "
 |in out|
 if (__INST(filePointer) != nil) {
 	do {
 	    f = __FILEVal(__INST(filePointer));
 #ifdef WIN32
 	    __threadErrno = 0;
 	    if (__INST(buffered) == true) {
 # if 0
 		currentPosition = STX_C_CALL1( "ftell", ftell, f);
 # else
 		currentPosition = ftell(f);
 # endif
 	    } else {
 		OBJ rA = __INST(readAhead);
 		off_t offs = 0;
 		if (rA != nil) {
 		    __INST(readAhead) = nil;
 		    offs = -1;
 		}
 # if 0
 		currentPosition = STX_C_CALL3( "lseek", lseek, fileno(f), offs, SEEK_CUR);
 # else
 		currentPosition = lseek(fileno(f), offs, SEEK_CUR);
 # endif
 	    }
 #else /* !WIN32 */
 	    if (__INST(buffered) == true) {
 #ifdef _LFS_LARGEFILE
 HFILE f;
 long ret;
 OBJ fp;
 if ((__INST(canPosition) != false) || (newPos == __MKSMALLINT(0))) {
-if ((fp = __INST(filePointer)) != nil) {
+	if ((fp = __INST(filePointer)) != nil) {
 #if defined(_LFS_LARGE_FILE) && !defined(WIN32)
 # define FSEEK fseeko
-off_t nP;
+	    off_t nP;
 #else
 #define FSEEK fseek
-long nP;
+	    long nP;
 #endif
-if (__isSmallInteger(newPos)) {
+	    if (__isSmallInteger(newPos)) {
-nP = __intVal(newPos);
+		nP = __intVal(newPos);
-if (nP < 0) {
+		if (nP < 0) {
-__INST(lastErrorNumber) = __MKSMALLINT(EINVAL);
+		    __INST(lastErrorNumber) = __MKSMALLINT(EINVAL);
-goto getOutOfHere;
+		    goto getOutOfHere;
-}
+		}
-} else {
+	    } else {
-nP = __signedLongIntVal(newPos);
+		nP = __signedLongIntVal(newPos);
-if (nP < 0) {
+		if (nP < 0) {
-__INST(lastErrorNumber) = __MKSMALLINT(EINVAL);
+		    __INST(lastErrorNumber) = __MKSMALLINT(EINVAL);
-goto getOutOfHere;
+		    goto getOutOfHere;
-}
+		}
-if (nP == 0) {
+		if (nP == 0) {
-if (sizeof(nP) == 8) {
+		    if (sizeof(nP) == 8) {
-if (__signedLong64IntVal(newPos, &nP) == 0 || nP < 0) {
+			if (__signedLong64IntVal(newPos, &nP) == 0 || nP < 0) {
-__INST(lastErrorNumber) = __MKSMALLINT(EINVAL);
+			    __INST(lastErrorNumber) = __MKSMALLINT(EINVAL);
-goto getOutOfHere;
+			    goto getOutOfHere;
-}
+			}
-} else {
+		    } else {
-__INST(lastErrorNumber) = __MKSMALLINT(EINVAL);
+			__INST(lastErrorNumber) = __MKSMALLINT(EINVAL);
-goto getOutOfHere;
+			goto getOutOfHere;
-}
+		    }
-}
+		}
-}
+	    }
-f = __FILEVal(fp);
+	    f = __FILEVal(fp);
-do {
+	    do {
 #ifdef WIN32
-__threadErrno = 0;
+		__threadErrno = 0;
-if (__INST(buffered) == true) {
+		if (__INST(buffered) == true) {
-ret = STX_C_CALL3( "fseek", fseek, f, nP, SEEK_SET);
+		    ret = STX_C_CALL3( "fseek", fseek, f, nP, SEEK_SET);
-} else {
+		} else {
-__INST(readAhead) = nil;
+		    __INST(readAhead) = nil;
-ret = STX_C_CALL3( "lseek", lseek, fileno(f), nP, SEEK_SET);
+		    ret = STX_C_CALL3( "lseek", lseek, fileno(f), nP, SEEK_SET);
-}
+		}
 #else
-if (__INST(buffered) == true) {
+		if (__INST(buffered) == true) {
-ret = FSEEK(f, nP, SEEK_SET);
+		    ret = FSEEK(f, nP, SEEK_SET);
-} else {
+		} else {
-ret = lseek(fileno(f), nP, SEEK_SET);
+		    ret = lseek(fileno(f), nP, SEEK_SET);
-}
+		}
 #endif
-} while ((ret < 0) && (__threadErrno == EINTR));
+	    } while ((ret < 0) && (__threadErrno == EINTR));
-if (ret >= 0) {
+	    if (ret >= 0) {
-__INST(position) = newPos; __STORE(self, newPos);
+		__INST(position) = newPos; __STORE(self, newPos);
-/*
+		/*
-* just to make certain ...
+		 * just to make certain ...
-*/
+		 */
-__INST(hitEOF) = false;
+		__INST(hitEOF) = false;
-RETURN ( self );
+		RETURN ( self );
-}
+	    }
-__INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
-}
+	}
 }
 getOutOfHere: ;
 #undef FSEEK
 %}.
 canPosition == false ifTrue:[
-"/ position by rewinding & re-reading everything up-to
+	"/ position by rewinding & re-reading everything up-to
-"/ that point.
+	"/ that point.
-^ self slowPosition0Based:newPos
+	^ self slowPosition0Based:newPos
 ].
 lastErrorNumber notNil ifTrue:[
-(OperatingSystem errorSymbolForNumber:lastErrorNumber) == #EINVAL ifTrue:[
+	(OperatingSystem errorSymbolForNumber:lastErrorNumber) == #EINVAL ifTrue:[
-"/ invalid position
+	    "/ invalid position
-^ self positionError
+	    ^ self positionError
-].
+	].
-"/ assume I/O error
+	"/ assume I/O error
-^ self ioError
+	^ self ioError
 ].
 filePointer isNil ifTrue:[^ self errorNotOpen].
 rslt := self positionFile:filePointer position:newPos.
 rslt >= 0 ifTrue:[
-position := newPos.
+	position := newPos.
 ] ifFalse:[
-hitEOF := true.
+	hitEOF := true.
 ]
 !
 setToEnd
 "set the read/write position in the file to be at the end of the file"
 	f = __FILEVal(__INST(filePointer));
 	__INST(position) = nil;    /* i.e. unknown */
 	do {
 #ifdef WIN32
 	    __threadErrno = 0;
 	    if (__INST(buffered) == true) {
 		ret = STX_C_CALL3( "fseek", fseek, f, 0L, SEEK_END);
 	    } else {
 		__INST(readAhead) = nil;
 		ret = STX_C_CALL3( "lseek", lseek, fileno(f), 0L, SEEK_END);
 	    }
 #else
 	    if (__INST(buffered) == true) {
 #ifdef _LFS_LARGE_FILE
 		ret = fseeko(f, (off_t)0, SEEK_END);
 #else
 		ret = fseek(f, 0L, SEEK_END);
 #endif
 	    } else {
 		ret = lseek(fileno(f), (off_t)0, SEEK_END);
 	    }
 "low level close - may be redefined in subclasses.
 Don't send this message, send #close instead"
 super closeFile.
 removeOnClose == true ifTrue:[
-pathName asFilename remove.
+	pathName asFilename remove.
 ]
 "Created: / 13.8.1998 / 12:11:22 / cg"
 ! !
 didWrite := true.
 ^ self openWithMode:WriteMode
 !
 openFile:pathName withMode:openmode attributes:attributeSpec
 "open the file;
 openmode is the string defining the way to open as defined by the stdio library
 (i.e. the 2nd fopen argument).
 attributeSpec is an additional argument, only used with VMS - it allows a file to
 be created as fixedRecord, variableRecord, streamLF, streamCR, ...
 |wasBlocked|
 %{
 HFILE f;
 HFILE fopen();
-OBJ fp;
 int pass = 0;
 retry:
 if (__isNonNilObject(pathName) && (__qClass(pathName)==String)) {
 #ifdef __VMS__
-do {
+	do {
-/*
+	    /*
-* allow passing additional RMS arguments.
+	     * allow passing additional RMS arguments.
-* stupid: DEC does not seem to offer an interface for passing a char **.
+	     * stupid: DEC does not seem to offer an interface for passing a char **.
-*/
+	     */
-__threadErrno = 0;
+	    __threadErrno = 0;
-{
+	    {
-if (__isArray(attributeSpec)) {
+		if (__isArray(attributeSpec)) {
-OBJ *ap = __ArrayInstPtr(attributeSpec)->a_element;
+		    OBJ *ap = __ArrayInstPtr(attributeSpec)->a_element;
-int numAttrib = 0;
+		    int numAttrib = 0;
-int i;
+		    int i;
-numAttrib = __arraySize(attributeSpec);
+		    numAttrib = __arraySize(attributeSpec);
-for (i=0; i<numAttrib;i++) {
+		    for (i=0; i<numAttrib;i++) {
-if (! __isString(ap[i])) {
+			if (! __isString(ap[i])) {
-f = NULL;
+			    f = NULL;
-__threadErrno = EINVAL; /* invalid argument */
+			    __threadErrno = EINVAL; /* invalid argument */
-goto getOutOfHere;
+			    goto getOutOfHere;
-}
+			}
-}
+		    }
-switch (numAttrib) {
+		    switch (numAttrib) {
-case 0:
+			case 0:
-__BEGIN_INTERRUPTABLE__
+			    __BEGIN_INTERRUPTABLE__
-f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode));
+			    f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode));
-__END_INTERRUPTABLE__
+			    __END_INTERRUPTABLE__
-break;
+			    break;
-case 1:
+			case 1:
-__BEGIN_INTERRUPTABLE__
+			    __BEGIN_INTERRUPTABLE__
-f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode),
+			    f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode),
-__stringVal(ap[0]));
+				      __stringVal(ap[0]));
-__END_INTERRUPTABLE__
+			    __END_INTERRUPTABLE__
-break;
+			    break;
-case 2:
+			case 2:
-__BEGIN_INTERRUPTABLE__
+			    __BEGIN_INTERRUPTABLE__
-f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode),
+			    f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode),
-__stringVal(ap[0]), __stringVal(ap[1]));
+				      __stringVal(ap[0]), __stringVal(ap[1]));
-__END_INTERRUPTABLE__
+			    __END_INTERRUPTABLE__
-break;
+			    break;
-case 3:
+			case 3:
-__BEGIN_INTERRUPTABLE__
+			    __BEGIN_INTERRUPTABLE__
-f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode),
+			    f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode),
-__stringVal(ap[0]), __stringVal(ap[1]), __stringVal(ap[2]));
+				      __stringVal(ap[0]), __stringVal(ap[1]), __stringVal(ap[2]));
-__END_INTERRUPTABLE__
+			    __END_INTERRUPTABLE__
-break;
+			    break;
-case 4:
+			case 4:
-__BEGIN_INTERRUPTABLE__
+			    __BEGIN_INTERRUPTABLE__
-f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode),
+			    f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode),
-__stringVal(ap[0]), __stringVal(ap[1]), __stringVal(ap[2]),
+				      __stringVal(ap[0]), __stringVal(ap[1]), __stringVal(ap[2]),
-__stringVal(ap[3]));
+				      __stringVal(ap[3]));
-__END_INTERRUPTABLE__
+			    __END_INTERRUPTABLE__
-break;
+			    break;
-case 5:
+			case 5:
-__BEGIN_INTERRUPTABLE__
+			    __BEGIN_INTERRUPTABLE__
-f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode),
+			    f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode),
-__stringVal(ap[0]), __stringVal(ap[1]), __stringVal(ap[2]),
+				      __stringVal(ap[0]), __stringVal(ap[1]), __stringVal(ap[2]),
-__stringVal(ap[3]), __stringVal(ap[4]));
+				      __stringVal(ap[3]), __stringVal(ap[4]));
-__END_INTERRUPTABLE__
+			    __END_INTERRUPTABLE__
-break;
+			    break;
-case 6:
+			case 6:
-__BEGIN_INTERRUPTABLE__
+			    __BEGIN_INTERRUPTABLE__
-f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode),
+			    f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode),
-__stringVal(ap[0]), __stringVal(ap[1]), __stringVal(ap[2]),
+				      __stringVal(ap[0]), __stringVal(ap[1]), __stringVal(ap[2]),
-__stringVal(ap[3]), __stringVal(ap[4]), __stringVal(ap[5]));
+				      __stringVal(ap[3]), __stringVal(ap[4]), __stringVal(ap[5]));
-__END_INTERRUPTABLE__
+			    __END_INTERRUPTABLE__
-break;
+			    break;
-case 7:
+			case 7:
-__BEGIN_INTERRUPTABLE__
+			    __BEGIN_INTERRUPTABLE__
-f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode),
+			    f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode),
-__stringVal(ap[0]), __stringVal(ap[1]), __stringVal(ap[2]),
+				      __stringVal(ap[0]), __stringVal(ap[1]), __stringVal(ap[2]),
-__stringVal(ap[3]), __stringVal(ap[4]), __stringVal(ap[5]),
+				      __stringVal(ap[3]), __stringVal(ap[4]), __stringVal(ap[5]),
-__stringVal(ap[6]));
+				      __stringVal(ap[6]));
-__END_INTERRUPTABLE__
+			    __END_INTERRUPTABLE__
-break;
+			    break;
-case 8:
+			case 8:
-__BEGIN_INTERRUPTABLE__
+			    __BEGIN_INTERRUPTABLE__
-f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode),
+			    f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode),
-__stringVal(ap[0]), __stringVal(ap[1]), __stringVal(ap[2]),
+				      __stringVal(ap[0]), __stringVal(ap[1]), __stringVal(ap[2]),
-__stringVal(ap[3]), __stringVal(ap[4]), __stringVal(ap[5]),
+				      __stringVal(ap[3]), __stringVal(ap[4]), __stringVal(ap[5]),
-__stringVal(ap[6]), __stringVal(ap[7]));
+				      __stringVal(ap[6]), __stringVal(ap[7]));
-__END_INTERRUPTABLE__
+			    __END_INTERRUPTABLE__
-break;
+			    break;
-case 9:
+			case 9:
-__BEGIN_INTERRUPTABLE__
+			    __BEGIN_INTERRUPTABLE__
-f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode),
+			    f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode),
-__stringVal(ap[0]), __stringVal(ap[1]), __stringVal(ap[2]),
+				      __stringVal(ap[0]), __stringVal(ap[1]), __stringVal(ap[2]),
-__stringVal(ap[3]), __stringVal(ap[4]), __stringVal(ap[5]),
+				      __stringVal(ap[3]), __stringVal(ap[4]), __stringVal(ap[5]),
-__stringVal(ap[6]), __stringVal(ap[7]), __stringVal(ap[8]));
+				      __stringVal(ap[6]), __stringVal(ap[7]), __stringVal(ap[8]));
-__END_INTERRUPTABLE__
+			    __END_INTERRUPTABLE__
-break;
+			    break;
-case 10:
+			case 10:
-__BEGIN_INTERRUPTABLE__
+			    __BEGIN_INTERRUPTABLE__
-f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode),
+			    f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode),
-__stringVal(ap[0]), __stringVal(ap[1]), __stringVal(ap[2]),
+				      __stringVal(ap[0]), __stringVal(ap[1]), __stringVal(ap[2]),
-__stringVal(ap[3]), __stringVal(ap[4]), __stringVal(ap[5]),
+				      __stringVal(ap[3]), __stringVal(ap[4]), __stringVal(ap[5]),
-__stringVal(ap[6]), __stringVal(ap[7]), __stringVal(ap[8]),
+				      __stringVal(ap[6]), __stringVal(ap[7]), __stringVal(ap[8]),
-__stringVal(ap[9]));
+				      __stringVal(ap[9]));
-__END_INTERRUPTABLE__
+			    __END_INTERRUPTABLE__
-break;
+			    break;
-default:
+			default:
-f = NULL;
+			    f = NULL;
-__threadErrno = E2BIG; /* too many args */
+			    __threadErrno = E2BIG; /* too many args */
-goto getOutOfHere;
+			    goto getOutOfHere;
-}
+		    }
-} else if (attributeSpec != nil) {
+		} else if (attributeSpec != nil) {
-f = NULL;
+		    f = NULL;
-__threadErrno = EINVAL; /* invalid argument */
+		    __threadErrno = EINVAL; /* invalid argument */
-goto getOutOfHere;
+		    goto getOutOfHere;
-} else {
+		} else {
-/*
+		    /*
-* create file as sequential streamLF by default.
+		     * create file as sequential streamLF by default.
-*/
+		     */
-__BEGIN_INTERRUPTABLE__
+		    __BEGIN_INTERRUPTABLE__
-f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode), "rfm=stmlf");
+		    f = fopen((char *)__stringVal(pathName), (char *)__stringVal(openmode), "rfm=stmlf");
-__END_INTERRUPTABLE__
+		    __END_INTERRUPTABLE__
-}
+		}
-}
+	    }
-} while ((f == NULL) && (__threadErrno == EINTR));
+	} while ((f == NULL) && (__threadErrno == EINTR));
 #else /* not VMS */
 # ifdef WIN32
-{
+	{
-char _aPathName[MAXPATHLEN];
+	    char _aPathName[MAXPATHLEN];
-char _openMode[64];
+	    char _openMode[64];
-strncpy(_aPathName, __stringVal(pathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
+	    strncpy(_aPathName, __stringVal(pathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
-strncpy(_openMode, __stringVal(openmode), sizeof(_openMode)-1); _openMode[sizeof(_openMode)-1] = '\0';
+	    strncpy(_openMode, __stringVal(openmode), sizeof(_openMode)-1); _openMode[sizeof(_openMode)-1] = '\0';
-do {
+	    do {
-__threadErrno = 0;
+		__threadErrno = 0;
-f = STX_C_CALL2( "fopen", fopen, _aPathName, _openMode);
+		f = STX_C_CALL2( "fopen", fopen, _aPathName, _openMode);
-if (__threadErrno == EINTR) {
+		if (__threadErrno == EINTR) {
-f = NULL;
+		    f = NULL;
-}
+		}
-} while ((f == NULL) && (__threadErrno == EINTR));
+	    } while ((f == NULL) && (__threadErrno == EINTR));
-}
+	}
 # else /* not WIN32 */
-do {
+	do {
-__BEGIN_INTERRUPTABLE__
+	    __BEGIN_INTERRUPTABLE__
 #  ifdef LINUX
-/*
+	    /*
-* LINUX may ret a non-NULL f even when interrupted.
+	     * LINUX may ret a non-NULL f even when interrupted.
-* Therefore, check errno and fake a null-ret.
+	     * Therefore, check errno and fake a null-ret.
-*/
+	     */
-__threadErrno = 0;
+	    __threadErrno = 0;
-f = fopen((char *) __stringVal(pathName), (char *) __stringVal(openmode));
+	    f = fopen((char *) __stringVal(pathName), (char *) __stringVal(openmode));
-if (__threadErrno == EINTR)
+	    if (__threadErrno == EINTR)
-f = NULL;
+		f = NULL;
 #  else /* not LINUX */
-f = fopen((char *) __stringVal(pathName), (char *) __stringVal(openmode));
+	    f = fopen((char *) __stringVal(pathName), (char *) __stringVal(openmode));
 #  endif /* not LINUX */
-__END_INTERRUPTABLE__
+	    __END_INTERRUPTABLE__
-} while ((f == NULL) && (__threadErrno == EINTR));
+	} while ((f == NULL) && (__threadErrno == EINTR));
 # endif /* not WIN32 */
 #endif /* not VMS */
-if (f == NULL) {
+	if (f == NULL) {
-/*
+	    /*
-* If no filedescriptors available, try to finalize
+	     * If no filedescriptors available, try to finalize
-* possibly collected fd's and try again.
+	     * possibly collected fd's and try again.
-*/
+	     */
-if (pass == 0 && (__threadErrno == ENFILE || __threadErrno == EMFILE)) {
+	    if (pass == 0 && (__threadErrno == ENFILE || __threadErrno == EMFILE)) {
-pass = 1;
+		pass = 1;
-__SSEND0(@global(ObjectMemory), @symbol(scavenge), 0);
+		__SSEND0(@global(ObjectMemory), @symbol(scavenge), 0);
-__SSEND0(@global(ObjectMemory), @symbol(finalize), 0);
+		__SSEND0(@global(ObjectMemory), @symbol(finalize), 0);
-goto retry;
+		goto retry;
-}
+	    }
-getOutOfHere: ;
+	getOutOfHere: ;
-__INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
-__INST(position) = nil;
+	    __INST(position) = nil;
-} else {
+	} else {
 #ifdef __VMS__
-/*
+	    /*
-* check to see if this is positionable ...
+	     * check to see if this is positionable ...
-*/
+	     */
-__INST(canPosition) = false;
+	    __INST(canPosition) = false;
 # ifndef _POSIX_C_SOURCE
-{
+	    {
-struct stat statBuffer;
+		struct stat statBuffer;
-if (fstat(fileno(f), &statBuffer) >= 0) {
+		if (fstat(fileno(f), &statBuffer) >= 0) {
-switch (statBuffer.st_fab_rfm) {
+		    switch (statBuffer.st_fab_rfm) {
-case FAB$C_UDF: /* undefined (also stream binary)   */
+			case FAB$C_UDF: /* undefined (also stream binary)   */
-case FAB$C_VAR: /* variable length records          */
+			case FAB$C_VAR: /* variable length records          */
-case FAB$C_VFC: /* variable fixed control           */
+			case FAB$C_VFC: /* variable fixed control           */
-case FAB$C_STM: /* RMS-11 stream (valid only for sequen> */
+			case FAB$C_STM: /* RMS-11 stream (valid only for sequen> */
-default:
+			default:
-__INST(canPosition) = false;
+			    __INST(canPosition) = false;
-break;
+			    break;
-case FAB$C_FIX: /* fixed length records             */
+			case FAB$C_FIX: /* fixed length records             */
-case FAB$C_STMLF: /* LF stream (valid only for sequential> */
+			case FAB$C_STMLF: /* LF stream (valid only for sequential> */
-case FAB$C_STMCR: /* CR stream (valid only for sequential> */
+			case FAB$C_STMCR: /* CR stream (valid only for sequential> */
-__INST(canPosition) = true;
+			    __INST(canPosition) = true;
-break;
+			    break;
-}
+		    }
-}
+		}
-}
+	    }
 # endif
 #else /* not VMS */
-__INST(canPosition) = true;
+	    __INST(canPosition) = true;
 #endif /* poor VMS */
-if (@global(FileOpenTrace) == true) {
+	    if (@global(FileOpenTrace) == true) {
-fprintf(stderr, "fopen %s [FileStream] -> %x\n", __stringVal(pathName), f);
+		fprintf(stderr, "fopen %s [FileStream] -> %x\n", __stringVal(pathName), f);
-}
+	    }
-if (f != NULL) {
+	    if (f != NULL) {
-wasBlocked = __BLOCKINTERRUPTS();
+		OBJ fp;
-__INST(filePointer) = fp = __MKOBJ((INT)f); __STORE(self, fp);
-}
+		wasBlocked = __BLOCKINTERRUPTS();
-}
+#if 0
+		// The original code was:
+		__INST(filePointer) = fp = __MKOBJ((INT)f); __STORE(self, fp);
+		// but for that, gcc generates wrong code, which loads self (volatile) into
+		// a register (bp), then calls __MKOBJ, then stores indirect bp.
+		// That is wrong if a scavenge occurs in MKOBJ, as bp is now still pointing to the old
+		// object.
+#else
+		fp = __MKOBJ((INT)f);
+		__INST(filePointer) = fp;
+		__STORE(self, fp);
+#endif
+	    }
+	}
 }
 %}.
 position := ZeroPosition.
 filePointer notNil ifTrue:[
-Lobby register:self.
+	Lobby register:self.
-wasBlocked == false ifTrue:[OperatingSystem unblockInterrupts].
+	wasBlocked == false ifTrue:[OperatingSystem unblockInterrupts].
 ].
 ^ filePointer
 !
 openForAppending
 "open the file for writeonly appending to the end.
 If the file does not exist its an error, raise OpenError;
 otherwise return the receiver."
 mode := #writeonly.
 didWrite := true.
 ^ self openWithMode:AppendMode
 !
 openForReadWrite
 "open the file for read/write.
 If the file does not exist its an error, raise OpenError;
 otherwise return the receiver."
 mode := #readwrite.
 ^ self openWithMode:ReadWriteMode
 !
 openForReading
 "open the file for readonly.
 If the file does not exist its an error, raise OpenError;
 otherwise return the receiver."
 mode := #readonly.
 didWrite := false.
 ^ self openWithMode:ReadMode
 !
 openForWriting
 "open the file writeonly. The contents of the file is preserved.
 If the file does not exist its an error, raise OpenError;
 otherwise return the receiver."
 mode := #writeonly.
 didWrite := true.
 "we must not truncate the file!! So do not use WriteMode"
 openmode is the string defining the way to open as defined by the stdio library
 (i.e. the 2nd fopen argument).
 This is a private entry, but maybe useful to open a file in a special mode,
 which is proprietrary to the operatingSystem."
 ^ self openWithMode:openmode attributes:nil
 !
 openWithMode:openmode attributes:attributeSpec
 "open the file;
 openmode is the string defining the way to open as defined by the stdio library
 (i.e. the 2nd fopen argument).
 attributeSpec is an additional argument, only used with VMS - it allows a file to
 be created as fixedRecord, variableRecord, streamLF, streamCR, ...
 filePointer notNil ifTrue:[^ self errorAlreadyOpen].
 filePointer := self openFile:pathName withMode:openmode attributes:attributeSpec.
 filePointer isNil ifTrue:[
-"
+	"
-the open failed for some reason ...
+	 the open failed for some reason ...
-"
+	"
-^ self openError
+	^ self openError
 ].
 position := ZeroPosition.
 buffered isNil ifTrue:[
-buffered := true.       "default is buffered"
+	buffered := true.       "default is buffered"
 ].
 !
 pathName:filename
 "set the pathname"
 reOpen
 "USERS WILL NEVER INVOKE THIS METHOD
 sent after snapin to reopen streams."
 filePointer notNil ifTrue:[
-"it was open, when snapped-out"
+	"it was open, when snapped-out"
-filePointer := nil.
+	filePointer := nil.
-Lobby unregister:self.
+	Lobby unregister:self.
-pathName isNil ifTrue:[
+	pathName isNil ifTrue:[
-^ self.
+	    ^ self.
-].
+	].
-[
+	[
-|oldPos|
+	    |oldPos|
-"should take care of appending files and open them for
+	    "should take care of appending files and open them for
-append / position them to the end"
+	     append / position them to the end"
-oldPos := position.
+	    oldPos := position.
-mode == #readonly ifTrue: [
+	    mode == #readonly ifTrue: [
-self openForReading
+		self openForReading
-] ifFalse:[mode == #writeonly ifTrue: [
+	    ] ifFalse:[mode == #writeonly ifTrue: [
-self openForWriting.
+		self openForWriting.
-] ifFalse:[
+	    ] ifFalse:[
-self openForReadWrite.
+		self openForReadWrite.
-]].
+	    ]].
-oldPos notNil ifTrue:[
+	    oldPos notNil ifTrue:[
-self position:oldPos.
+		self position:oldPos.
-]
+	    ]
-] on:OpenError do:[:ex|
+	] on:OpenError do:[:ex|
-"this happens, if after a restart,
+	    "this happens, if after a restart,
-the file is no longer present or accessable ..."
+	     the file is no longer present or accessable ..."
-(self class name , ' [warning]: could not reopen file: ', pathName) errorPrintCR.
+	    (self class name , ' [warning]: could not reopen file: ', pathName) errorPrintCR.
-].
+	].
 ]
 "Modified: 10.1.1997 / 17:50:51 / cg"
 !
 ! !
 !FileStream class methodsFor:'documentation'!
 version
-^ '$Header: /cvs/stx/stx/libbasic/FileStream.st,v 1.115 2004-09-29 13:42:29 stefan Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/FileStream.st,v 1.116 2004-11-09 17:26:59 cg Exp $'
 ! !
 FileStream initialize!

changeset 8627	5a86b95bebbb
parent 8604	3079fcbdecb2
child 8768	0036c76202c5