hg/stx-libbasic: comparison ExtStream.st

equal deleted inserted replaced

-:be947d4e7fb2
+:514c749165c3
 "
 COPYRIGHT (c) 1988 by Claus Gittinger
-All Rights Reserved
+	      All Rights Reserved
 This software is furnished under a license and may be used
 only in accordance with the terms of that license and with the
 inclusion of the above copyright notice.   This software may not
 be provided or otherwise made available to, or used by, any
 other person.  No title to or ownership of the software is
 hereby transferred.
 "
 ReadWriteStream subclass:#ExternalStream
-instanceVariableNames:'filePointer mode buffered binary useCRLF hitEOF didWrite'
+instanceVariableNames:'filePointer mode buffered binary useCRLF hitEOF didWrite lastErrorNumber'
-classVariableNames:'Lobby LastErrorNumber'
+classVariableNames:'Lobby LastErrorNumber
+			   StreamErrorSignal ReadErrorSignal WriteErrorSignal
+			   InvalidReadSignal InvalidWriteSignal InvalidModeSignal
+			   StreamNotOpenSignal'
 poolDictionaries:''
 category:'Streams-External'
 !
 ExternalStream comment:'
 COPYRIGHT (c) 1988 by Claus Gittinger
-All Rights Reserved
+	      All Rights Reserved
-$Header: /cvs/stx/stx/libbasic/Attic/ExtStream.st,v 1.20 1994-08-11 21:36:34 claus Exp $
+$Header: /cvs/stx/stx/libbasic/Attic/ExtStream.st,v 1.21 1994-10-10 00:25:47 claus Exp $
 '!
 %{
 #include <stdio.h>
 #include <fcntl.h>
 !ExternalStream class methodsFor:'documentation'!
 copyright
 "
 COPYRIGHT (c) 1988 by Claus Gittinger
-All Rights Reserved
+	      All Rights Reserved
 This software is furnished under a license and may be used
 only in accordance with the terms of that license and with the
 inclusion of the above copyright notice.   This software may not
 be provided or otherwise made available to, or used by, any
 "
 !
 version
 "
-$Header: /cvs/stx/stx/libbasic/Attic/ExtStream.st,v 1.20 1994-08-11 21:36:34 claus Exp $
+$Header: /cvs/stx/stx/libbasic/Attic/ExtStream.st,v 1.21 1994-10-10 00:25:47 claus Exp $
 "
 !
 documentation
 "
 ExternalStream defines protocol common to Streams which have a file-descriptor and
 represent some file or communicationChannel of the underlying OperatingSystem.
 ExternalStream is abstract; concrete classes are FileStream, PipeStream etc.
-ExternalStreams can be in two modes: text (the default) and binary.
+ExternalStreams can be in two modes: text- (the default) and binary-mode.
 In text-mode, the elements read/written are characters;
 while in binary-mode the basic elements are bytes which read/write as SmallIntegers
 in the range 0..255.
 Also, the stream can be either in buffered or unbuffered mode. In buffered mode,
 The underlying OperatingSystem streams may either be closed explicitely (sending a close)
 or just forgotten - in this case, the garbage collector will eventually collect the
 object AND a close will be performed automatically (but you will NOT know when this
 happens - so it is recommended, that you close your files when no longer needed).
-Closing is also suggested since if smalltalk is finished (be it by purpose, or due to
+Closing is also suggested, since if smalltalk is finished (be it by purpose, or due to
 some crash) the data will not be in the file, if unclosed.
 All streams understand the close message, so it never hurts to use it (it is defined as
 a noop in one of the superclasses).
 Most of the methods found here redefine inherited methods for better performance,
 For streams sitting on some communication channel (i.e. Pipes and Sockets) you should
 reestablish the stream upon image restart (make someone dependent on ObjectMemory).
 Instance variables:
-filePointer     <Integer>       the unix FILE*; somehow mapped to an integer
+	filePointer     <Integer>       the unix FILE*; somehow mapped to an integer
-(notice: not the fd)
+					(notice: not the fd)
-mode            <Symbol>        #readwrite, #readonly or #writeonly
+	mode            <Symbol>        #readwrite, #readonly or #writeonly
-buffered        <Boolean>       true, if buffered (i.e. collects characters - does
+	buffered        <Boolean>       true, if buffered (i.e. collects characters - does
-not output immediately)
+					not output immediately)
-binary          <Boolean>       true if in binary mode (reads bytes instead of chars)
+	binary          <Boolean>       true if in binary mode (reads bytes instead of chars)
-useCRLF         <Boolean>       true, if lines should be terminated with crlf instead
+	useCRLF         <Boolean>       true, if lines should be terminated with crlf instead
-of lf. (i.e. if file is an MSDOS-type file)
+					of lf. (i.e. if file is an MSDOS-type file)
-hitEOF          <Boolean>       true, if EOF was reached
+	hitEOF          <Boolean>       true, if EOF was reached
+	lastErrorNumber <Integer>       the value of errno (only valid right after the error -
+					updated with next i/o operation)
 Class variables:
-Lobby           <Registry>      keeps track of used ext-streams (to free up FILE*'s)
+	Lobby           <Registry>      keeps track of used ext-streams (to free up FILE*'s)
-LastErrorNumber <Integer>       the value of errno (only valid right after the error -
+	StreamErrorSignal       <Signal> parent of all stream errors
-updated with next i/o operation)
+	ReadErrorSignal         <Signal> raised on read errors
+	WriteErrorSignal        <Signal> raised on write errors
-Question: should lastErrorNumber be kept instance-specific ?
+	InvalidReadSignal       <Signal> raised on read from writeonly stream
+	InvalidWriteSignal      <Signal> raised on write to readonly stream
+	InvalidModeSignal       <Signal> raised on text I/O with binary-stream
+					 or binary I/O with text-stream
+	StreamNotOpenSignal     <Signal> raised on I/O with non-open stream
+Additional notes:
+This class is implemented using the underlying stdio-c library package, which
+has both advantages and disadvantages: since it is portable (posix defined), porting
+ST/X to non-Unix machines is simplified. The disadvantage is that the stdio library
+has big problems handling unbounded Streams, since the EOF handling in stdio is
+not prepared for data to arrive after EOF has been reached - time will show, if we need
+a complete rewrite for UnboundedStream ...
 "
 ! !
 !ExternalStream class methodsFor:'initialization'!
 initialize
+StreamErrorSignal isNil ifTrue:[
+	super initialize.
+	StreamErrorSignal := Object errorSignal newSignalMayProceed:false.
+	StreamErrorSignal nameClass:self message:#streamErrorSignal.
+	StreamErrorSignal notifierString:'I/O error'.
+	ReadErrorSignal := StreamErrorSignal newSignalMayProceed:false.
+	ReadErrorSignal nameClass:self message:#readErrorSignal.
+	ReadErrorSignal notifierString:'read error'.
+	WriteErrorSignal := StreamErrorSignal newSignalMayProceed:false.
+	WriteErrorSignal nameClass:self message:#writeErrorSignal.
+	WriteErrorSignal notifierString:'write error'.
+	InvalidReadSignal := ReadErrorSignal newSignalMayProceed:false.
+	InvalidReadSignal nameClass:self message:#invalidReadSignal.
+	InvalidReadSignal notifierString:'write error'.
+	InvalidWriteSignal := WriteErrorSignal newSignalMayProceed:false.
+	InvalidWriteSignal nameClass:self message:#invalidWriteSignal.
+	InvalidWriteSignal notifierString:'write error'.
+	InvalidModeSignal :=  StreamErrorSignal newSignalMayProceed:false.
+	InvalidModeSignal nameClass:self message:#invalidModeSignal.
+	InvalidModeSignal notifierString:'binary/text mode mismatch'.
+	StreamNotOpenSignal := StreamErrorSignal newSignalMayProceed:false.
+	StreamNotOpenSignal nameClass:self message:#streamNotOpenSignal.
+	StreamNotOpenSignal notifierString:'stream is not open'.
+].
 Lobby isNil ifTrue:[
-Lobby := Registry new.
+	Lobby := Registry new.
-"want to get informed when returning from snapshot"
+	"want to get informed when returning from snapshot"
-ObjectMemory addDependent:self
+	ObjectMemory addDependent:self
 ]
 !
 reOpenFiles
 "reopen all files (if possible) after a snapShot load"
 Lobby contentsDo:[:aFileStream |
-aFileStream reOpen
+	aFileStream reOpen
 ]
 !
 update:something
 "have to reopen files when returning from snapshot"
 something == #returnFromSnapshot ifTrue:[
-self reOpenFiles
+	self reOpenFiles
 ]
+! !
+!ExternalStream class methodsFor:'signal access '!
+streamErrorSignal
+"return the parent of all stream errors;
+handling this one also handles all other errors.
+Also, this one is raised for errors not related to read/write
+operations, such as failed ioctls"
+^ StreamErrorSignal
+!
+readErrorSignal
+"return the signal raised on read errors"
+^ ReadErrorSignal
+!
+writeErrorSignal
+"return the signal raised on write errors"
+^ WriteErrorSignal
+!
+invalidReadSignal
+"return the signal raised when reading from writeonly streams"
+^ InvalidReadSignal
+!
+invalidWriteSignal
+"return the signal raised when writing to readonly streams"
+^ InvalidWriteSignal
+!
+invalidModeSignal
+"return the signal raised when doing text-I/O with a binary stream
+or binary-I/O with a text stream"
+^ InvalidModeSignal
+!
+streamNotOpenSignal
+"return the signal raised on I/O with closed streams"
+^ StreamNotOpenSignal
 ! !
 !ExternalStream class methodsFor:'instance creation'!
 new
 ! !
 !ExternalStream class methodsFor:'error handling'!
 lastErrorNumber
-"return the last error"
+"return the errno of the last error"
 ^ LastErrorNumber
+"
+ExternalStream lastErrorNumber
+"
 !
 lastErrorString
 "return a message string describing the last error"
 "
 ! !
 !ExternalStream methodsFor:'instance release'!
+shallowCopyForFinalization
+"return a copy for finalization-registration;
+since all we need at finalization time is the fileDescriptor,
+a cheaper copy is possible."
+^ self class basicNew setFilePointer:filePointer
+!
+setFilePointer:anInteger
+filePointer := anInteger
+!
 disposed
 "some Stream has been collected - close the file if not already done"
 self closeFile
 !
 "low level close - may be redefined in subclasses"
 %{  /* NOCONTEXT */
 if (_INST(filePointer) != nil) {
-extern int _immediateInterrupt;
+	extern int _immediateInterrupt;
-_immediateInterrupt = 1;
+	_immediateInterrupt = 1;
-fclose(MKFD(_INST(filePointer)));
+	fclose(MKFD(_INST(filePointer)));
-_immediateInterrupt = 0;
+	_immediateInterrupt = 0;
 }
 %}
 ! !
 !ExternalStream methodsFor:'private'!
 cannot reopen here since I am abstract and have no device knowledge"
 self class name errorPrint. ': cannot reOpen stream - stream closed' errorPrintNewline.
 filePointer := nil.
 Lobby unregister:self.
+!
+setLastError:aNumber
+lastErrorNumber := aNumber
 ! !
 !ExternalStream methodsFor:'error handling'!
 lastErrorNumber
 "return the last error"
-^ LastErrorNumber
+^ lastErrorNumber
 !
 lastErrorString
 "return a message string describing the last error"
-^ self class lastErrorString
+(lastErrorNumber isNil or:[lastErrorNumber == 0]) ifTrue:[
+	^ 'I/O error'
+].
+^ OperatingSystem errorTextForNumber:lastErrorNumber
 !
 errorNotOpen
 "report an error, that the stream has not been opened"
-^ self error:(self class name , ' not open')
+^ StreamNotOpenSignal
+	raiseRequestWith:self
+	errorString:(self class name , ' not open')
 !
 errorReadOnly
 "report an error, that the stream is a readOnly stream"
-^ self error:(self class name , ' is readonly')
+^ InvalidWriteSignal
+	raiseRequestWith:self
+	errorString:(self class name , ' is readonly')
 !
 errorWriteOnly
 "report an error, that the stream is a writeOnly stream"
-^ self error:(self class name , ' is writeonly')
+^ InvalidReadSignal
+	raiseRequestWith:self
+	errorString:(self class name , ' is writeonly')
 !
 errorNotBinary
 "report an error, that the stream is not in binary mode"
-^ self error:(self class name , ' is not in binary mode')
+^ InvalidModeSignal
+	raiseRequestWith:self
+	errorString:(self class name , ' is not in binary mode')
 !
 errorBinary
 "report an error, that the stream is in binary mode"
-^ self error:(self class name , ' is in binary mode')
+^ InvalidModeSignal
+	raiseRequestWith:self
+	errorString:(self class name , ' is in binary mode')
 !
 errorNotBuffered
 "report an error, that the stream is not in buffered mode"
-^ self error:(self class name , ' is unbuffered - operation not allowed')
+^ StreamErrorSignal
+	raiseRequestWith:self
+	errorString:(self class name , ' is unbuffered - operation not allowed')
+!
+ioError
+"report an error, that some I/O error occured"
+^ StreamErrorSignal
+	raiseRequestWith:self
+	errorString:('I/O error: ' , self lastErrorString)
+!
+readError
+"report an error, that some read error occured"
+^ ReadErrorSignal
+	raiseRequestWith:self
+	errorString:('read error: ' , self lastErrorString)
+!
+writeError
+"report an error, that some write error occured"
+^ WriteErrorSignal
+	raiseRequestWith:self
+	errorString:('write error: ' , self lastErrorString)
 !
 argumentMustBeInteger
 "report an error, that the argument must be an integer"
 %{  /* NOCONTEXT */
 FILE *f;
 if (_INST(filePointer) != nil) {
-f = MKFD(_INST(filePointer));
+	f = MKFD(_INST(filePointer));
-RETURN ( MKOBJ(fileno(f)) );
+	RETURN ( MKOBJ(fileno(f)) );
 }
 %}
 .
 ^ self errorNotOpen
 !
 contentsSpecies
 "return the kind of object to be returned by sub-collection builders
 (such as upTo)"
 binary ifTrue:[
-^ ByteArray
+	^ ByteArray
 ].
 ^ String
 !
 contents
 is returned."
 |text l chunks sizes chunk byteCount cnt bytes offset|
 binary ifTrue:[
-"adding to a ByteArray produces quadratic time-space
+	"adding to a ByteArray produces quadratic time-space
-behavior - therefore we allocate chunks, and concatenate them
+	 behavior - therefore we allocate chunks, and concatenate them
-at the end."
+	 at the end."
-chunks := OrderedCollection new.
+	chunks := OrderedCollection new.
-sizes := OrderedCollection new.
+	sizes := OrderedCollection new.
-byteCount := 0.
+	byteCount := 0.
-[self atEnd] whileFalse:[
+	[self atEnd] whileFalse:[
-chunk := ByteArray uninitializedNew:4096.
+	    chunk := ByteArray uninitializedNew:4096.
-cnt := self nextBytes:(chunk size) into:chunk.
+	    cnt := self nextBytes:(chunk size) into:chunk.
-cnt notNil ifTrue:[
+	    cnt notNil ifTrue:[
-chunks add:chunk.
+		chunks add:chunk.
-sizes add:cnt.
+		sizes add:cnt.
-byteCount := byteCount + cnt
+		byteCount := byteCount + cnt
-]
+	    ]
-].
+	].
-"now, create one big ByteArray"
+	"now, create one big ByteArray"
-bytes := ByteArray uninitializedNew:byteCount.
+	bytes := ByteArray uninitializedNew:byteCount.
-offset := 1.
+	offset := 1.
-1 to:chunks size do:[:index |
+	1 to:chunks size do:[:index |
-chunk := chunks at:index.
+	    chunk := chunks at:index.
-cnt := sizes at:index.
+	    cnt := sizes at:index.
-bytes replaceFrom:offset to:(offset + cnt - 1) with:chunk.
+	    bytes replaceFrom:offset to:(offset + cnt - 1) with:chunk.
-offset := offset + cnt
+	    offset := offset + cnt
-].
+	].
-^ bytes
+	^ bytes
 ].
 text := Text new.
 [self atEnd] whileFalse:[
-l := self nextLine.
+	l := self nextLine.
-l notNil ifTrue:[
+	l notNil ifTrue:[
-text add:l
+	    text add:l
-]
+	]
 ].
 ^ text
 ! !
 !ExternalStream methodsFor:'misc functions'!
 backStep
 "step back one element -
 redefined, since position is redefined here"
 self position:(self position - 1)
+!
+reset
+"set the read position to the beginning of the collection"
+self position:"0" 1
+!
+setToEnd
+"redefined since it must be implemented differently"
+^ self subclassResponsibility
 !
 blocking:aBoolean
 "set/clear the blocking attribute - if set (which is the default)
 a read (using next) on the receiver will block until data is available.
 async:aBoolean
 "set/clear the async attribute - if set the availability of data on
 the receiver will trigger an ioInterrupt.
 If cleared (which is the default) no special notification is made."
-filePointer isNil ifTrue:[^ self errorNotOpen].
+|fd|
+filePointer isNil ifTrue:[^ self errorNotOpen].
+fd := self fileDescriptor.
 aBoolean ifTrue:[
-^ OperatingSystem enableIOInterruptsOn:(self fileDescriptor)
+	^ OperatingSystem enableIOInterruptsOn:fd
 ].
-^ OperatingSystem disableIOInterruptsOn:(self fileDescriptor)
+^ OperatingSystem disableIOInterruptsOn:fd
 !
 ioctl:ioctlNumber
 "to provide a simple ioctl facility - an ioctl is performed
 on the underlying file; no arguments are passed."
 FILE *f;
 int ret, ioNum, ioArg;
 extern int _immediateInterrupt;
 extern errno;
+_INST(lastErrorNumber) = nil;
 if (_INST(filePointer) != nil) {
-if (_isSmallInteger(ioctlNumber)) {
+	if (_isSmallInteger(ioctlNumber)) {
-ioNum = _intVal(ioctlNumber);
+	    ioNum = _intVal(ioctlNumber);
-f = MKFD(_INST(filePointer));
+	    f = MKFD(_INST(filePointer));
-_immediateInterrupt = 1;
+	    _immediateInterrupt = 1;
-do {
+	    do {
-ret = ioctl(fileno(f), ioNum);
+		ret = ioctl(fileno(f), ioNum);
-} while ((ret < 0) && (errno == EINTR));
+	    } while ((ret < 0) && (errno == EINTR));
-_immediateInterrupt = 0;
+	    _immediateInterrupt = 0;
-if (ret >= 0) {
+	    if (ret >= 0) {
-RETURN ( _MKSMALLINT(ret) );
+		RETURN ( _MKSMALLINT(ret) );
-}
+	    }
-ExternalStream_LastErrorNumber = _MKSMALLINT(errno);
+	    _INST(position) = nil;
-RETURN ( nil );
+	    _INST(lastErrorNumber) = _MKSMALLINT(errno);
-}
+	}
 }
-%}
+%}.
-.
+lastErrorNumber notNil ifTrue:[^ self ioError].
 filePointer isNil ifTrue:[^ self errorNotOpen].
-self primitiveFailed
+"
+ioctl-number is not an integer
+"
+^ self primitiveFailed
 !
 ioctl:ioctlNumber with:arg
 "to provide a simple ioctl facility - an ioctl is performed
 on the underlying file; the argument is passed as argument.
 If the argument is a number, its directly passed; if its a
 kind of ByteArray (ByteArray, String or Structure) a pointer to
 the data is passed. This allows performing most ioctls - however,
 it might be tricky to setup the buffer."
-|isStructure|
+%{  /* NOCONTEXT */
-isStructure := arg isKindOf:ByteArray.
-%{
 FILE *f;
 int ret, ioNum;
 extern int _immediateInterrupt;
 extern errno;
+_INST(lastErrorNumber) = nil;
 if (_INST(filePointer) != nil) {
-if (_isSmallInteger(ioctlNumber)
+	if (_isSmallInteger(ioctlNumber)
-&& (_isSmallInteger(arg) || (isStructure == true))) {
+	 && (_isSmallInteger(arg) || __isBytes(arg))) {
-f = MKFD(_INST(filePointer));
+	    f = MKFD(_INST(filePointer));
-ioNum = _intVal(ioctlNumber);
+	    ioNum = _intVal(ioctlNumber);
-_immediateInterrupt = 1;
+	    _immediateInterrupt = 1;
-do {
+	    do {
-if (isStructure == true) {
+		if (_isSmallInteger(arg)) {
-ret = ioctl(fileno(f), ioNum, _ByteArrayInstPtr(arg)->ba_element);
+		    ret = ioctl(fileno(f), ioNum, _intVal(arg));
-} else {
+		} else {
-ret = ioctl(fileno(f), ioNum, _intVal(arg));
+		    ret = ioctl(fileno(f), ioNum, _ByteArrayInstPtr(arg)->ba_element);
-}
+		}
-} while ((ret < 0) && (errno == EINTR));
+	    } while ((ret < 0) && (errno == EINTR));
-_immediateInterrupt = 0;
+	    _immediateInterrupt = 0;
-if (ret >= 0) {
+	    if (ret >= 0) {
-RETURN ( _MKSMALLINT(ret) );
+		RETURN ( _MKSMALLINT(ret) );
-}
+	    }
-ExternalStream_LastErrorNumber = _MKSMALLINT(errno);
+	    _INST(position) = nil;
-RETURN ( nil );
+	    _INST(lastErrorNumber) = _MKSMALLINT(errno);
-}
+	}
 }
-%}
+%}.
-.
+lastErrorNumber notNil ifTrue:[^ self ioError].
 filePointer isNil ifTrue:[^ self errorNotOpen].
-self primitiveFailed
+"
+ioctl-number is not an integer or argument is not byteArray-like
+"
+^ self primitiveFailed
 ! !
 !ExternalStream methodsFor:'non homogenous reading'!
 nextByte
 unsigned char byte;
 int cnt;
 extern errno;
 extern int _immediateInterrupt;
-if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
+_INST(lastErrorNumber) = nil;
-f = MKFD(_INST(filePointer));
+if ((_INST(filePointer) != nil)
+&& (_INST(mode) != @symbol(writeonly))) {
-_immediateInterrupt = 1;
+	f = MKFD(_INST(filePointer));
-do {
-if (_INST(buffered) == false) {
+	_immediateInterrupt = 1;
-cnt = read(fileno(f), &byte, 1);
+	do {
-} else {
+	    if (_INST(buffered) == false) {
-if ((_INST(didWrite) != false) && (_INST(mode) == _readwrite)) {
+		cnt = read(fileno(f), &byte, 1);
-_INST(didWrite) = false;
+	    } else {
-fseek(f, 0L, 1); /* needed in stdio */
+		if ((_INST(didWrite) != false)
-}
+		 && (_INST(mode) == @symbol(readwrite))) {
-cnt = fread(&byte, 1, 1, f);
+		    _INST(didWrite) = false;
-}
+		    fseek(f, 0L, 1); /* needed in stdio */
-} while ((cnt < 0) && (errno == EINTR));
+		}
-_immediateInterrupt = 0;
+		cnt = fread(&byte, 1, 1, f);
+	    }
-if (cnt == 1) {
+	} while ((cnt < 0) && (errno == EINTR));
-if (_INST(position) != nil)
+	_immediateInterrupt = 0;
-_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 1);
-RETURN ( _MKSMALLINT(byte) );
+	if (cnt == 1) {
-}
+	    if (_INST(position) != nil)
-if (cnt < 0) {
+		_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 1);
-ExternalStream_LastErrorNumber = _MKSMALLINT(errno);
+	    RETURN ( _MKSMALLINT(byte) );
-}
+	}
-_INST(hitEOF) = true;
+	if (cnt == 0) {
-RETURN ( nil );
+	    _INST(hitEOF) = true;
-}
+	    RETURN (nil);
-%}
+	}
-.
+	_INST(position) = nil;
-filePointer isNil ifTrue:[^ self errorNotOpen].
+	_INST(lastErrorNumber) = _MKSMALLINT(errno);
-self errorWriteOnly
+}
+%}.
+lastErrorNumber notNil ifTrue:[^ self readError].
+filePointer isNil ifTrue:[^ self errorNotOpen].
+^ self errorWriteOnly
 !
 nextBytesInto:anObject
 "read bytes into an object, regardless of binary/text mode.
 The number of bytes to read is defined by the objects size.
 ^ self nextBytes:count into:anObject startingAt:1
 !
 nextBytes:count into:anObject startingAt:start
 "read the next count bytes into an object and return the number of
-bytes read or nil on error. On EOF, 0 is returned.
+bytes read or 0 on EOF. Notice, that in contrast to other methods
-The object must have non-pointer indexed instvars (i.e. it must be
+here, this does NOT return nil on EOF, but the actual count.
-a ByteArray, String, Float- or DoubleArray).
+Thus allowing read of partial blocks.
-Use with care - non object oriented i/o."
+The object must have non-pointer indexed instvars
+(i.e. it must be a ByteArray, String, Float- or DoubleArray).
+Use with care - non object oriented I/O."
 %{  /* NOCONTEXT */
 FILE *f;
 int cnt, offs;
 extern errno;
 OBJ pos;
 extern int _immediateInterrupt;
 OBJ oClass;
-if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
+_INST(lastErrorNumber) = nil;
-if (_isSmallInteger(count) && _isSmallInteger(start)) {
+if ((_INST(filePointer) != nil)
-oClass = _Class(anObject);
+&& (_INST(mode) != @symbol(writeonly))) {
-switch (_intVal(_ClassInstPtr(oClass)->c_flags) & ARRAYMASK) {
+	if (_isSmallInteger(count) && _isSmallInteger(start)) {
-case BYTEARRAY:
+	    oClass = _Class(anObject);
-case WORDARRAY:
+	    switch (_intVal(_ClassInstPtr(oClass)->c_flags) & ARRAYMASK) {
-case LONGARRAY:
+		case BYTEARRAY:
-case FLOATARRAY:
+		case WORDARRAY:
-case DOUBLEARRAY:
+		case LONGARRAY:
-break;
+		case FLOATARRAY:
-default:
+		case DOUBLEARRAY:
-goto bad;
+		    break;
-}
+		default:
-cnt = _intVal(count);
+		    goto bad;
-offs = _intVal(start) - 1;
+	    }
-f = MKFD(_INST(filePointer));
+	    cnt = _intVal(count);
-nInstVars = _intVal(_ClassInstPtr(oClass)->c_ninstvars);
+	    offs = _intVal(start) - 1;
-nInstBytes = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
+	    f = MKFD(_INST(filePointer));
-objSize = _Size(anObject) - nInstBytes;
+	    nInstVars = _intVal(_ClassInstPtr(oClass)->c_ninstvars);
-if ((offs >= 0) && (cnt >= 0) && (objSize >= (cnt + offs))) {
+	    nInstBytes = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
-cp = (char *)_InstPtr(anObject) + nInstBytes + offs;
+	    objSize = _Size(anObject) - nInstBytes;
+	    if ((offs >= 0) && (cnt >= 0) && (objSize >= (cnt + offs))) {
-_immediateInterrupt = 1;
+		cp = (char *)_InstPtr(anObject) + nInstBytes + offs;
-do {
-if (_INST(buffered) == false) {
+		_immediateInterrupt = 1;
-cnt = read(fileno(f), cp, cnt);
+		do {
-} else {
+		    if (_INST(buffered) == false) {
-if ((_INST(didWrite) != false) && (_INST(mode) == _readwrite)) {
+			cnt = read(fileno(f), cp, cnt);
-_INST(didWrite) = false;
+		    } else {
-fseek(f, 0L, 1); /* needed in stdio */
+			if ((_INST(didWrite) != false)
-}
+			 && (_INST(mode) == @symbol(readwrite))) {
-cnt = fread(cp, 1, cnt, f);
+			    _INST(didWrite) = false;
-}
+			    fseek(f, 0L, 1); /* needed in stdio */
-} while ((cnt < 0) && (errno == EINTR));
+			}
-_immediateInterrupt = 0;
+			cnt = fread(cp, 1, cnt, f);
+		    }
-if (cnt >= 0) {
+		} while ((cnt < 0) && (errno == EINTR));
-if (cnt == 0)
+		_immediateInterrupt = 0;
-_INST(hitEOF) = true;
-else {
+		if (cnt >= 0) {
-pos = _INST(position);
+		    if (cnt == 0)
-if (pos != nil)
+			_INST(hitEOF) = true;
-_INST(position) = _MKSMALLINT(_intVal(pos) + cnt);
+		    else {
-}
+			pos = _INST(position);
-RETURN ( _MKSMALLINT(cnt) );
+			if (pos != nil)
-}
+			    _INST(position) = _MKSMALLINT(_intVal(pos) + cnt);
-ExternalStream_LastErrorNumber = _MKSMALLINT(errno);
+		    }
-RETURN ( nil );
+		    RETURN (_MKSMALLINT(cnt));
-}
+		}
-}
+		_INST(position) = nil;
+		_INST(lastErrorNumber) = _MKSMALLINT(errno);
+	    }
+	}
 }
 bad: ;
-%}
+%}.
-.
+lastErrorNumber notNil ifTrue:[^ self readError].
 filePointer isNil ifTrue:[^ self errorNotOpen].
 (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
-self primitiveFailed
+"
-!
+count not integer or arg not bit-like (String, ByteArray etc)
+"
-nextWord
+^ self primitiveFailed
-"in text-mode:
+!
-read the next word (i.e. up to non letter-or-digit).
-return a string containing those characters.
+nextShortMSB:msbFlag
-in binary-mode:
+"Read two bytes and return the value as a 16-bit signed Integer.
-read two bytes (msb-first) and return the value as a 16-bit unsigned Integer
+If msbFlag is true, value is read with most-significant byte first,
-(for compatibility with other smalltalks)"
+otherwise least-significant byte comes first.
+A nil is returned if EOF is reached (also when EOF is hit after the first byte).
+Works in both binary and text modes."
 %{  /* NOCONTEXT */
 extern int _immediateInterrupt;
-int _buffered;
+_INST(lastErrorNumber) = nil;
-_buffered = (_INST(buffered) == true);
+if ((_INST(filePointer) != nil)
-/*
+&& (_INST(mode) != @symbol(writeonly))) {
-* binary mode
+	FILE *f;
-*/
+	int first, second, err;
-if (_INST(binary) == true) {
+	short value;
-if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
-FILE *f;
+	f = MKFD(_INST(filePointer));
-unsigned char hi, low;
-int cnt;
+	_immediateInterrupt = 1;
-OBJ pos;
+	if ((_INST(didWrite) != false)
+	 && (_INST(mode) == @symbol(readwrite))) {
-f = MKFD(_INST(filePointer));
+	    _INST(didWrite) = false;
+	    fseek(f, 0L, 1); /* needed in stdio */
-_immediateInterrupt = 1;
+	}
+	first = getc(f);
-if (_buffered) {
+	if (first != EOF) {
-if ((_INST(didWrite) != false) && (_INST(mode) == _readwrite)) {
+	    second = getc(f);
-_INST(didWrite) = false;
+	    _immediateInterrupt = 0;
-fseek(f, 0L, 1); /* needed in stdio */
+	    if (second != EOF) {
-}
+		if (_INST(position) != nil) {
-}
+		    _INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 2);
+		}
-do {
+		if (msbFlag == true) {
-if (! _buffered) {
+		    value = ((first & 0xFF) << 8) | (second & 0xFF);
-cnt = read(fileno(f), &hi, 1);
+		} else {
-} else {
+		    value = ((second & 0xFF) << 8) | (first & 0xFF);
-cnt = fread(&hi, 1, 1, f);
+		}
-}
+		RETURN (_MKSMALLINT(value));
-} while ((cnt < 0) && (errno == EINTR));
+	    }
+	}
-if (cnt <= 0) {
+	_immediateInterrupt = 0;
-_INST(hitEOF) = true;
-if (cnt < 0)
+	if (ferror(f)) {
-ExternalStream_LastErrorNumber = _MKSMALLINT(errno);
+	    _INST(position) = nil;
-_immediateInterrupt = 0;
+	    _INST(lastErrorNumber) = _MKSMALLINT(errno);
-RETURN ( nil );
+	} else {
-}
+	    _INST(hitEOF) = true;
+	    RETURN (nil);
-do {
+	}
-if (! _buffered) {
+}
-cnt = read(fileno(f), &low, 1);
+%}.
-} else {
-cnt = fread(&low, 1, 1, f);
-}
-} while ((cnt < 0) && (errno == EINTR));
-_immediateInterrupt = 0;
-pos = _INST(position);
-if (cnt <= 0) {
-if (pos != nil) {
-_INST(position) = _MKSMALLINT(_intVal(pos) + 1);
-}
-_INST(hitEOF) = true;
-if (cnt < 0)
-ExternalStream_LastErrorNumber = _MKSMALLINT(errno);
-RETURN ( _MKSMALLINT(hi & 0xFF) );
-}
-if (pos != nil) {
-_INST(position) = _MKSMALLINT(_intVal(pos) + 2);
-}
-RETURN ( _MKSMALLINT(((hi & 0xFF)<<8) | (low & 0xFF)) );
-}
-}
-%}
-.
-%{  /* STACK: 2000 */
-FILE *f;
-int len;
-char buffer[1024];
-int ch;
-int cnt = 0;
-extern int _immediateInterrupt;
-/*
-* text mode
-*/
-if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
-f = MKFD(_INST(filePointer));
-_immediateInterrupt = 1;
-if ((_INST(didWrite) != false) && (_INST(mode) == _readwrite)) {
-_INST(didWrite) = false;
-fseek(f, 0L, 1); /* needed in stdio */
-}
-for (;;) {
-ch = getc(f);
-cnt++;
-if (ch >= ' ') break;
-if ((ch != ' ') && (ch != '\t') && (ch != '\r')
-&& (ch != '\n') && (ch != 0x0b)) break;
-}
-ungetc(ch, f);
-cnt--;
-len = 0;
-for (;;) {
-ch = getc(f);
-if (ch == EOF) {
-_INST(hitEOF) = true;
-break;
-}
-ch &= 0xFF;
-if (! (((ch >= 'a') && (ch <= 'z')) ||
-((ch >= 'A') && (ch <= 'Z')) ||
-((ch >= '0') && (ch <= '9')))) {
-ungetc(ch, f);
-break;
-}
-cnt++;
-buffer[len++] = ch;
-if (len >= sizeof(buffer)-1) {
-/* emergency */
-break;
-}
-}
-_immediateInterrupt = 0;
-if (_INST(position) != nil) {
-_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + cnt);
-}
-buffer[len] = '\0';
-if (len != 0) {
-RETURN ( _MKSTRING(buffer COMMA_CON) );
-}
-RETURN ( nil );
-}
-%}
-.
-filePointer isNil ifTrue:[^ self errorNotOpen].
-self errorWriteOnly
-!
-nextShortMSB:msbFlag
-"Read two bytes and return the value as a 16-bit signed Integer.
-If msbFlag is true, value is read with most-significant byte first, otherwise
-least-significant byte comes first.
-A nil is also returned, if endOfFile occurs after the first byte.
-Works in both binary and text modes."
-%{  /* NOCONTEXT */
-extern int _immediateInterrupt;
-if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
-FILE *f;
-int first, second;
-short value;
-f = MKFD(_INST(filePointer));
-_immediateInterrupt = 1;
-if ((_INST(didWrite) != false) && (_INST(mode) == _readwrite)) {
-_INST(didWrite) = false;
-fseek(f, 0L, 1); /* needed in stdio */
-}
-first = getc(f);
-if (first == EOF) {
-_immediateInterrupt = 0;
-_INST(hitEOF) = true;
-RETURN ( nil );
-}
-second = getc(f);
-_immediateInterrupt = 0;
-if (second == EOF) {
-_INST(hitEOF) = true;
-RETURN ( nil );
-}
-if (_INST(position) != nil) {
-_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 2);
-}
-if (msbFlag == true) {
-RETURN ( _MKSMALLINT(((first & 0xFF)<<8) | (second & 0xFF)) );
-}
-RETURN ( _MKSMALLINT(((second & 0xFF)<<8) | (first & 0xFF)) );
-}
-%}
-.
 filePointer isNil ifTrue:[^ self errorNotOpen].
 (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
-self primitiveFailed
+^ self readError.
 !
 nextUnsignedShortMSB:msbFlag
 "Read two bytes and return the value as a 16-bit unsigned Integer.
 If msbFlag is true, value is read with most-significant byte first, otherwise
 least-significant byte comes first.
-A nil is also returned, if endOfFile occurs after the first byte.
+A nil is returned if EOF is reached (also when EOF is hit after the first byte).
 Works in both binary and text modes."
 %{  /* NOCONTEXT */
 extern int _immediateInterrupt;
-if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
+_INST(lastErrorNumber) = nil;
-FILE *f;
+if ((_INST(filePointer) != nil)
-int first, second;
+&& (_INST(mode) != @symbol(writeonly))) {
+	FILE *f;
-_immediateInterrupt = 1;
+	int first, second;
+	unsigned value;
-f = MKFD(_INST(filePointer));
+	_immediateInterrupt = 1;
-if ((_INST(didWrite) != false) && (_INST(mode) == _readwrite)) {
+	f = MKFD(_INST(filePointer));
-_INST(didWrite) = false;
-fseek(f, 0L, 1); /* needed in stdio */
+	if ((_INST(didWrite) != false)
-}
+	 && (_INST(mode) == @symbol(readwrite))) {
+	    _INST(didWrite) = false;
-first = getc(f);
+	    fseek(f, 0L, 1); /* needed in stdio */
-if (first == EOF) {
+	}
-_immediateInterrupt = 0;
-_INST(hitEOF) = true;
+	first = getc(f);
-RETURN ( nil );
+	if (first != EOF) {
-}
+	    second = getc(f);
-second = getc(f);
+	    _immediateInterrupt = 0;
-_immediateInterrupt = 0;
+	    if (second != EOF) {
+		if (_INST(position) != nil) {
-if (second == EOF) {
+		    _INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 2);
-_INST(hitEOF) = true;
+		}
-RETURN ( nil );
+		if (msbFlag == true) {
-}
+		    value = ((first & 0xFF) << 8) | (second & 0xFF);
-if (_INST(position) != nil) {
+		} else {
-_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 2);
+		    value = ((second & 0xFF) << 8) | (first & 0xFF);
-}
+		}
-if (msbFlag == true) {
+		RETURN (_MKSMALLINT(value));
-RETURN ( _MKSMALLINT(((first & 0xFF)<<8) | (second & 0xFF)) );
+	    }
-}
+	}
-RETURN ( _MKSMALLINT(((second & 0xFF)<<8) | (first & 0xFF)) );
+	_immediateInterrupt = 0;
-}
-%}
+	if (ferror(f)) {
-.
+	    _INST(position) = nil;
+	    _INST(lastErrorNumber) = _MKSMALLINT(errno);
+	} else {
+	    _INST(hitEOF) = true;
+	    RETURN (nil);
+	}
+}
+%}.
 filePointer isNil ifTrue:[^ self errorNotOpen].
 (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
-self primitiveFailed
+^ self readError.
 !
 nextLongMSB:msbFlag
-"Read four bytes and return the value as a 32-bit signed Integer, which may be
+"Read four bytes and return the value as a 32-bit signed Integer,
-a LargeInteger.
+which may be a LargeInteger.
-If msbFlag is true, value is read with most-significant byte first, otherwise
+If msbFlag is true, value is read with most-significant byte first,
-least-significant byte comes first.
+otherwise least-significant byte comes first.
-A nil is returned, if endOfFile occurs before all 4 bytes have been read.
+A nil is returned, if EOF is hit before all 4 bytes have been read.
 Works in both binary and text modes."
 %{  /* NOCONTEXT */
 extern int _immediateInterrupt;
-if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
+_INST(lastErrorNumber) = nil;
-FILE *f;
+if ((_INST(filePointer) != nil)
-int first, second, third, fourth;
+&& (_INST(mode) != @symbol(writeonly))) {
-int value;
+	FILE *f;
+	int first, second, third, fourth;
-_immediateInterrupt = 1;
+	int value;
-f = MKFD(_INST(filePointer));
+	_immediateInterrupt = 1;
-if ((_INST(didWrite) != false) && (_INST(mode) == _readwrite)) {
+	f = MKFD(_INST(filePointer));
-_INST(didWrite) = false;
-fseek(f, 0L, 1); /* needed in stdio */
+	if ((_INST(didWrite) != false)
-}
+	 && (_INST(mode) == @symbol(readwrite))) {
+	    _INST(didWrite) = false;
-first = getc(f);
+	    fseek(f, 0L, 1); /* needed in stdio */
-if (first == EOF) {
+	}
-_INST(hitEOF) = true;
-_immediateInterrupt = 0;
+	first = getc(f);
-RETURN ( nil );
+	if (first != EOF) {
-}
+	    second = getc(f);
-second = getc(f);
+	    if (second != EOF) {
-if (second == EOF) {
+		third = getc(f);
-_INST(hitEOF) = true;
+		if (third != EOF) {
-_immediateInterrupt = 0;
+		    fourth = getc(f);
-RETURN ( nil );
+		    if (fourth != EOF) {
-}
+			_immediateInterrupt = 0;
-third = getc(f);
+			if (msbFlag == true) {
-if (third == EOF) {
+			    value = (first & 0xFF);
-_INST(hitEOF) = true;
+			    value = (value<<8) | (second & 0xFF);
-_immediateInterrupt = 0;
+			    value = (value<<8) | (third & 0xFF);
-RETURN ( nil );
+			    value = (value<<8) | (fourth & 0xFF);
-}
+			} else {
-fourth = getc(f);
+			    value = (fourth & 0xFF);
-_immediateInterrupt = 0;
+			    value = (value<<8) | (third & 0xFF);
+			    value = (value<<8) | (second & 0xFF);
-if (fourth == EOF) {
+			    value = (value<<8) | (first & 0xFF);
-_INST(hitEOF) = true;
+			}
-RETURN ( nil );
+			if (_INST(position) != nil) {
-}
+			    _INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 4);
-if (_INST(position) != nil) {
+			}
-_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 4);
+			if ((value >= _MIN_INT) && (value <= _MAX_INT)) {
-}
+			    RETURN ( _MKSMALLINT(value));
-if (msbFlag == true) {
+			}
-value = ((first & 0xFF) << 24)
+			RETURN ( _makeLarge(value) );
-| ((second & 0xFF) << 16)
+		    }
-| ((third & 0xFF) << 8)
+		}
-| (fourth & 0xFF);
+	    }
-} else {
+	}
-value = ((fourth & 0xFF) << 24)
+	if (ferror(f)) {
-| ((third & 0xFF) << 16)
+	    _INST(lastErrorNumber) = _MKSMALLINT(errno);
-| ((second & 0xFF) << 8)
+	    _INST(position) = nil;
-| (first & 0xFF);
+	} else {
-}
+	    _INST(hitEOF) = true;
-if ((value >= _MIN_INT) && (value <= _MAX_INT)) {
+	    RETURN (nil);
-RETURN ( _MKSMALLINT(value));
+	}
 }
-RETURN ( _makeLarge(value) );
+%}.
-}
-%}
-.
 filePointer isNil ifTrue:[^ self errorNotOpen].
 (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
-self primitiveFailed
+^ self readError.
 !
 nextUnsignedLongMSB:msbFlag
 "Read four bytes and return the value as a 32-bit unsigned Integer, which may be
 a LargeInteger.
 %{  /* NOCONTEXT */
 extern int _immediateInterrupt;
 extern OBJ _makeULarge();
-if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
+_INST(lastErrorNumber) = nil;
-FILE *f;
+if ((_INST(filePointer) != nil)
-int first, second, third, fourth;
+&& (_INST(mode) != @symbol(writeonly))) {
-unsigned int value;
+	FILE *f;
+	int first, second, third, fourth;
-_immediateInterrupt = 1;
+	unsigned int value;
-f = MKFD(_INST(filePointer));
+	_immediateInterrupt = 1;
-if ((_INST(didWrite) != false) && (_INST(mode) == _readwrite)) {
+	f = MKFD(_INST(filePointer));
-_INST(didWrite) = false;
-fseek(f, 0L, 1); /* needed in stdio */
+	if ((_INST(didWrite) != false)
-}
+	 && (_INST(mode) == @symbol(readwrite))) {
+	    _INST(didWrite) = false;
-first = getc(f);
+	    fseek(f, 0L, 1); /* needed in stdio */
-if (first == EOF) {
+	}
-_INST(hitEOF) = true;
-_immediateInterrupt = 0;
+	first = getc(f);
-RETURN ( nil );
+	if (first != EOF) {
-}
+	    second = getc(f);
-second = getc(f);
+	    if (second != EOF) {
-if (second == EOF) {
+		third = getc(f);
-_INST(hitEOF) = true;
+		if (third != EOF) {
-_immediateInterrupt = 0;
+		    fourth = getc(f);
-RETURN ( nil );
+		    if (fourth != EOF) {
-}
+			_immediateInterrupt = 0;
-third = getc(f);
+			if (msbFlag == true) {
-if (third == EOF) {
+			    value = (first & 0xFF);
-_INST(hitEOF) = true;
+			    value = (value<<8) | (second & 0xFF);
-_immediateInterrupt = 0;
+			    value = (value<<8) | (third & 0xFF);
-RETURN ( nil );
+			    value = (value<<8) | (fourth & 0xFF);
-}
+			} else {
-fourth = getc(f);
+			    value = (fourth & 0xFF);
-_immediateInterrupt = 0;
+			    value = (value<<8) | (third & 0xFF);
-if (fourth == EOF) {
+			    value = (value<<8) | (second & 0xFF);
-_INST(hitEOF) = true;
+			    value = (value<<8) | (first & 0xFF);
-RETURN ( nil );
+			}
-}
+			if (_INST(position) != nil) {
-if (_INST(position) != nil) {
+			    _INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 4);
-_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 4);
+			}
-}
+			if (value <= _MAX_INT) {
-if (msbFlag == true) {
+			    RETURN ( _MKSMALLINT(value));
-value = ((first & 0xFF) << 24)
+			}
-| ((second & 0xFF) << 16)
+			RETURN ( _makeULarge(value) );
-| ((third & 0xFF) << 8)
+		    }
-| (fourth & 0xFF);
+		}
-} else {
+	    }
-value = ((fourth & 0xFF) << 24)
+	}
-| ((third & 0xFF) << 16)
+	if (ferror(f)) {
-| ((second & 0xFF) << 8)
+	    _INST(lastErrorNumber) = _MKSMALLINT(errno);
-| (first & 0xFF);
+	    _INST(position) = nil;
-}
+	} else {
-if (value <= _MAX_INT) {
+	    _INST(hitEOF) = true;
-RETURN ( _MKSMALLINT(value));
+	    RETURN (nil);
-}
+	}
-RETURN ( _makeULarge(value) );
+}
-}
+%}.
-%}
-.
 filePointer isNil ifTrue:[^ self errorNotOpen].
 (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
-self primitiveFailed
+^ self readError.
+!
+nextWord
+"in text-mode:
+	 read the alphaNumeric next word (i.e. up to non letter-or-digit).
+	 return a string containing those characters.
+in binary-mode:
+	 read two bytes (msb-first) and return the value as a 16-bit unsigned Integer
+	 (for compatibility with other smalltalks)"
+binary ifTrue:[
+	^ self nextShortMSB:true
+].
+^ self nextAlphaNumericWord
 !
 nextLong
 "Read four bytes (msb-first) and return the value as a 32-bit signed Integer.
 The returned value may be a LargeInteger.
 extern errno;
 OBJ pos;
 int cnt;
 extern int _immediateInterrupt;
-if ((_INST(filePointer) != nil) && (_INST(mode) != _readonly)) {
+_INST(lastErrorNumber) = nil;
-if (_isSmallInteger(aByteValue)) {
+if ((_INST(filePointer) != nil)
-c = _intVal(aByteValue);
+&& (_INST(mode) != @symbol(readonly))) {
-f = MKFD(_INST(filePointer));
+	if (_isSmallInteger(aByteValue)) {
-_immediateInterrupt = 1;
+	    c = _intVal(aByteValue);
+	    f = MKFD(_INST(filePointer));
+	    _immediateInterrupt = 1;
 #ifdef OLD
-if (_INST(buffered) == false) {
+	    if (_INST(buffered) == false) {
-cnt = write(fileno(f), &c, 1);
+		cnt = write(fileno(f), &c, 1);
-} else
+	    } else
 #endif
-{
+	    {
-if ((_INST(didWrite) != true) && (_INST(mode) == _readwrite)) {
+		if ((_INST(didWrite) != true)
-_INST(didWrite) = true;
+		 && (_INST(mode) == @symbol(readwrite))) {
-fseek(f, 0L, 1); /* needed in stdio */
+		    _INST(didWrite) = true;
-}
+		    fseek(f, 0L, 1); /* needed in stdio */
-cnt = fwrite(&c, 1, 1, f);
+		}
+		cnt = fwrite(&c, 1, 1, f);
 #ifndef OLD
-if (_INST(buffered) == false) {
+		if (_INST(buffered) == false) {
-fflush(f);
+		    fflush(f);
-}
+		}
 #endif
-}
+	    }
-_immediateInterrupt = 0;
+	    _immediateInterrupt = 0;
-if (cnt == 1) {
+	    if (cnt == 1) {
-pos = _INST(position);
+		pos = _INST(position);
-if (pos != nil)
+		if (pos != nil)
-_INST(position) = _MKSMALLINT(_intVal(pos) + 1);
+		    _INST(position) = _MKSMALLINT(_intVal(pos) + 1);
-RETURN ( self );
+		RETURN (self);
-}
+	    }
-ExternalStream_LastErrorNumber = _MKSMALLINT(errno);
+	    if (cnt < 0) {
-RETURN (nil);
+		_INST(lastErrorNumber) = _MKSMALLINT(errno);
-}
+	    }
-}
+	}
-%}
+}
-.
+%}.
 filePointer isNil ifTrue:[^ self errorNotOpen].
 (mode == #readonly) ifTrue:[^ self errorReadOnly].
-self primitiveFailed
+^ self writeError.
 !
 nextPutBytesFrom:anObject
 "write bytes from an object; the number of bytes is defined by
 the objects size.
 ^ self nextPutBytes:count from:anObject startingAt:1
 !
 nextPutBytes:count from:anObject startingAt:start
 "write count bytes from an object starting at index start.
-return the number of bytes written or nil on error.
+return the number of bytes written - which could be 0.
 The object must have non-pointer indexed instvars
 (i.e. be a ByteArray, String, Float- or DoubleArray).
 Use with care - non object oriented i/o"
 %{  /* NOCONTEXT */
 extern errno;
 OBJ oClass;
 OBJ pos;
 extern int _immediateInterrupt;
-if ((_INST(filePointer) != nil) && (_INST(mode) != _readonly)) {
+_INST(lastErrorNumber) = nil;
-if (_isSmallInteger(count) && _isSmallInteger(start)) {
+if ((_INST(filePointer) != nil)
-oClass = _Class(anObject);
+&& (_INST(mode) != @symbol(readonly))) {
-switch (_intVal(_ClassInstPtr(oClass)->c_flags) & ARRAYMASK) {
+	if (_isSmallInteger(count) && _isSmallInteger(start)) {
-case BYTEARRAY:
+	    oClass = _Class(anObject);
-case WORDARRAY:
+	    switch (_intVal(_ClassInstPtr(oClass)->c_flags) & ARRAYMASK) {
-case LONGARRAY:
+		case BYTEARRAY:
-case FLOATARRAY:
+		case WORDARRAY:
-case DOUBLEARRAY:
+		case LONGARRAY:
-break;
+		case FLOATARRAY:
-default:
+		case DOUBLEARRAY:
-goto bad;
+		    break;
-}
+		default:
-cnt = _intVal(count);
+		    goto bad;
-offs = _intVal(start) - 1;
+	    }
-f = MKFD(_INST(filePointer));
+	    cnt = _intVal(count);
+	    offs = _intVal(start) - 1;
-nInstVars = _intVal(_ClassInstPtr(oClass)->c_ninstvars);
+	    f = MKFD(_INST(filePointer));
-nInstBytes = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
-objSize = _Size(anObject) - nInstBytes;
+	    nInstVars = _intVal(_ClassInstPtr(oClass)->c_ninstvars);
-if ( (offs >= 0) && (cnt >= 0) && (objSize >= (cnt + offs)) ) {
+	    nInstBytes = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
-cp = (char *)_InstPtr(anObject) + nInstBytes + offs;
+	    objSize = _Size(anObject) - nInstBytes;
-_immediateInterrupt = 1;
+	    if ( (offs >= 0) && (cnt >= 0) && (objSize >= (cnt + offs)) ) {
+		cp = (char *)_InstPtr(anObject) + nInstBytes + offs;
+		_immediateInterrupt = 1;
 #ifdef OLD
-if (_INST(buffered) == false) {
+		if (_INST(buffered) == false) {
-cnt = write(fileno(f), cp, cnt);
+		    cnt = write(fileno(f), cp, cnt);
-} else
+		} else
 #endif
-{
+		{
-if ((_INST(didWrite) != true) && (_INST(mode) == _readwrite)) {
+		    if ((_INST(didWrite) != true)
-_INST(didWrite) = true;
+		     && (_INST(mode) == @symbol(readwrite))) {
-fseek(f, 0L, 1); /* needed in stdio */
+			_INST(didWrite) = true;
-}
+			fseek(f, 0L, 1); /* needed in stdio */
-cnt = fwrite(cp, 1, cnt, f);
+		    }
-}
+		    cnt = fwrite(cp, 1, cnt, f);
+		}
 #ifndef OLD
-if (_INST(buffered) == false) {
+		if (_INST(buffered) == false) {
-fflush(f);
+		    fflush(f);
-}
+		}
 #endif
-_immediateInterrupt = 0;
+		_immediateInterrupt = 0;
-if (cnt >= 0) {
+		if (cnt >= 0) {
-pos = _INST(position);
+		    pos = _INST(position);
-if (pos != nil)
+		    if (pos != nil)
-_INST(position) = _MKSMALLINT(_intVal(pos) + cnt);
+			_INST(position) = _MKSMALLINT(_intVal(pos) + cnt);
-RETURN ( _MKSMALLINT(cnt) );
+		    RETURN ( _MKSMALLINT(cnt) );
-}
+		}
-ExternalStream_LastErrorNumber = _MKSMALLINT(errno);
+		_INST(lastErrorNumber) = _MKSMALLINT(errno);
-RETURN ( nil );
+	    }
-}
+	}
-}
 }
 bad: ;
-%}
+%}.
-.
+lastErrorNumber notNil ifTrue:[^ self writeError].
 filePointer isNil ifTrue:[^ self errorNotOpen].
 (mode == #readonly) ifTrue:[^ self errorReadOnly].
-self primitiveFailed
+^ self primitiveFailed
 !
 nextPutShort:aNumber MSB:msbFlag
 "Write the argument, aNumber as a short (two bytes). If msbFlag is
 true, data is written most-significant byte first; otherwise least
-first. Returns the receiver on ok, nil on error.
+first.
 Works in both binary and text modes."
 %{  /* NOCONTEXT */
 int num;
 FILE *f;
 extern errno;
 extern int _immediateInterrupt;
 int cnt;
-if ((_INST(filePointer) != nil) && (_INST(mode) != _readonly)) {
+_INST(lastErrorNumber) = nil;
-if (_isSmallInteger(aNumber)) {
+if ((_INST(filePointer) != nil)
-num = _intVal(aNumber);
+&& (_INST(mode) != @symbol(readonly))
-if (msbFlag == true) {
+&& _isSmallInteger(aNumber)) {
-bytes[0] = (num >> 8) & 0xFF;
+	num = _intVal(aNumber);
-bytes[1] = num & 0xFF;
+	if (msbFlag == true) {
-} else {
+	    bytes[0] = (num >> 8) & 0xFF;
-bytes[1] = (num >> 8) & 0xFF;
+	    bytes[1] = num & 0xFF;
-bytes[0] = num & 0xFF;
+	} else {
-}
+	    bytes[1] = (num >> 8) & 0xFF;
+	    bytes[0] = num & 0xFF;
-f = MKFD(_INST(filePointer));
+	}
-_immediateInterrupt = 1;
+	f = MKFD(_INST(filePointer));
+	_immediateInterrupt = 1;
 #ifdef OLD
-if (_INST(buffered) == false) {
+	if (_INST(buffered) == false) {
-cnt = write(fileno(f), bytes, 2);
+	    cnt = write(fileno(f), bytes, 2);
-} else
+	} else
 #endif
-{
+	{
-if ((_INST(didWrite) != true) && (_INST(mode) == _readwrite)) {
+	    if ((_INST(didWrite) != true)
-_INST(didWrite) = true;
+	     && (_INST(mode) == @symbol(readwrite))) {
-fseek(f, 0L, 1); /* needed in stdio */
+		_INST(didWrite) = true;
-}
+		fseek(f, 0L, 1); /* needed in stdio */
-cnt = fwrite(bytes, 1, 2, f);
+	    }
-}
+	    cnt = fwrite(bytes, 1, 2, f);
+	}
 #ifndef OLD
-if (_INST(buffered) == false) {
+	if (_INST(buffered) == false) {
-fflush(f);
+	    fflush(f);
-}
+	}
 #endif
-_immediateInterrupt = 0;
+	_immediateInterrupt = 0;
-if (cnt == 2) {
+	if (cnt == 2) {
-if (_INST(position) != nil) {
+	    if (_INST(position) != nil) {
-_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 2);
+		_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 2);
-}
+	    }
-RETURN ( self );
+	    RETURN ( self );
-}
+	}
-ExternalStream_LastErrorNumber = _MKSMALLINT(errno);
+	_INST(lastErrorNumber) = _MKSMALLINT(errno);
-return ( nil );
+}
-}
+%}.
-}
+lastErrorNumber notNil ifTrue:[^ self writeError].
-%}
-.
 filePointer isNil ifTrue:[^ self errorNotOpen].
 (mode == #readonly) ifTrue:[^ self errorReadOnly].
 self argumentMustBeInteger
 !
 nextPutLong:aNumber MSB:msbFlag
 "Write the argument, aNumber as a long (four bytes). If msbFlag is
 true, data is written most-significant byte first; otherwise least
-first. Returns the receiver on ok, nil on error.
+first.
 Works in both binary and text modes."
 %{  /* NOCONTEXT */
 int num;
 FILE *f;
 extern errno;
 int cnt;
 extern int _immediateInterrupt;
-if ((_INST(filePointer) != nil) && (_INST(mode) != _readonly)) {
+_INST(lastErrorNumber) = nil;
-if (_isSmallInteger(aNumber)) {
+if ((_INST(filePointer) != nil)
-num = _intVal(aNumber);
+&& (_INST(mode) != @symbol(readonly))
-if (msbFlag == true) {
+&& _isSmallInteger(aNumber)) {
-bytes[0] = (num >> 24) & 0xFF;
+	num = _intVal(aNumber);
-bytes[1] = (num >> 16) & 0xFF;
+	if (msbFlag == true) {
-bytes[2] = (num >> 8) & 0xFF;
+	    bytes[0] = (num >> 24) & 0xFF;
-bytes[3] = num & 0xFF;
+	    bytes[1] = (num >> 16) & 0xFF;
-} else {
+	    bytes[2] = (num >> 8) & 0xFF;
-bytes[3] = (num >> 24) & 0xFF;
+	    bytes[3] = num & 0xFF;
-bytes[2] = (num >> 16) & 0xFF;
+	} else {
-bytes[1] = (num >> 8) & 0xFF;
+	    bytes[3] = (num >> 24) & 0xFF;
-bytes[0] = num & 0xFF;
+	    bytes[2] = (num >> 16) & 0xFF;
-}
+	    bytes[1] = (num >> 8) & 0xFF;
+	    bytes[0] = num & 0xFF;
-f = MKFD(_INST(filePointer));
+	}
-_immediateInterrupt = 1;
+	f = MKFD(_INST(filePointer));
+	_immediateInterrupt = 1;
 #ifdef OLD
-if (_INST(buffered) == false) {
+	if (_INST(buffered) == false) {
-cnt = write(fileno(f), bytes, 4);
+	    cnt = write(fileno(f), bytes, 4);
-} else
+	} else
 #endif
-{
+	{
-cnt = fwrite(bytes, 1, 4, f);
+	    if ((_INST(didWrite) != true)
-}
+	     && (_INST(mode) == @symbol(readwrite))) {
+		_INST(didWrite) = true;
+		fseek(f, 0L, 1); /* needed in stdio */
+	    }
+	    cnt = fwrite(bytes, 1, 4, f);
+	}
 #ifndef OLD
-if (_INST(buffered) == false) {
+	if (_INST(buffered) == false) {
-fflush(f);
+	    fflush(f);
-}
+	}
 #endif
-_immediateInterrupt = 0;
+	_immediateInterrupt = 0;
-if (cnt == 4) {
+	if (cnt == 4) {
-if (_INST(position) != nil) {
+	    if (_INST(position) != nil) {
-_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 4);
+		_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 4);
-}
+	    }
-RETURN ( self );
+	    RETURN ( self );
-}
+	}
-ExternalStream_LastErrorNumber = _MKSMALLINT(errno);
+	_INST(lastErrorNumber) = _MKSMALLINT(errno);
-return ( nil );
+}
-}
+%}.
-}
-%}
-.
 filePointer isNil ifTrue:[^ self errorNotOpen].
 (mode == #readonly) ifTrue:[^ self errorReadOnly].
+lastErrorNumber notNil ifTrue:[^ self writeError].
 aNumber isInteger ifTrue:[
-msbFlag ifTrue:[
+	msbFlag ifTrue:[
-"high word first"
+	    "high word first"
-(self nextShortPut:(aNumber // 16r10000) MSB:true) isNil ifTrue:[^ nil].
+	    (self nextShortPut:(aNumber // 16r10000) MSB:true) isNil ifTrue:[^ nil].
-^ self nextShortPut:(aNumber \\ 16r10000) MSB:true
+	    ^ self nextShortPut:(aNumber \\ 16r10000) MSB:true
-].
+	].
-"low word first"
+	"low word first"
-(self nextShortPut:(aNumber \\ 16r10000) MSB:false) isNil ifTrue:[^ nil].
+	(self nextShortPut:(aNumber \\ 16r10000) MSB:false) isNil ifTrue:[^ nil].
-^ self nextShortPut:(aNumber // 16r10000) MSB:false.
+	^ self nextShortPut:(aNumber // 16r10000) MSB:false.
 ].
 self argumentMustBeInteger
 ! !
 !ExternalStream methodsFor:'reading'!
 FILE *f;
 REGISTER int c;
 extern int _immediateInterrupt;
-if (_INST(filePointer) != nil) {
+_INST(lastErrorNumber) = nil;
-if (_INST(mode) != _writeonly) {
+if ((_INST(filePointer) != nil)
+&& (_INST(mode) != @symbol(writeonly))) {
 #ifdef OLD
-if (_INST(buffered) == true)
+	if (_INST(buffered) == true)
 #endif
-{
+	{
-f = MKFD(_INST(filePointer));
+	    f = MKFD(_INST(filePointer));
-if ((_INST(didWrite) != false) && (_INST(mode) == _readwrite)) {
+	    if ((_INST(didWrite) != false)
-_INST(didWrite) = false;
+	     && (_INST(mode) == @symbol(readwrite))) {
-fseek(f, 0L, 1); /* needed in stdio */
+		_INST(didWrite) = false;
-}
+		fseek(f, 0L, 1); /* needed in stdio */
+	    }
-_immediateInterrupt = 1;
-c = getc(f);
+	    _immediateInterrupt = 1;
-_immediateInterrupt = 0;
+	    c = getc(f);
+	    _immediateInterrupt = 0;
-if (c != EOF) {
-ungetc(c, f);
+	    if (c != EOF) {
-if (_INST(binary) == true) {
+		ungetc(c, f);
-RETURN ( _MKSMALLINT(c & 0xFF) );
+		if (_INST(binary) == true) {
-}
+		    RETURN ( _MKSMALLINT(c & 0xFF) );
-RETURN ( _MKCHARACTER(c & 0xFF) );
+		}
-}
+		RETURN ( _MKCHARACTER(c & 0xFF) );
-_INST(hitEOF) = true;
+	    }
-RETURN ( nil );
+	    if (ferror(f)) {
-}
+		_INST(lastErrorNumber) = _MKSMALLINT(errno);
-}
+	    } else {
-}
+		_INST(hitEOF) = true;
-%}
+		RETURN ( nil );
-.
+	    }
+	}
+}
+%}.
+lastErrorNumber notNil ifTrue:[^ self readError].
 filePointer isNil ifTrue:[^ self errorNotOpen].
 buffered ifFalse:[^ self errorNotBuffered].
-self errorWriteOnly
+^ self errorWriteOnly
 !
 next
 "return the next element; advance read position.
 In binary mode, an integer is returned, otherwise a character.
 OBJ pos;
 unsigned char ch;
 extern int _immediateInterrupt;
-if (_INST(filePointer) != nil) {
+_INST(lastErrorNumber) = nil;
-if (_INST(mode) != _writeonly) {
+if ((_INST(filePointer) != nil)
-f = MKFD(_INST(filePointer));
+&& (_INST(mode) != @symbol(writeonly))) {
-_immediateInterrupt = 1;
+	f = MKFD(_INST(filePointer));
-do {
+	_immediateInterrupt = 1;
+	do {
 #ifdef OLD
-if (_INST(buffered) == false) {
+	    if (_INST(buffered) == false) {
-if (read(fileno(f), &ch, 1) != 1)
+		if (read(fileno(f), &ch, 1) != 1)
-c = EOF;
+		    c = EOF;
-else
+		else
-c = ch;
+		    c = ch;
-} else
+	    } else
 #endif
-{
+	    {
-if ((_INST(didWrite) != false) && (_INST(mode) == _readwrite)) {
+		if ((_INST(didWrite) != false)
-_INST(didWrite) = false;
+		 && (_INST(mode) == @symbol(readwrite))) {
-fseek(f, 0L, 1); /* needed in stdio */
+		    _INST(didWrite) = false;
-}
+		    fseek(f, 0L, 1); /* needed in stdio */
-c = getc(f);
+		}
-}
+		c = getc(f);
-} while ((c < 0) && (errno == EINTR));
+	    }
+	} while ((c < 0) && (errno == EINTR));
-_immediateInterrupt = 0;
-if (c != EOF) {
+	_immediateInterrupt = 0;
-pos = _INST(position);
-if (_isSmallInteger(pos)) {
+	if (c != EOF) {
-_INST(position) = _MKSMALLINT(_intVal(pos) + 1);
+	    pos = _INST(position);
-} else {
+	    if (_isSmallInteger(pos)) {
-_INST(position) = nil;
+		_INST(position) = _MKSMALLINT(_intVal(pos) + 1);
-}
+	    } else {
-if (_INST(binary) == true) {
+		_INST(position) = nil;
-RETURN ( _MKSMALLINT(c & 0xFF) );
+	    }
-}
+	    if (_INST(binary) == true) {
-RETURN ( _MKCHARACTER(c & 0xFF) );
+		RETURN ( _MKSMALLINT(c & 0xFF) );
-}
+	    }
-_INST(hitEOF) = true;
+	    RETURN ( _MKCHARACTER(c & 0xFF) );
-_INST(position) = nil;
+	}
-RETURN ( nil );
+	_INST(position) = nil;
-}
+	if (ferror(f)) {
-}
+	    _INST(lastErrorNumber) = _MKSMALLINT(errno);
-%}
+	} else {
-.
+	    _INST(hitEOF) = true;
+	    RETURN ( nil );
+	}
+}
+%}.
+lastErrorNumber notNil ifTrue:[^ self readError].
 filePointer isNil ifTrue:[^ self errorNotOpen].
 self errorWriteOnly
 !
 next:count
 Redefined to return a String or ByteArray instead of the default Array."
 |coll|
 binary ifTrue:[
-coll := ByteArray new:count
+	coll := ByteArray new:count
 ] ifFalse:[
-coll := String new:count
+	coll := String new:count
 ].
 1 to:count do: [:index |
-coll at:index put:(self next)
+	coll at:index put:(self next)
 ].
 ^ coll
 ! !
 !ExternalStream methodsFor:'writing'!
 synchronizeOutput
 "write all buffered data - for buffered mode only"
 %{  /* NOCONTEXT */
+_INST(lastErrorNumber) = nil;
 if (_INST(filePointer) != nil) {
-if (_INST(mode) != _readonly) {
+	if (_INST(mode) != @symbol(readonly)) {
-if (_INST(buffered) == true) {
+	    if (_INST(buffered) == true) {
-fflush( MKFD(_INST(filePointer)) );
+		fflush( MKFD(_INST(filePointer)) );
-}
+	    }
-}
+	}
 }
 %}
 !
 nextPut:aCharacter
 extern errno;
 int cnt;
 OBJ pos;
 extern int _immediateInterrupt;
-if (_INST(filePointer) != nil) {
+_INST(lastErrorNumber) = nil;
-if (_INST(mode) != _readonly) {
+if ((_INST(filePointer) != nil)
-if (_INST(binary) != true) {
+&& (_INST(mode) != @symbol(readonly))) {
-if (__isCharacter(aCharacter)) {
+	if (_INST(binary) != true) {
-c = _intVal(_CharacterInstPtr(aCharacter)->c_asciivalue);
+	    if (__isCharacter(aCharacter)) {
+		c = _intVal(_CharacterInstPtr(aCharacter)->c_asciivalue);
 doWrite:
-f = MKFD(_INST(filePointer));
+		f = MKFD(_INST(filePointer));
-_immediateInterrupt = 1;
+		_immediateInterrupt = 1;
-#ifdef OLD
-if (_INST(buffered) == false) {
+		if ((_INST(didWrite) != true)
-cnt = write(fileno(f), &c, 1);
+		 && (_INST(mode) == @symbol(readwrite))) {
-} else
+		    _INST(didWrite) = true;
-#endif
+		    fseek(f, 0L, 1); /* needed in stdio */
-{
+		}
-if ((_INST(didWrite) != true) && (_INST(mode) == _readwrite)) {
-_INST(didWrite) = true;
+		do {
-fseek(f, 0L, 1); /* needed in stdio */
+		    cnt = fwrite(&c, 1, 1, f);
-}
+	    	} while ((cnt != 1) && (errno == EINTR));
-cnt = fwrite(&c, 1, 1, f);
-}
+		if (_INST(buffered) == false) {
-#ifndef OLD
+		    fflush(f);
-if (_INST(buffered) == false) {
+		}
-fflush(f);
-}
+		_immediateInterrupt = 0;
-#endif
+		if (cnt == 1) {
-_immediateInterrupt = 0;
+		    pos = _INST(position);
-if (cnt == 1) {
+		    if (pos != nil) {
-pos = _INST(position);
+			_INST(position) = _MKSMALLINT(_intVal(pos) + 1);
-if (pos != nil) {
+		    }
-_INST(position) = _MKSMALLINT(_intVal(pos) + 1);
+		    RETURN ( self );
-}
+		}
-RETURN ( self );
+		_INST(lastErrorNumber) = _MKSMALLINT(errno);
-}
+	    }
-ExternalStream_LastErrorNumber = _MKSMALLINT(errno);
+	} else {
-RETURN ( nil );
+	    if (_isSmallInteger(aCharacter)) {
-}
+		c = _intVal(aCharacter);
-} else {
+		goto doWrite;
-if (_isSmallInteger(aCharacter)) {
+	    }
-c = _intVal(aCharacter);
+	}
-goto doWrite;
+}
-}
+%}.
-}
+lastErrorNumber notNil ifTrue:[^ self writeError].
-}
-}
-%}
-.
 filePointer isNil ifTrue:[^ self errorNotOpen].
 (mode == #readonly) ifTrue:[^ self errorReadOnly].
 binary ifFalse:[^ self argumentMustBeCharacter].
 ^ self argumentMustBeInteger.
 !
 int len, cnt;
 extern errno;
 OBJ pos;
 extern int _immediateInterrupt;
-if ((_INST(filePointer) != nil) && (_INST(mode) != _readonly)) {
+_INST(lastErrorNumber) = nil;
-cp = NULL;
+if ((_INST(filePointer) != nil)
-if (__isString(aCollection) || __isSymbol(aCollection)) {
+&& (_INST(mode) != @symbol(readonly))) {
-cp = _stringVal(aCollection);
+	cp = NULL;
-len = _stringSize(aCollection);
+	if (__isString(aCollection) || __isSymbol(aCollection)) {
-} else {
+	    cp = _stringVal(aCollection);
-if (_INST(binary) == true) {
+	    len = _stringSize(aCollection);
-if (__isByteArray(aCollection)) {
+	} else {
-cp = _ByteArrayInstPtr(aCollection)->ba_element;
+	    if (_INST(binary) == true) {
-len = _byteArraySize(aCollection);
+		if (__isByteArray(aCollection)) {
-} else {
+		    cp = _ByteArrayInstPtr(aCollection)->ba_element;
-if (__isBytes(aCollection)) {
+		    len = _byteArraySize(aCollection);
-int nInst;
+		} else {
+		    if (__isBytes(aCollection)) {
-cp = _ByteArrayInstPtr(aCollection)->ba_element;
+			int nInst;
-len = _byteArraySize(aCollection);
-nInst = _intVal(_ClassInstPtr(_qClass(aCollection))->c_ninstvars);
+			cp = _ByteArrayInstPtr(aCollection)->ba_element;
-cp += __OBJS2BYTES__(nInst);
+			len = _byteArraySize(aCollection);
-len -= __OBJS2BYTES__(nInst);
+			nInst = _intVal(_ClassInstPtr(_qClass(aCollection))->c_ninstvars);
-}
+			cp += __OBJS2BYTES__(nInst);
-}
+			len -= __OBJS2BYTES__(nInst);
-}
+		    }
-}
+		}
-if (cp != NULL) {
+	    }
-f = MKFD(_INST(filePointer));
+	}
+	if (cp != NULL) {
-_immediateInterrupt = 1;
+	    f = MKFD(_INST(filePointer));
+	    _immediateInterrupt = 1;
 #ifdef OLD
-if (_INST(buffered) == false) {
+	    if (_INST(buffered) == false) {
-cnt = write(fileno(f), cp, len);
+		cnt = write(fileno(f), cp, len);
-} else
+	    } else
 #endif
-{
+	    {
-if ((_INST(didWrite) != true) && (_INST(mode) == _readwrite)) {
+		if ((_INST(didWrite) != true)
-_INST(didWrite) = true;
+		 && (_INST(mode) == @symbol(readwrite))) {
-fseek(f, 0L, 1); /* needed in stdio */
+		    _INST(didWrite) = true;
-}
+		    fseek(f, 0L, 1); /* needed in stdio */
-cnt = fwrite(cp, 1, len, f);
+		}
-}
+		do {
+		    cnt = fwrite(cp, 1, len, f);
+		    if (cnt != len) {
+			if (cnt >= 0) {
+			    if (errno == EINTR) {
+			   	cp += cnt;
+				len -= cnt;
+			    }
+			}
+		    }
+	        } while ((cnt != len) && (errno == EINTR));
+	    }
 #ifndef OLD
-if (_INST(buffered) == false) {
+		    if (_INST(buffered) == false) {
-fflush(f);
+			fflush(f);
-}
+		    }
 #endif
-_immediateInterrupt = 0;
+	    _immediateInterrupt = 0;
-if (cnt == len) {
+	    if (cnt == len) {
-pos = _INST(position);
+		pos = _INST(position);
-if (pos != nil) {
+		if (pos != nil) {
-_INST(position) = _MKSMALLINT(_intVal(pos) + len);
+		    _INST(position) = _MKSMALLINT(_intVal(pos) + len);
-}
+		}
-RETURN ( self );
+		RETURN ( self );
-}
+	    }
-ExternalStream_LastErrorNumber = _MKSMALLINT(errno);
+	    _INST(lastErrorNumber) = _MKSMALLINT(errno);
-RETURN ( nil );
+	}
 }
-}
+%}.
-%}
+lastErrorNumber notNil ifTrue:[^ self writeError].
-.
 ^ super nextPutAll:aCollection
 !
 nextPutAll:aCollection startingAt:start to:stop
 "write a range of elements of the argument, aCollection.
 unsigned char *cp;
 int len, cnt, index1, index2;
 extern errno;
 extern int _immediateInterrupt;
-if ((_INST(filePointer) != nil) && (_INST(mode) != _readonly)) {
+_INST(lastErrorNumber) = nil;
-if (_isSmallInteger(start) && _isSmallInteger(stop)) {
+if ((_INST(filePointer) != nil)
-cp = NULL;
+&& (_INST(mode) != @symbol(readonly))) {
-if (_INST(binary) != true) {
+	if (_isSmallInteger(start) && _isSmallInteger(stop)) {
-if (__isString(aCollection) || __isSymbol(aCollection)) {
+	    cp = NULL;
-cp = _stringVal(aCollection);
+	    if (_INST(binary) != true) {
-len = _stringSize(aCollection);
+		if (__isString(aCollection) || __isSymbol(aCollection)) {
-}
+		    cp = _stringVal(aCollection);
-} else {
+		    len = _stringSize(aCollection);
-if (__isByteArray(aCollection)) {
+		}
-cp = _ByteArrayInstPtr(aCollection)->ba_element;
+	    } else {
-len = _byteArraySize(aCollection);
+		if (__isByteArray(aCollection)) {
-} else {
+		    cp = _ByteArrayInstPtr(aCollection)->ba_element;
-if (__isBytes(aCollection)) {
+		    len = _byteArraySize(aCollection);
-int nInst;
+		} else {
+		    if (__isBytes(aCollection)) {
-cp = _ByteArrayInstPtr(aCollection)->ba_element;
+			int nInst;
-len = _byteArraySize(aCollection);
-nInst = _intVal(_ClassInstPtr(_qClass(aCollection))->c_ninstvars);
+			cp = _ByteArrayInstPtr(aCollection)->ba_element;
-cp += __OBJS2BYTES__(nInst);
+			len = _byteArraySize(aCollection);
-len -= __OBJS2BYTES__(nInst);
+			nInst = _intVal(_ClassInstPtr(_qClass(aCollection))->c_ninstvars);
-}
+			cp += __OBJS2BYTES__(nInst);
-}
+			len -= __OBJS2BYTES__(nInst);
-}
+		    }
-if (cp != NULL) {
+		}
-f = MKFD(_INST(filePointer));
+	    }
-index1 = _intVal(start);
+	    if (cp != NULL) {
-index2 = _intVal(stop);
+		f = MKFD(_INST(filePointer));
-if ((index1 < 1) || (index2 > len) || (index2 < index1)) {
+		index1 = _intVal(start);
-RETURN ( self );
+		index2 = _intVal(stop);
-}
+		if ((index1 < 1) || (index2 > len) || (index2 < index1)) {
-if (index2 > len)
+		    RETURN ( self );
-index2 = len;
+		}
+		if (index2 > len)
-_immediateInterrupt = 1;
+		    index2 = len;
-len = index2 - index1 + 1;
-#ifdef OLD
+		_immediateInterrupt = 1;
-if (_INST(buffered) == false) {
+		len = index2 - index1 + 1;
-cnt = write(fileno(f), cp + index1 - 1, len);
-} else
+		if ((_INST(didWrite) != true)
-#endif
+		 && (_INST(mode) == @symbol(readwrite))) {
-{
+		    _INST(didWrite) = true;
-if ((_INST(didWrite) != true) && (_INST(mode) == _readwrite)) {
+		    fseek(f, 0L, 1); /* needed in stdio */
-_INST(didWrite) = true;
+		}
-fseek(f, 0L, 1); /* needed in stdio */
-}
+		do {
-cnt = fwrite(cp + index1 - 1, 1, len, f);
+		    cnt = fwrite(cp + index1 - 1, 1, len, f);
-}
+		    if (cnt != len) {
-#ifndef OLD
+		        if (cnt >= 0) {
-if (_INST(buffered) == false) {
+			    if (errno == EINTR) {
-fflush(f);
+			   	cp += cnt;
-}
+				len -= cnt;
-#endif
+			    }
-_immediateInterrupt = 0;
+			}
-if (cnt == len) {
+		    }
-if (_INST(position) != nil) {
+	        } while ((cnt != len) && (errno == EINTR));
-_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + len);
-}
+		if (_INST(buffered) == false) {
-RETURN ( self );
+		    fflush(f);
-}
+		}
-ExternalStream_LastErrorNumber = _MKSMALLINT(errno);
-RETURN ( nil );
+		_immediateInterrupt = 0;
-}
+		if (cnt == len) {
-}
+		    if (_INST(position) != nil) {
-}
+			_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + len);
-%}
+		    }
-.
+		    RETURN ( self );
+		}
+		_INST(lastErrorNumber) = _MKSMALLINT(errno);
+	    }
+	}
+}
+%}.
+lastErrorNumber notNil ifTrue:[^ self writeError].
 ^ super nextPutAll:aCollection startingAt:start to:stop
 !
 cr
 "reimplemented for speed"
 FILE *f;
 extern errno;
 extern int _immediateInterrupt;
 int cnt;
-if ((_INST(filePointer) != nil) && (_INST(mode) != _readonly)) {
+_INST(lastErrorNumber) = nil;
-if (_INST(binary) != true) {
+if ((_INST(filePointer) != nil)
-f = MKFD(_INST(filePointer));
+&& (_INST(mode) != @symbol(readonly))) {
+	if (_INST(binary) != true) {
-_immediateInterrupt = 1;
+	    f = MKFD(_INST(filePointer));
-#ifdef OLD
-if (_INST(buffered) == false) {
+	    _immediateInterrupt = 1;
-cnt = write(fileno(f), "\n", 1);
-} else
+	    if ((_INST(didWrite) != true)
-#endif
+	     && (_INST(mode) == @symbol(readwrite))) {
-{
+		_INST(didWrite) = true;
-if ((_INST(didWrite) != true) && (_INST(mode) == _readwrite)) {
+		fseek(f, 0L, 1); /* needed in stdio */
-_INST(didWrite) = true;
+	    }
-fseek(f, 0L, 1); /* needed in stdio */
-}
+	    do {
-cnt = fwrite("\n", 1, 1, f);
+		cnt = fwrite("\n", 1, 1, f);
-}
+	    } while ((cnt != 1) && (errno == EINTR));
-#ifndef OLD
-if (_INST(buffered) == false) {
+	    if (_INST(buffered) == false) {
-fflush(f);
+		fflush(f);
-}
+	    }
-#endif
-_immediateInterrupt = 0;
+	    _immediateInterrupt = 0;
-if (cnt == 1) {
+	    if (cnt == 1) {
-if (_INST(position) != nil) {
+		if (_INST(position) != nil) {
-_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 1);
+		    _INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 1);
-}
+		}
-RETURN ( self );
+		RETURN ( self );
-}
+	    }
-ExternalStream_LastErrorNumber = _MKSMALLINT(errno);
+	    _INST(lastErrorNumber) = _MKSMALLINT(errno);
-return ( nil );
+	}
 }
-}
+%}.
-%}
+lastErrorNumber notNil ifTrue:[^ self writeError].
-.
 filePointer isNil ifTrue:[^ self errorNotOpen].
 (mode == #readonly) ifTrue:[^ self errorReadOnly].
 self errorBinary
 ! !
 char *rslt;
 extern errno;
 int fd, ch;
 int _buffered;
-if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
+_INST(lastErrorNumber) = nil;
-if (_INST(binary) != true) {
+if ((_INST(filePointer) != nil)
-f = MKFD(_INST(filePointer));
+&& (_INST(mode) != @symbol(writeonly))) {
-_immediateInterrupt = 1;
+	if (_INST(binary) != true) {
-buffer[0] = 0;
+	    f = MKFD(_INST(filePointer));
+	    _immediateInterrupt = 1;
-_buffered = (_INST(buffered) == true);
+	    buffer[0] = 0;
-/*
+	    _buffered = (_INST(buffered) == true);
-* mhmh - the following code looks ok to me,
-* but seems not to work for sockets
+	    /*
-*/
+	     * mhmh - the following code looks ok to me,
+	     * but seems not to work for sockets
+	     */
 #ifdef DOES_NOT_WORK
-if (_INST(mode) == _readwrite)
+	    if (_INST(mode) == _readwrite)
-fseek(f, 0L, 1); /* needed in stdio */
+		fseek(f, 0L, 1); /* needed in stdio */
-do {
+	    do {
-rslt = fgets(buffer, sizeof(buffer), f);
+		rslt = fgets(buffer, sizeof(buffer), f);
-} while ((rslt == NULL) && (errno == EINTR));
+	    } while ((rslt == NULL) && (errno == EINTR));
 #else
-if (_buffered) {
+	    if (_buffered) {
-if ((_INST(didWrite) != false) && (_INST(mode) == _readwrite)) {
+		if ((_INST(didWrite) != false)
-_INST(didWrite) = false;
+		 && (_INST(mode) == @symbol(readwrite))) {
-fseek(f, 0L, 1); /* needed in stdio */
+		    _INST(didWrite) = false;
-}
+		    fseek(f, 0L, 1); /* needed in stdio */
-}
+		}
-rslt = buffer;
+	    }
-fd = fileno(f);
+	    rslt = buffer;
-for (;;) {
+	    fd = fileno(f);
-if (_buffered) {
+	    for (;;) {
-ch = getc(f);
+		if (_buffered) {
-if (ch == EOF)
+		    ch = getc(f);
-len = 0;
+		    if (ch == EOF) {
-else {
+			if (ferror(f)) {
-len = 1;
+			    if (errno == EINTR) {
-*rslt = ch;
+				clearerr(f);
-}
+				continue;
-} else {
+			    }
-do {
+			    _INST(lastErrorNumber) = _MKSMALLINT(errno);
-len = read(fd, rslt, 1);
+			}
-} while ((len < 0) && (errno == EINTR));
+			len = 0;
-}
+		    } else {
-if (len <= 0) {
+			len = 1;
-if (rslt == buffer) {
+			*rslt = ch;
-rslt = NULL;
+		    }
-} else {
+		} else {
-*rslt = '\0';
+		    do {
-}
+			len = read(fd, rslt, 1);
-break;
+		    } while ((len < 0) && (errno == EINTR));
-}
+		}
-rslt++;
+		if (len <= 0) {
-if (*(rslt-1) == '\n') {
+		    if (rslt == buffer) {
-*rslt = '\0';
+			rslt = NULL;
-break;
+		    } else {
-}
+			*rslt = '\0';
-if (rslt == (buffer + sizeof(buffer) - 1)) {
+		    }
-*rslt = '\0';
+		    break;
-break;
+		}
-}
+		rslt++;
-}
+		if (*(rslt-1) == '\n') {
+		    *rslt = '\0';
+		    break;
+		}
+		if (rslt == (buffer + sizeof(buffer) - 1)) {
+		    *rslt = '\0';
+		    break;
+		}
+	    }
 #endif
-_immediateInterrupt = 0;
+	    _immediateInterrupt = 0;
-if (rslt != NULL) {
+	    if (rslt != NULL) {
-len = strlen(buffer);
+		len = strlen(buffer);
-if (_INST(position) != nil) {
+		if (_INST(position) != nil) {
-_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + len + 1);
+		    _INST(position) = _MKSMALLINT(_intVal(_INST(position)) + len + 1);
-}
+		}
-/* remove EOL character */
+		/* remove EOL character */
-if ((len != 0) && (buffer[len-1] == '\n')) {
+		if ((len != 0) && (buffer[len-1] == '\n')) {
-buffer[--len] = '\0';
+		    buffer[--len] = '\0';
-}
+		}
-if ((len != 0) && (buffer[len-1] == '\r')) {
+		if ((len != 0) && (buffer[len-1] == '\r')) {
-buffer[--len] = '\0';
+		    buffer[--len] = '\0';
-}
+		}
-RETURN ( _MKSTRING(buffer COMMA_CON) );
+		RETURN ( _MKSTRING(buffer COMMA_CON) );
-}
+	    }
-_INST(hitEOF) = true;
+	    if (ferror(f)) {
-RETURN ( nil );
+		_INST(lastErrorNumber) = _MKSMALLINT(errno);
-}
+	    } else {
-}
+		_INST(hitEOF) = true;
-%}
+		RETURN ( nil );
-.
+	    }
+	}
+}
+%}.
+lastErrorNumber notNil ifTrue:[^ self readError].
 filePointer isNil ifTrue:[^ self errorNotOpen].
 (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
 self errorBinary
 !
 OBJ pos;
 char *s;
 extern errno;
 extern int _immediateInterrupt;
-if ((_INST(filePointer) != nil) && (_INST(mode) != _readonly)) {
+_INST(lastErrorNumber) = nil;
-if (_INST(binary) != true) {
+if ((_INST(filePointer) != nil)
-if (__isString(aString)) {
+&& (_INST(mode) != @symbol(readonly))) {
-f = MKFD(_INST(filePointer));
+	if (_INST(binary) != true) {
-s = (char *) _stringVal(aString);
+	    if (__isString(aString)) {
-len = _stringSize(aString);
+		f = MKFD(_INST(filePointer));
+		s = (char *) _stringVal(aString);
-_immediateInterrupt = 1;
+		len = _stringSize(aString);
+		_immediateInterrupt = 1;
 #ifdef OLD
-if (_INST(buffered) == false) {
+		if (_INST(buffered) == false) {
-cnt = write(fileno(f), s, len);
+		    cnt = write(fileno(f), s, len);
-} else
+		} else
 #endif
-{
+		{
-if ((_INST(didWrite) != true) && (_INST(mode) == _readwrite)) {
+		    if ((_INST(didWrite) != true)
-_INST(didWrite) = true;
+		     && (_INST(mode) == @symbol(readwrite))) {
-fseek(f, 0L, 1); /* needed in stdio */
+			_INST(didWrite) = true;
-}
+			fseek(f, 0L, 1); /* needed in stdio */
-cnt = fwrite(s, 1, len, f);
+		    }
-}
+		    cnt = fwrite(s, 1, len, f);
-if (cnt == len) {
+		}
+		if (cnt == len) {
 #ifdef OLD
-if (_INST(buffered) == false) {
+		    if (_INST(buffered) == false) {
-cnt = write(fileno(f), "\n", 1);
+			cnt = write(fileno(f), "\n", 1);
-} else
+		    } else
 #endif
-{
+		    {
-cnt = fwrite("\n", 1, 1, f);
+			cnt = fwrite("\n", 1, 1, f);
-}
+		    }
 #ifndef OLD
-if (_INST(buffered) == false) {
+		    if (_INST(buffered) == false) {
-fflush(f);
+			fflush(f);
-}
+		    }
 #endif
-if (cnt == 1) {
+		    if (cnt == 1) {
-pos = _INST(position);
+			pos = _INST(position);
-if (pos != nil) {
+			if (pos != nil) {
-_INST(position) = _MKSMALLINT(_intVal(pos)+len+1);
+			    _INST(position) = _MKSMALLINT(_intVal(pos)+len+1);
-}
+			}
-_immediateInterrupt = 0;
+			_immediateInterrupt = 0;
-RETURN ( self );
+			RETURN ( self );
-}
+		    }
-}
+		}
-_immediateInterrupt = 0;
+		_immediateInterrupt = 0;
-ExternalStream_LastErrorNumber = _MKSMALLINT(errno);
+		_INST(lastErrorNumber) = _MKSMALLINT(errno);
-RETURN ( nil );
+	    }
-}
+	}
 }
-}
+%}.
-%}
+lastErrorNumber notNil ifTrue:[^ self writeError].
-.
 super nextPutAll:aString.
 self cr.
 !
 nextPutLinesFrom:aStream upToLineStartingWith:aStringOrNil
 "read from aStream up to and including a line starting with aStringOrNil
 and append it to self.
-can be used to copy/create large files or copy from a pipe/socket.
+Can be used to copy/create large files or copy from a pipe/socket.
 If aStringOrNil is nil or not matched, copy preceeds to the end.
 (this allows for example to read a Socket and transfer the data quickly
 into a file - without creating zillions of temporary strings)"
-|srcFilePointer|
+|srcFilePointer readError|
 (mode == #readonly) ifTrue:[^ self errorReadOnly].
 filePointer isNil ifTrue:[^ self errorNotOpen].
 srcFilePointer := aStream filePointer.
 srcFilePointer isNil ifTrue:[^ aStream errorNotOpen].
 char *matchString;
 int matchLen = 0;
 char buffer[1024];
 extern int _immediateInterrupt;
-if (_isSmallInteger(srcFilePointer)
+_INST(lastErrorNumber) = nil;
-#ifdef OLD
+if (_isSmallInteger(srcFilePointer)) {
-&& (_INST(buffered) == true)
+	if ((aStringOrNil == nil) || __isString(aStringOrNil)) {
+	    if (aStringOrNil != nil) {
+		matchString = (char *) _stringVal(aStringOrNil);
+		matchLen = _stringSize(aStringOrNil);
+	    }
+	    dst = MKFD(_INST(filePointer));
+	    src = (FILE *)_intVal(srcFilePointer);
+	    _immediateInterrupt = 1;
+	    errno = 0;
+	    if ((_INST(didWrite) != true)
+	     && (_INST(mode) == @symbol(readwrite))) {
+		_INST(didWrite) = true;
+		fseek(dst, 0L, 1); /* needed in stdio */
+	    }
+	    for (;;) {
+		if (fgets(buffer, sizeof(buffer), src) == NULL) {
+		    if (ferror(src)) {
+			readError = _MKSMALLINT(errno);
+			goto err;
+		    }
+		    break;
+		}
+		if (fputs(buffer, dst) == EOF) {
+		    if (ferror(dst)) {
+			_INST(lastErrorNumber) = _MKSMALLINT(errno);
+			goto err;
+		    }
+		    break;
+		}
+#ifndef OLD
+		if (_INST(buffered) == false) {
+		    fflush(dst);
+		}
 #endif
-) {
+		if (matchLen) {
-if ((aStringOrNil == nil) || __isString(aStringOrNil)) {
+		    if (strncmp(matchString, buffer, matchLen) == 0)
-if (aStringOrNil != nil) {
+			break;
-matchString = (char *) _stringVal(aStringOrNil);
+		}
-matchLen = _stringSize(aStringOrNil);
+	    }
-}
+	    _immediateInterrupt = 0;
-dst = MKFD(_INST(filePointer));
+	    _INST(position) = nil;
-src = (FILE *)_intVal(srcFilePointer);
+	    RETURN (self);
-_immediateInterrupt = 1;
+	}
-for (;;) {
+}
-if (fgets(buffer, sizeof(buffer), src) == NULL) break;
+err: ;
-if (fputs(buffer, dst) == EOF) break;
+%}.
-#ifndef OLD
+readError ifTrue:[
-if (_INST(buffered) == false) {
+	aStream setLastErrorNumber:readError.
-fflush(dst);
+	^ aStream readError
-}
+].
-#endif
+lastErrorNumber notNil ifTrue:[^ self writeError].
-if (matchLen) {
-if (strncmp(matchString, buffer, matchLen) == 0)
-break;
-}
-}
-_immediateInterrupt = 0;
-_INST(position) = nil;
-RETURN ( self );
-}
-}
-%}
-.
 buffered ifFalse:[^ self errorNotBuffered].
+"
+argument error
+"
 ^ self primitiveFailed
 !
 peekForLineStartingWith:aString
 "read ahead for next line starting with aString;
-return the line-string if found, nil otherwise.
+return the line-string if found, or nil if EOF is encountered.
-Do not advance position i.e. nextLine will reread this line"
+If matched, not advance position behond that line
+i.e. nextLine will read the matched line.
+If not matched, reposition to original position for firther reading."
 (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
 filePointer isNil ifTrue:[^ self errorNotOpen].
 binary ifTrue:[^ self errorBinary].
 char *cp;
 char *matchString;
 int  firstpos = -1, lastpos;
 extern int _immediateInterrupt;
+_INST(lastErrorNumber) = nil;
 if (__isString(aString)) {
-matchString = (char *) _stringVal(aString);
+	matchString = (char *) _stringVal(aString);
-l = _stringSize(aString);
+	l = _stringSize(aString);
-f = MKFD(_INST(filePointer));
+	f = MKFD(_INST(filePointer));
-if ((_INST(didWrite) != false) && (_INST(mode) == _readwrite)) {
+	if ((_INST(didWrite) != false)
-_INST(didWrite) = false;
+	 && (_INST(mode) == @symbol(readwrite))) {
-fseek(f, 0L, 1); /* needed in stdio */
+	    _INST(didWrite) = false;
-}
+	    fseek(f, 0L, 1); /* needed in stdio */
+	}
-for (;;) {
-lastpos = ftell(f);
+	for (;;) {
-if (firstpos == -1) firstpos = lastpos;
+	    lastpos = ftell(f);
+	    if (firstpos == -1) firstpos = lastpos;
-_immediateInterrupt = 1;
-do {
+	    _immediateInterrupt = 1;
-cp = fgets(buffer, sizeof(buffer), f);
+	    do {
-} while ((cp == NULL) && (errno == EINTR));
+		cp = fgets(buffer, sizeof(buffer), f);
-_immediateInterrupt = 0;
+	    } while ((cp == NULL) && (errno == EINTR));
+	    _immediateInterrupt = 0;
-if (cp == NULL) {
-fseek(f, firstpos, 0);
+	    if (cp == NULL) {
-RETURN ( nil );
+		if (ferror(f)) {
-}
+		    _INST(lastErrorNumber) = _MKSMALLINT(errno);
-if (strncmp(cp, matchString, l) == 0) {
+		    goto err;
-fseek(f, lastpos, 0);
+		} else {
-break;
+		    fseek(f, firstpos, 0);
-}
+		    RETURN (nil);
-}
+		}
-/* remove EOL character */
+	    }
-cp = buffer;
+	    if (strncmp(cp, matchString, l) == 0) {
-while (*cp && (*cp != '\n')) cp++;
+		fseek(f, lastpos, 0);
-*cp = '\0';
+		break;
-RETURN ( _MKSTRING(buffer COMMA_CON) );
+	    }
-}
+	}
-%}
+	/* remove EOL character */
-.
+	cp = buffer;
-self argumentMustBeString
+	while (*cp && (*cp != '\n')) cp++;
+	*cp = '\0';
+	RETURN ( _MKSTRING(buffer COMMA_CON) );
+}
+err: ;
+%}.
+lastErrorNumber notNil ifTrue:[^ self readError].
+^ self argumentMustBeString
 !
 peekForLineStartingWithAny:aCollectionOfStrings
 "read ahead for next line starting with any of aCollectionOfStrings;
 return the index in aCollection if found, nil otherwise..
 filePointer isNil ifTrue:[^ self errorNotOpen].
 binary ifTrue:[^ self errorBinary].
 startPos := self position.
 [self atEnd] whileFalse:[
-linePos := self position.
+	linePos := self position.
-line := self nextLine.
+	line := self nextLine.
-index := 1.
+	line notNil ifTrue:[
-aCollectionOfStrings do:[:prefix |
+	    index := 1.
-(line startsWith:prefix) ifTrue:[
+	    aCollectionOfStrings do:[:prefix |
-self position:linePos.
+		(line startsWith:prefix) ifTrue:[
-^ index
+		    self position:linePos.
-].
+		    ^ index
-index := index + 1
+		].
-]
+		index := index + 1
+	    ]
+	]
 ].
 self position:startPos.
 ^ nil
 ! !
 OBJ _true = true;
 int c;
 extern int _immediateInterrupt;
 if (_INST(hitEOF) == _true) {
-RETURN (_true);
+	RETURN (_true);
 }
+_INST(lastErrorNumber) = nil;
 if ((t = _INST(filePointer)) != nil) {
-f = MKFD(t);
+	f = MKFD(t);
 #ifdef OLD
-RETURN ( feof(f) ? _true : false );
+	RETURN ( feof(f) ? _true : false );
 #else
-_immediateInterrupt = 1;
+	if ((_INST(didWrite) != false)
-c = getc(f);
+	 && (_INST(mode) == @symbol(readwrite))) {
-_immediateInterrupt = 0;
+	    _INST(didWrite) = false;
-if (c == EOF) {
+	    fseek(f, 0L, 1); /* needed in stdio */
-_INST(hitEOF) = _true;
+	}
-RETURN (_true);
-}
+	_immediateInterrupt = 1;
-ungetc(c, f);
+	c = getc(f);
-RETURN (false);
+	_immediateInterrupt = 0;
+	if (c != EOF) {
+	    ungetc(c, f);
+	    RETURN (false);
+	}
+	if (ferror(f)) {
+	    _INST(lastErrorNumber) = _MKSMALLINT(errno);
+	} else {
+	    _INST(hitEOF) = _true;
+	    RETURN (_true);
+	}
 #endif
 }
-%}
+%}.
-.
+lastErrorNumber notNil ifTrue:[^ self readError].
-self errorNotOpen
+^ self errorNotOpen
 !
 canReadWithoutBlocking
 "return true, if any data is available for reading (i.e.
 a read operation will not block the smalltalk process), false otherwise."
 |fd|
-filePointer isNil ifTrue:[
+filePointer isNil ifTrue:[^ self errorNotOpen].
-^ self errorNotOpen
+mode == #writeonly ifTrue:[^ self errorWriteOnly].
-].
-mode == #writeonly ifTrue:[
-^ self errorWriteOnly
-].
 fd := self fileDescriptor.
 ^ OperatingSystem readCheck:fd
 "
 |pipe|
 pipe := PipeStream readingFrom:'(sleep 10; echo hello)'.
 pipe canReadWithoutBlocking ifTrue:[
-Transcript showCr:'data available'
+	 Transcript showCr:'data available'
 ] ifFalse:[
-Transcript showCr:'no data available'
+	 Transcript showCr:'no data available'
 ].
 pipe close
 "
 !
 "return true, if data can be written into the stream
 (i.e. a write operation will not block the smalltalk process)."
 |fd|
-filePointer isNil ifTrue:[
+filePointer isNil ifTrue:[^ self errorNotOpen].
-^ self errorNotOpen
+mode == #readonly ifTrue:[^ self errorReadOnly].
-].
-mode == #readonly ifTrue:[
-^ self errorReadOnly
-].
 fd := self fileDescriptor.
 ^ OperatingSystem writeCheck:fd
 ! !
 Return true if data is available, false if not (i.e. a timeout occured).
 The other threads are not affected by the wait."
 |fd inputSema hasData wasBlocked|
-filePointer isNil ifTrue:[
+filePointer isNil ifTrue:[^ self errorNotOpen].
-^ self errorNotOpen
+mode == #writeonly ifTrue:[^ self errorWriteOnly].
-].
-mode == #writeonly ifTrue:[
-^ self errorWriteOnly
-].
 fd := self fileDescriptor.
 (OperatingSystem readCheck:fd) ifTrue:[^ true].
 wasBlocked := OperatingSystem blockInterrupts.
 hasData := OperatingSystem readCheck:fd.
 hasData ifFalse:[
-inputSema := Semaphore new.
+	inputSema := Semaphore new.
-timeout notNil ifTrue:[
+	timeout notNil ifTrue:[
-Processor signal:inputSema afterSeconds:timeout
+	    Processor signal:inputSema afterSeconds:timeout
-].
+	].
-Processor signal:inputSema onInput:fd.
+	Processor signal:inputSema onInput:fd.
-Processor activeProcess state:#ioWait.
+	Processor activeProcess state:#ioWait.
-inputSema wait.
+	inputSema wait.
-Processor disableSemaphore:inputSema.
+	Processor disableSemaphore:inputSema.
-hasData := OperatingSystem readCheck:fd
+	hasData := OperatingSystem readCheck:fd
 ].
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 ^ hasData
 !
 The other threads are not affected by the wait."
 |fd outputSema canWrite wasBlocked|
 filePointer isNil ifTrue:[
-^ self errorNotOpen
+	^ self errorNotOpen
 ].
 mode == #readonly ifTrue:[
-^ self errorReadOnly
+	^ self errorReadOnly
 ].
 fd := self fileDescriptor.
 (OperatingSystem writeCheck:fd) ifTrue:[^ true].
 wasBlocked := OperatingSystem blockInterrupts.
 canWrite := OperatingSystem writeCheck:fd.
 canWrite ifFalse:[
-outputSema := Semaphore new.
+	outputSema := Semaphore new.
-timeout notNil ifTrue:[
+	timeout notNil ifTrue:[
-Processor signal:outputSema afterSeconds:timeout
+	    Processor signal:outputSema afterSeconds:timeout
-].
+	].
-Processor signal:outputSema onOutput:fd.
+	Processor signal:outputSema onOutput:fd.
-Processor activeProcess state:#ioWait.
+	Processor activeProcess state:#ioWait.
-outputSema wait.
+	outputSema wait.
-Processor disableSemaphore:outputSema.
+	Processor disableSemaphore:outputSema.
-canWrite := OperatingSystem writeCheck:fd
+	canWrite := OperatingSystem writeCheck:fd
 ].
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 ^ canWrite
 ! !
 !ExternalStream methodsFor:'reimplemented for speed'!
 peekFor:anObject
-"return true and move past if next == something.
+"return true and move past next element, if next == something.
-Otherwise, stay and return false."
+Otherwise, stay and return false. False is also returned
+when EOF is encountered."
 %{  /* NOCONTEXT */
 FILE *f;
 int c;
 int peekValue;
 extern int _immediateInterrupt;
-if (_INST(filePointer) != nil) {
+_INST(lastErrorNumber) = nil;
-if (_INST(binary) == true) {
+if ((_INST(filePointer) != nil)
-if (_isSmallInteger(anObject)) {
+&& (_INST(mode) != @symbol(writeonly))) {
-peekValue = _intVal(anObject) & 0xFF;
+	if (_INST(binary) == true) {
-} else {
+	    if (_isSmallInteger(anObject)) {
-goto bad;
+		peekValue = _intVal(anObject) & 0xFF;
-}
+	    } else {
-} else {
+		goto bad;
-if (__isCharacter(anObject)) {
+	    }
-peekValue = _intVal(_characterVal(anObject)) & 0xFF;
+	} else {
-} else {
+	    if (__isCharacter(anObject)) {
-goto bad;
+		peekValue = _intVal(_characterVal(anObject)) & 0xFF;
-}
+	    } else {
-}
+		goto bad;
+	    }
-f = MKFD(_INST(filePointer));
+	}
-_immediateInterrupt = 1;
-c = getc(f);
+	if ((_INST(didWrite) != false)
-_immediateInterrupt = 0;
+	 && (_INST(mode) == @symbol(readwrite))) {
+	    _INST(didWrite) = false;
-if (c == peekValue) {
+	    fseek(f, 0L, 1); /* needed in stdio */
-OBJ pos;
+	}
-if ((pos = _INST(position)) != nil) {
+	f = MKFD(_INST(filePointer));
-_INST(position) = _MKSMALLINT(_intVal(pos) + 1);
+	_immediateInterrupt = 1;
-}
+	c = getc(f);
-RETURN ( true );
+	_immediateInterrupt = 0;
-}
+	if (c == peekValue) {
-if (c == EOF) {
+	    OBJ pos;
-_INST(hitEOF) = true;
-} else {
+	    if ((pos = _INST(position)) != nil) {
-ungetc(c, f);
+		_INST(position) = _MKSMALLINT(_intVal(pos) + 1);
-}
+	    }
-RETURN ( false );
+	    RETURN (true);
+	}
+	if (c != EOF) {
+	    ungetc(c, f);
+	    RETURN (false);
+	}
+	if (ferror(f)) {
+	    _INST(lastErrorNumber) = _MKSMALLINT(errno);
+	} else {
+	    _INST(hitEOF) = true;
+	    RETURN (false);
+	}
 }
 bad: ;
-%}
+%}.
-.
+mode == #writeonly ifTrue:[^ self errorWriteOnly].
+lastErrorNumber notNil iftrue:[^ self readError].
 filePointer isNil ifTrue:[^ self errorNotOpen].
 ^ super peekFor:anObject
 !
 nextMatchFor:anObject
 FILE *f;
 int peekValue, c;
 extern int _immediateInterrupt;
-if ((_INST(binary) == true) && _isSmallInteger(anObject)) {
+_INST(lastErrorNumber) = nil;
-peekValue = _intVal(anObject) & 0xFF;
+if ((_INST(filePointer) != nil)
-} else {
+&& (_INST(mode) != @symbol(writeonly))) {
-if ((_INST(binary) != true) && __isCharacter(anObject)) {
+	if ((_INST(binary) == true) && _isSmallInteger(anObject)) {
-peekValue = _intVal(_characterVal(anObject)) & 0xFF;
+	    peekValue = _intVal(anObject) & 0xFF;
-} else
+	} else {
-peekValue = -1;
+	    if ((_INST(binary) != true) && __isCharacter(anObject)) {
-}
+		peekValue = _intVal(_characterVal(anObject)) & 0xFF;
+	    } else {
-if (peekValue >= 0) {
+		peekValue = -1;
-if (_INST(filePointer) != nil) {
+	    }
-if (_INST(mode) != _writeonly) {
+	}
-f = MKFD(_INST(filePointer));
-_immediateInterrupt = 1;
+	if (peekValue >= 0) {
-_INST(position) = nil;
+	    f = MKFD(_INST(filePointer));
+	    _immediateInterrupt = 1;
-if ((_INST(didWrite) != false) && (_INST(mode) == _readwrite)) {
+	    _INST(position) = nil;
-_INST(didWrite) = false;
-fseek(f, 0L, 1); /* needed in stdio */
+	    if ((_INST(didWrite) != false)
-}
+	     && (_INST(mode) == @symbol(readwrite))) {
+		_INST(didWrite) = false;
-for (;;) {
+		fseek(f, 0L, 1); /* needed in stdio */
-c = getc(f);
+	    }
-if (c == EOF) {
-_INST(hitEOF) = true;
+	    for (;;) {
-_immediateInterrupt = 0;
+		c = getc(f);
-RETURN (nil);
+		if (c == EOF) {
-}
+		    _immediateInterrupt = 0;
-if (c == peekValue) {
+		    if (ferror(f)) {
-_immediateInterrupt = 0;
+			_INST(lastErrorNumber) = _MKSMALLINT(errno);
-RETURN (anObject);
+			break;
-}
+		    }
-}
+		    _INST(hitEOF) = true;
-_immediateInterrupt = 0;
+		    RETURN (nil);
-}
+		}
-}
+		if (c == peekValue) {
-}
+		    _immediateInterrupt = 0;
-%}
+		    RETURN (anObject);
-.
+		}
+	    }
+	    _immediateInterrupt = 0;
+	}
+}
+%}.
+lastErrorNumber notNil iftrue:[^ self readError].
 filePointer isNil ifTrue:[^ self errorNotOpen].
 ^ super nextMatchFor:anObject
 !
 skipLine
 FILE *f;
 char buffer[1024];
 extern int _immediateInterrupt;
-if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
+_INST(lastErrorNumber) = nil;
-if (_INST(binary) != true) {
+if ((_INST(filePointer) != nil)
-f = MKFD(_INST(filePointer));
+&& (_INST(mode) != @symbol(writeonly))) {
+	if (_INST(binary) != true) {
+	    f = MKFD(_INST(filePointer));
-if ((_INST(didWrite) != false) && (_INST(mode) == _readwrite)) {
+	    if ((_INST(didWrite) != false)
-_INST(didWrite) = false;
+	     && (_INST(mode) == @symbol(readwrite))) {
-fseek(f, 0L, 1); /* needed in stdio */
+		_INST(didWrite) = false;
-}
+		fseek(f, 0L, 1); /* needed in stdio */
+	    }
-_immediateInterrupt = 1;
-if (fgets(buffer, sizeof(buffer), f) != NULL) {
+	    _immediateInterrupt = 1;
-_immediateInterrupt = 0;
+	    if (fgets(buffer, sizeof(buffer), f) != NULL) {
-RETURN ( self );
+		_immediateInterrupt = 0;
-}
+		RETURN ( self );
-_INST(hitEOF) = true;
+	    }
-_immediateInterrupt = 0;
+	    _immediateInterrupt = 0;
-RETURN ( nil );
+	    if (ferror(f)) {
-}
+		_INST(lastErrorNumber) = _MKSMALLINT(errno);
-}
+	    } else {
-%}
+		_INST(hitEOF) = true;
-.
+		RETURN ( nil );
+	    }
+	}
+}
+%}.
+lastErrorNumber notNil iftrue:[^ self readError].
 filePointer isNil ifTrue:[^ self errorNotOpen].
 binary ifTrue:[^ self errorBinary].
-self errorWriteOnly
+^ self errorWriteOnly
 !
 skipThroughAll:aString
 "search & skip for the sequence given by the argument, aCollection;
 return nil if not found, self otherwise. If successfull, the next read
 will return the character after the searchstring."
 |buffer len first|
 (aString isString and:[binary not]) ifTrue:[
-len := aString size.
+	len := aString size.
-first := aString at:1.
+	first := aString at:1.
-buffer := String new:len.
+	buffer := String new:len.
-buffer at:1 put:first.
+	buffer at:1 put:first.
-len := len - 1.
+	len := len - 1.
-[true] whileTrue:[
+	[true] whileTrue:[
-(self skipThrough:first) isNil ifTrue:[
+	    (self skipThrough:first) isNil ifTrue:[
-^ nil.
+		^ nil.
-].
+	    ].
-(self nextBytes:len into:buffer startingAt:2) == len ifFalse:[
+	    (self nextBytes:len into:buffer startingAt:2) == len ifFalse:[
-^ nil
+		^ nil
-].
+	    ].
-buffer = aString ifTrue:[
+	    buffer = aString ifTrue:[
-"
+		"
-position back, before string
+		 position back, before string
-"
+		"
-^ self
+		^ self
-].
+	    ].
-].
+	].
-"NOT REACHED"
+	"NOT REACHED"
 ].
 ^ super skipThroughAll:aString
 "
 |s|
 |oldPos|
 oldPos := self position.
 (self skipThroughAll:aString) isNil ifTrue:[
-"
+	"
-restore position
+	 restore position
-"
+	"
-self position:oldPos.
+	self position:oldPos.
-^ nil
+	^ nil
 ].
 "
 position before match-string
 "
 self position:(self position - aString size).
 FILE *f;
 REGISTER int c, cSearch;
 extern int _immediateInterrupt;
-if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
+_INST(lastErrorNumber) = nil;
-if (_INST(binary) == true) {
+if ((_INST(filePointer) != nil)
-/* searched for object must be a smallInteger */
+&& (_INST(mode) != @symbol(writeonly))) {
-if (! _isSmallInteger(aCharacter)) goto badArgument;
+	if (_INST(binary) == true) {
-cSearch = _intVal(aCharacter);
+	    /* searched for object must be a smallInteger */
-} else {
+	    if (! _isSmallInteger(aCharacter)) goto badArgument;
-/* searched for object must be a character */
+	    cSearch = _intVal(aCharacter);
-if (! __isCharacter(aCharacter)) goto badArgument;
+	} else {
-cSearch = _intVal(_characterVal(aCharacter));
+	    /* searched for object must be a character */
-}
+	    if (! __isCharacter(aCharacter)) goto badArgument;
-/* Q: should we just say: "not found" ? */
+	    cSearch = _intVal(_characterVal(aCharacter));
-if ((cSearch < 0) || (cSearch > 255)) goto badArgument;
+	}
+	/* Q: should we just say: "not found" ? */
-f = MKFD(_INST(filePointer));
+	if ((cSearch < 0) || (cSearch > 255)) goto badArgument;
+	f = MKFD(_INST(filePointer));
-if ((_INST(didWrite) != false) && (_INST(mode) == _readwrite)) {
+	if ((_INST(didWrite) != false)
-_INST(didWrite) = false;
+	 && (_INST(mode) == @symbol(readwrite))) {
-fseek(f, 0L, 1); /* needed in stdio */
+	    _INST(didWrite) = false;
-}
+	    fseek(f, 0L, 1); /* needed in stdio */
+	}
-_immediateInterrupt = 1;
-while (1) {
+	_immediateInterrupt = 1;
-if (feof(f)) {
+	while (1) {
-_immediateInterrupt = 0;
+#ifdef NOTNEEDED
-RETURN ( nil );
+	    if (feof(f)) {
-}
+		_immediateInterrupt = 0;
+		RETURN ( nil );
-c = getc(f);
+	    }
+#endif
-if (c < 0) {
+	    c = getc(f);
-_immediateInterrupt = 0;
-_INST(hitEOF) = true;
+	    if (c == cSearch) {
-RETURN (nil);
+		_immediateInterrupt = 0;
-}
+		RETURN (self);
-if (c == cSearch) {
+	    }
-_immediateInterrupt = 0;
+	    if (c < 0) {
-RETURN (self);
+		_immediateInterrupt = 0;
-}
+		if (ferror(f)) {
-}
+		    _INST(lastErrorNumber) = _MKSMALLINT(errno);
+		    break;
+		} else {
+		    _INST(hitEOF) = true;
+		    RETURN (nil);
+		}
+	    }
+	}
 }
 badArgument: ;
-%}
+%}.
-.
+lastErrorNumber notNil iftrue:[^ self readError].
 filePointer isNil ifTrue:[^ self errorNotOpen].
 (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
 "
 argument must be integer/character in binary mode,
 character in text mode
 FILE *f;
 REGISTER int c;
 extern int _immediateInterrupt;
-if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
+_INST(lastErrorNumber) = nil;
-if (_INST(binary) != true) {
+if ((_INST(filePointer) != nil)
-f = MKFD(_INST(filePointer));
+&& (_INST(mode) != @symbol(writeonly))) {
+	if (_INST(binary) != true) {
+	    f = MKFD(_INST(filePointer));
-if ((_INST(didWrite) != false) && (_INST(mode) == _readwrite)) {
+	    if ((_INST(didWrite) != false) && (_INST(mode) == _readwrite)) {
-_INST(didWrite) = false;
+		_INST(didWrite) = false;
-fseek(f, 0L, 1); /* needed in stdio */
+		fseek(f, 0L, 1); /* needed in stdio */
-}
+	    }
-_immediateInterrupt = 1;
+	    _immediateInterrupt = 1;
-while (1) {
+	    while (1) {
-if (feof(f)) {
+		if (feof(f)) {
-_immediateInterrupt = 0;
+		    _immediateInterrupt = 0;
-RETURN ( nil );
+		    RETURN ( nil );
-}
+		}
-c = getc(f);
+		c = getc(f);
-switch (c) {
+		switch (c) {
-case ' ':
+		    case ' ':
-case '\t':
+		    case '\t':
-case '\n':
+		    case '\n':
-case '\r':
+		    case '\r':
-case '\b':
+		    case '\b':
-case '\014':
+		    case '\014':
-break;
+			break;
-default:
+		    default:
-if (c < 0) {
+			_immediateInterrupt = 0;
-_INST(hitEOF) = true;
+			if (c < 0) {
-_immediateInterrupt = 0;
+			    if (ferror(f)) {
-RETURN ( nil );
+				_INST(lastErrorNumber) = _MKSMALLINT(errno);
-}
+				goto err;
-ungetc(c, f);
+			    }
-_immediateInterrupt = 0;
+			    _INST(hitEOF) = true;
-RETURN ( _MKCHARACTER(c & 0xFF) );
+			    RETURN ( nil );
-}
+			}
-}
+			ungetc(c, f);
-}
+			RETURN ( _MKCHARACTER(c & 0xFF) );
-}
+		}
-%}
+	    }
-.
+	}
+}
+err: ;
+%}.
+lastErrorNumber notNil iftrue:[^ self readError].
 filePointer isNil ifTrue:[^ self errorNotOpen].
 (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
 ^ self errorBinary.
 !
 FILE *f;
 int c;
 extern int _immediateInterrupt;
-if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
+_INST(lastErrorNumber) = nil;
-if (_INST(binary) != true) {
+if ((_INST(filePointer) != nil)
-f = MKFD(_INST(filePointer));
+&& (_INST(mode) != @symbol(writeonly))) {
+	if (_INST(binary) != true) {
-if ((_INST(didWrite) != false) && (_INST(mode) == _readwrite)) {
+	    f = MKFD(_INST(filePointer));
-_INST(didWrite) = false;
-fseek(f, 0L, 1); /* needed in stdio */
+	    if ((_INST(didWrite) != false)
-}
+	     && (_INST(mode) == @symbol(readwrite))) {
+		_INST(didWrite) = false;
-_immediateInterrupt = 1;
+		fseek(f, 0L, 1); /* needed in stdio */
-while (1) {
+	    }
+	    _immediateInterrupt = 1;
+	    while (1) {
-if (feof(f)) {
+		if (feof(f)) {
-_immediateInterrupt = 0;
+		    _immediateInterrupt = 0;
-RETURN ( nil );
+		    RETURN ( nil );
-}
+		}
-c = getc(f);
+		c = getc(f);
-switch (c) {
+		switch (c) {
-case ' ':
+		    case ' ':
-case '\t':
+		    case '\t':
-case '\b':
+		    case '\b':
-break;
+			break;
-default:
+		    default:
-if (c < 0) {
+			_immediateInterrupt = 0;
-_INST(hitEOF) = true;
+			if (c < 0) {
-_immediateInterrupt = 0;
+			    if (ferror(f)) {
-RETURN ( nil );
+				_INST(lastErrorNumber) = _MKSMALLINT(errno);
-}
+				goto err;
-ungetc(c, f);
+			    }
-_immediateInterrupt = 0;
+			    _INST(hitEOF) = true;
-RETURN ( _MKCHARACTER(c & 0xFF) );
+			    RETURN ( nil );
-}
+			}
-}
+			ungetc(c, f);
-}
+			RETURN ( _MKCHARACTER(c & 0xFF) );
-}
+		}
-%}
+	    }
-.
+	}
+}
+err: ;
+%}.
+lastErrorNumber notNil iftrue:[^ self readError].
 filePointer isNil ifTrue:[^ self errorNotOpen].
 (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
-self errorBinary
+^ self errorBinary
+!
+nextAlphaNumericWord
+"read the next word (i.e. up to non letter-or-digit).
+return a string containing those characters."
+%{  /* STACK: 2000 */
+FILE *f;
+int len;
+char buffer[1024];
+int ch;
+int cnt = 0;
+extern int _immediateInterrupt;
+if ((_INST(filePointer) != nil)
+&& (_INST(mode) != @symbol(writeonly))) {
+	f = MKFD(_INST(filePointer));
+	_immediateInterrupt = 1;
+	if ((_INST(didWrite) != false)
+	 && (_INST(mode) == @symbol(readwrite))) {
+	    _INST(didWrite) = false;
+	    fseek(f, 0L, 1); /* needed in stdio */
+	}
+	for (;;) {
+	    ch = getc(f);
+	    if (ch < 0) {
+		if (ferror(f)) {
+		    _INST(lastErrorNumber) = _MKSMALLINT(errno);
+		    goto err;
+		}
+		_INST(hitEOF) = true;
+		break;
+	    }
+	    cnt++;
+	    if (ch >= ' ') break;
+	    if ((ch != ' ') && (ch != '\t') && (ch != '\r')
+	     && (ch != '\n') && (ch != 0x0b)) break;
+	}
+	ungetc(ch, f);
+	cnt--;
+	len = 0;
+	for (;;) {
+	    ch = getc(f);
+	    if (ch < 0) {
+		if (ferror(f)) {
+		    _INST(lastErrorNumber) = _MKSMALLINT(errno);
+		    goto err;
+		}
+		_INST(hitEOF) = true;
+		break;
+	    }
+	    ch &= 0xFF;
+	    if (! (((ch >= 'a') && (ch <= 'z')) ||
+		   ((ch >= 'A') && (ch <= 'Z')) ||
+		   ((ch >= '0') && (ch <= '9')))) {
+		ungetc(ch, f);
+		break;
+	    }
+	    cnt++;
+	    buffer[len++] = ch;
+	    if (len >= sizeof(buffer)-1) {
+		/* emergency */
+		break;
+	    }
+	}
+	_immediateInterrupt = 0;
+	if (_INST(position) != nil) {
+	    _INST(position) = _MKSMALLINT(_intVal(_INST(position)) + cnt);
+	}
+	buffer[len] = '\0';
+	if (len != 0) {
+	    RETURN ( _MKSTRING(buffer COMMA_CON) );
+	}
+	RETURN ( nil );
+}
+err: ;
+%}.
+lastErrorNumber notNil ifTrue:[^ self readError].
+filePointer isNil ifTrue:[^ self errorNotOpen].
+^ self errorWriteOnly
 !
 nextChunk
 "return the next chunk, i.e. all characters up to the next
 non-doubled exclamation mark; undouble doubled exclamation marks.
 - reimplemented for speed"
 |retVal|
-filePointer isNil ifTrue:[
+filePointer isNil ifTrue:[^ self errorNotOpen].
-^ self errorNotOpen
+binary ifTrue:[^ self errorBinary].
-].
+(mode == #writeonly) ifTrue:[^ self errorWriteOnly].
-binary ifTrue:[
-^ self errorBinary
-].
 %{
 FILE *f;
 int done = 0;
 REGISTER int c;
 unsigned char peekC;
-char *buffer, *newBuffer;
+char *buffer = (char *)0, *newBuffer;
 REGISTER int index;
 int currSize;
 int inComment, inString, inPrimitive = 0;
 extern int _immediateInterrupt;
+_INST(lastErrorNumber) = nil;
 f = MKFD(_INST(filePointer));
-if ((_INST(didWrite) != false) && (_INST(mode) == _readwrite)) {
+if ((_INST(didWrite) != false)
-_INST(didWrite) = false;
+&& (_INST(mode) == @symbol(readwrite))) {
-fseek(f, 0L, 1); /* needed in stdio */
+	_INST(didWrite) = false;
+	fseek(f, 0L, 1); /* needed in stdio */
+}
+if (feof(f)) {
+	_immediateInterrupt = 0;
+	RETURN (nil);
 }
 /*
 * skip spaces
 */
 _immediateInterrupt = 1;
 while (! done) {
-if (feof(f)) {
-_immediateInterrupt = 0;
+	do {
-RETURN ( nil );
+	    c = getc(f);
-}
+	} while ((c < 0) && (errno == EINTR));
-do {
+	switch (c) {
-c = getc(f);
+	    case ' ':
-} while ((c < 0) && (errno == EINTR));
+	    case '\t':
+	    case '\n':
-switch (c) {
+	    case '\r':
-case ' ':
+	    case '\b':
-case '\t':
+	    case '\014':
-case '\n':
+		break;
-case '\r':
-case '\b':
+	    case EOF:
-case '\014':
+		_immediateInterrupt = 0;
-break;
+		if (ferror(f)) {
+		    _INST(lastErrorNumber) = _MKSMALLINT(errno);
-case EOF:
+		    goto err;
-_immediateInterrupt = 0;
+		}
-_INST(hitEOF) = true;
+		_INST(hitEOF) = true;
-RETURN ( nil );
+		RETURN (nil);
-default:
+	    default:
-ungetc(c, f);
+		ungetc(c, f);
-done = 1;
+		done = 1;
-break;
+		break;
-}
+	}
 }
 /*
 * read chunk into a buffer
 */
 buffer = (char *)malloc(3000);
 currSize = 3000;
 index = 0;
 while (! feof(f)) {
-/* do we have to resize the buffer ? */
+	/* do we have to resize the buffer ? */
-if ((index+2) >= currSize) {
+	if ((index+2) >= currSize) {
-newBuffer = (char *)malloc(currSize * 2);
+	    newBuffer = (char *)malloc(currSize * 2);
-bcopy(buffer, newBuffer, index);
+	    bcopy(buffer, newBuffer, index);
-free(buffer);
+	    free(buffer);
-buffer = newBuffer;
+	    buffer = newBuffer;
-currSize = currSize * 2;
+	    currSize = currSize * 2;
-}
+	}
-do {
+	do {
-c = getc(f);
+	    c = getc(f);
-} while (c < 0 && (errno == EINTR));
+	} while (c < 0 && (errno == EINTR));
-if (c == '%') {
+	if (c == '%') {
-peekC = getc(f);
+	    peekC = getc(f);
-ungetc(peekC, f);
+	    ungetc(peekC, f);
-if (peekC == '{') {
+	    if (peekC == '{') {
-inPrimitive++;
+		inPrimitive++;
-} else if (peekC == '}') {
+	    } else if (peekC == '}') {
-inPrimitive--;
+		inPrimitive--;
-}
+	    }
-} else {
+	} else {
-if (! inPrimitive) {
+	    if (! inPrimitive) {
-if (c == '!') {
+		if (c == '!') {
-do {
+		    do {
-c = getc(f);
+			c = getc(f);
-} while (c < 0 && (errno == EINTR));
+		    } while (c < 0 && (errno == EINTR));
-if (c != '!') {
+		    if (c != '!') {
-ungetc(c, f);
+			ungetc(c, f);
-break;
+			break;
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
-if (c == EOF) {
-_INST(hitEOF) = true;
+	if (c < 0) {
-break;
+	    _immediateInterrupt = 0;
-}
+	    if (ferror(f)) {
-buffer[index++] = c;
+		_INST(lastErrorNumber) = _MKSMALLINT(errno);
+		goto err;
+	    }
+	    _INST(hitEOF) = true;
+	    break;
+	}
+	buffer[index++] = c;
 }
 _immediateInterrupt = 0;
 buffer[index] = '\0';
 /*
 * make it a string
 */
 retVal = _MKSTRING(buffer COMMA_CON);
-free(buffer);
+err:
-%}
+if (buffer)
-.
+	free(buffer);
+%}.
+lastErrorNumber notNil ifTrue:[^ self readError].
 ^ retVal
 ! !

changeset 159	514c749165c3
parent 108	634ca035d22c
child 188	454ed0ee733e