hg/stx-libbasic: comparison ExternalStream.st

equal deleted inserted replaced

-:e08c79499faa
+:1efe4d36fd3f
 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.
 "
+'From Smalltalk/X, Version:6.2.3.0 on 18-04-2014 at 00:36:23'                   !
 "{ Package: 'stx:libbasic' }"
 ReadWriteStream subclass:#ExternalStream
 	instanceVariableNames:'handleType handle mode buffered binary eolMode hitEOF didWrite
 		lastErrorNumber readAhead'
 #else
 # define OPT_FSEEK(f, pos, whence)      /* nothing */
 #endif
 #ifdef WIN32
-# ifdef __BORLANDC__
+#  define READ(ret, f, cp, n, handleType) { \
-int _rtl_read();
+if (handleType == @symbol(socketHandle)) { \
-int _rtl_write();
+(ret) = __STX_WSA_NOINT_CALL4("recv", recv, (f), (cp), (n), 0); \
-#  define READ(ret,f, cp, n, handleType) \
-{ int __res;\
-HANDLE h; \
-h = _get_osfhandle(fileno(f)); \
-if ((handleType == @symbol(socketFilePointer)) \
-|| ((handleType == nil) && (ioctlsocket((SOCKET)h,FIONREAD,&__res)==0))) { \
-(ret) = __STX_WSA_NOINT_CALL4("recv", recv, h, (cp), (n), 0);\
 } else { \
-(ret) = __STX_C_NOINT_CALL3("_rtl_read", _rtl_read, fileno(f), (cp), (n));\
+HANDLE h = _get_osfhandle(fileno(f)); \
-} \
+if (handleType == @symbol(socketFilePointer)) { \
-}
-#  define WRITE(ret,f, cp, n, handleType) \
-{ int __res;\
-HANDLE h; \
-h = _get_osfhandle(fileno(f)); \
-if ((handleType == @symbol(socketFilePointer)) \
-|| ((handleType == nil) && (ioctlsocket((SOCKET)h,FIONREAD,&__res)==0))) { \
-(ret) = __STX_WSA_NOINT_CALL4("send", send, h, (cp), (n), 0);\
-} else { \
-(ret) = __STX_C_NOINT_CALL3("_rtl_write", _rtl_write, fileno(f), (cp), (n));\
-} \
-}
-# else /* MSC */
-#  define READ(ret,f, cp, n, handleType) \
-{ int __res;\
-int fd; \
-HANDLE h; \
-fd = fileno(f); \
-if ((handleType == @symbol(socketFileDescriptor)) \
-|| ((handleType == nil) && (ioctlsocket((SOCKET)fd,FIONREAD,&__res)==0))) { \
-(ret) = __STX_WSA_NOINT_CALL4("recv", recv, fd, (cp), (n), 0);\
-} else { \
-h = _get_osfhandle(fd); \
-if ((handleType == @symbol(socketFilePointer)) \
-|| ((handleType == nil) && (ioctlsocket((SOCKET)h,FIONREAD,&__res)==0))) { \
 (ret) = __STX_WSA_NOINT_CALL4("recv", recv, h, (cp), (n), 0);\
 } else { \
+int __res; \
 (ret) = __STX_API_NOINT_CALL5("ReadFile", ReadFile, h, (cp), (n), &__res, 0);\
-if (ret) \
+(ret) = (ret) ? __res : -1; \
-ret = __res; \
 } \
 } \
 }
-#  define WRITE(ret,f, cp, n, handleType) \
-{ int __res;\
+#  define WRITE(ret, f, cp, n, handleType) { \
-int fd; \
+if (handleType == @symbol(socketHandle)) { \
-HANDLE h; \
+(ret) = __STX_WSA_NOINT_CALL4("send", send, (f), (cp), (n), 0); \
-fd = fileno(f); \
-if ((handleType == @symbol(socketFileDescriptor)) \
-|| ((handleType == nil) && (ioctlsocket((SOCKET)fd,FIONREAD,&__res)==0))) { \
-(ret) = __STX_WSA_NOINT_CALL4("send", send, fd, (cp), (n), 0);\
 } else {\
-h = _get_osfhandle(fd); \
+HANDLE h = _get_osfhandle(fileno(f)); \
-if ((handleType == @symbol(socketFilePointer)) \
+if (handleType == @symbol(socketFilePointer)) { \
-|| ((handleType == nil) && (ioctlsocket((SOCKET)h,FIONREAD,&__res)==0))) { \
 (ret) = __STX_WSA_NOINT_CALL4("send", send, h, (cp), (n), 0);\
 } else {\
+int __res; \
 (ret) = __STX_API_NOINT_CALL5("WriteFile", WriteFile, h, (cp), (n), &__res, 0);\
-if (ret) \
+(ret) = (ret) ? __res : -1; \
-ret = __res; \
 } \
 } \
 }
-# endif /* MSC */
 # define FFLUSH(fp)             fflush(fp)
 # undef STDIO_NEEDS_FSEEK
 # define FILEPOINTER            FILE *
 # define FILENO(f)              fileno(f)
 # define __UNGETC__(c, f, isBuffered)                   \
 if (isBuffered) {                                   \
 ungetc((c), (f));                               \
 } else {                                            \
-__INST(readAhead) = __mkSmallInteger((c));            \
+__INST(readAhead) = __mkSmallInteger((c));        \
 }
-# define __READBYTE__(ret, f, buf, isBuffered, handleType)          \
+# define __READBYTE__(ret, f, buf, isBuffered, handleType) \
 if (isBuffered) {                                   \
 for (;;) {                                      \
 CLEAR_ERRNO;                                \
 (ret) = getc(f);                            \
 if ((ret) >= 0) {                           \
 __INST(readAhead) = nil;                    \
 (ret) = 1;                                  \
 } else {                                        \
 for (;;) {                                  \
 CLEAR_ERRNO;                            \
-READ(ret,f, buf, 1, handleType);                    \
+READ(ret, f, buf, 1, handleType);       \
-if ((ret) >= 0 || __threadErrno != EINTR)       \
+if ((ret) >= 0 || __threadErrno != EINTR) \
 break;                              \
 }                                           \
 }                                               \
 }
 while (__offs < (cnt)) {                        \
 CLEAR_ERRNO;                                \
 (ret) = getc(f);                            \
 if ((ret) < 0) {                            \
 if (ferror(f)) {                        \
-if (__threadErrno == EINTR) {               \
+if (__threadErrno == EINTR) {       \
 clearerr(f);                    \
 continue;                       \
 }                                   \
 } else {                                \
 (ret) = 0;                          \
 (buf)[__offs] = __intVal(rA);           \
 __INST(readAhead) = nil;                \
 (ret) = 1;                              \
 } else {                                    \
 CLEAR_ERRNO;                            \
-READ(ret,f, (buf)+__offs, (cnt)-__offs, handleType); \
+READ(ret, f, (buf)+__offs, (cnt)-__offs, handleType); \
 if ((ret) <= 0) {                       \
 if ((ret) < 0 && __threadErrno == EINTR) {  \
 continue;                       \
 }                                   \
 break;                              \
 while (__offs < (cnt)) {                        \
 CLEAR_ERRNO;                                \
 (ret) = getc(f);                            \
 if ((ret) < 0) {                            \
 if (ferror(f)) {                        \
-if (__threadErrno == EINTR) {               \
+if (__threadErrno == EINTR) {       \
 clearerr(f);                    \
 continue;                       \
 }                                   \
 } else {                                \
 (ret) = 0;                          \
 OBJ rA = __INST(readAhead);                 \
 if (rA != nil) {                            \
 (buf)[__offs] = __intVal(rA);           \
 __INST(readAhead) = nil;                \
 (ret) = 1;                              \
-__offs += (ret);                        \
+__offs ++;                              \
 continue;                               \
 }                                           \
 CLEAR_ERRNO;                                \
 {                                           \
-int res;                                  \
+int res = 0;                              \
-if ((handleType == @symbol(socketFilePointer)) \
+if ((handleType == @symbol(socketFilePointer) && (ioctlsocket((SOCKET)_get_osfhandle(fileno(f)),FIONREAD,&res), 1)) \
-|| ((handleType == nil) && (ioctlsocket((SOCKET)_get_osfhandle(fileno(f)),FIONREAD,&res)==0))) { \
+|| (handleType == @symbol(socketHandle) && (ioctlsocket((SOCKET)(f), FIONREAD, &res), 1)) \
+|| (handleType == @symbol(pipeFilePointer) && (PeekNamedPipe((HANDLE)_get_osfhandle(fileno(f)),0, 0,0,&res,0)), 1)) { \
 if (res > 0) {                        \
 if (res > ((cnt)-__offs))         \
-res = (cnt)-__offs;             \
+res = (cnt)-__offs;           \
-READ(ret,f, (buf)+__offs, res, handleType);   \
+READ(ret, f, (buf)+__offs, res, handleType); \
 } else {                              \
 (ret) = 0;                        \
+break;                            \
 }                                     \
-} else if ((handleType == @symbol(pipeFilePointer)) \
-|| ((handleType == nil) && (PeekNamedPipe((HANDLE)_get_osfhandle(fileno(f)),0, 0,0,&res,0)))) { \
-if (res > 0) {                        \
-if (res > ((cnt)-__offs))         \
-res = (cnt)-__offs;             \
-READ(ret,f, (buf)+__offs, res, handleType);   \
-} else                                \
-ret = 0;                          \
 } else {                                  \
-READ(ret,f, (buf)+__offs, (cnt)-__offs, handleType); \
+READ(ret, f, (buf)+__offs, (cnt)-__offs, handleType); \
 }                                         \
 }                                           \
-if ((ret) < 0) {                            \
+if ((ret) < 0 && __threadErrno == EINTR)    \
-if (__threadErrno == EINTR) {                   \
+continue;                               \
-continue;                           \
-}                                       \
-break;                                  \
-}                                           \
 __offs += (ret);                            \
-break;                                      \
 }                                               \
 if (__offs > 0)                                 \
 (ret) = __offs;                             \
 }                                                   \
 }
 continue;                       \
 }                                   \
 break;                              \
 }                                       \
 }                                           \
-if( (ret) > 0 ) {                               \
+if ((ret) > 0 ) {                           \
 /* refetch */                               \
 buf = (char *)(obj);               \
 memcpy((buf)+__ooffs+__offs,__buf,(ret));   \
 __offs += (ret);                            \
 } else {                                        \
 if (__offs > 0)                                 \
 (ret) = __offs;                             \
 }                                                   \
 }
-# define __READAVAILBYTES_OBJ__(ret, f, obj, obj_offs, cnt, isBuffered, handleType)\
+# define __READAVAILBYTES_OBJ__(ret, f, obj, obj_offs, cnt, isBuffered, handleType) \
 {                                                  \
 int __ooffs = obj_offs;                          \
 int __offs = 0;                                  \
 char *buf = (char *)(obj);                       \
 \
 OBJ rA = __INST(readAhead);              \
 if (rA != nil) {                         \
 (buf)[__ooffs+__offs] = __intVal(rA);\
 __INST(readAhead) = nil;             \
 (ret) = 1;                           \
-__offs += (ret);                     \
+__offs++;                            \
 continue;                            \
 }                                        \
 {                                        \
-int l;                               \
+int res = 0;                         \
-int res;                             \
+int l = (cnt)-__offs;                \
 CLEAR_ERRNO;                         \
-l = (cnt)-__offs;                    \
+if (l > IO_BUFFER_SIZE)              \
-if ( l > IO_BUFFER_SIZE)             \
 l = IO_BUFFER_SIZE;              \
-if (ioctlsocket((SOCKET)_get_osfhandle(fileno(f)),FIONREAD,&res)==0) { \
+if ((handleType == @symbol(socketFilePointer) && (ioctlsocket((SOCKET)_get_osfhandle(fileno(f)), FIONREAD, &res), 1)) \
+|| (handleType == @symbol(socketHandle) && (ioctlsocket((SOCKET)(f), FIONREAD, &res), 1)) \
+|| (handleType == @symbol(pipeFilePointer) && (PeekNamedPipe((HANDLE)_get_osfhandle(fileno(f)),0,0,0,&res,0), 1))) { \
 if (res > 0) {                   \
-if (res > l)                 \
+if (res > l) res = l;        \
-res = l;                 \
+READ(ret, f, __buf, res, handleType); \
-READ(ret,f, __buf, res, handleType);     \
 } else {                         \
 (ret) = 0;                   \
+break;                       \
 }                                \
-} else if (PeekNamedPipe((HANDLE)_get_osfhandle(fileno(f)),0, 0,0,&res,0)) { \
-if (res > 0) {                   \
-if (res > l)                 \
-res = l;                 \
-READ(ret,f, __buf, res, handleType);     \
-} else                           \
-(ret) = 0;                   \
 } else {                             \
-READ(ret,f, __buf, l, handleType);           \
+READ(ret, f, __buf, l, handleType); \
-}                                    \
+}                                       \
-if ((ret) < 0 && __threadErrno == EINTR) {   \
+if ((ret) < 0 && __threadErrno == EINTR) \
-continue;                        \
+continue;                           \
-}                                    \
+}                                           \
-}                                        \
+if ((ret) > 0) {                            \
-if( (ret) > 0 ) {                               \
+buf = (char *)(obj);                    \
-/* refetch */                               \
+memcpy((buf)+__ooffs+__offs, __buf, (ret)); \
-buf = (char *)(obj);               \
+__offs += (ret);                        \
-memcpy((buf)+__ooffs+__offs,__buf,(ret));   \
+} else {                                    \
-__offs += (ret);                            \
+(ret) = 0;                              \
-} else {                                        \
+}                                           \
-(ret) = 0;                                  \
-}                                               \
-break;                                      \
 }                                               \
 if (__offs > 0)                                 \
 (ret) = __offs;                             \
 }                                                   \
 }
 int __offs = 0;                                 \
 while (__offs < (cnt)) {                        \
 CLEAR_ERRNO;                                \
 WRITE(ret,f, (buf)+__offs, (cnt)-__offs, handleType);   \
 if (ret <= 0) {                             \
-if (ret < 0 && __threadErrno == EINTR) {        \
+if (ret < 0 && __threadErrno == EINTR) { \
 continue;                           \
 }                                       \
 break;                                  \
 }                                           \
 __offs += (ret);                            \
 if the contents changed in the meantime.
 Therefore, it is a good idea to reopen files and check for these things at restart time.
 [Instance variables:]
-	handleType      <Symbol>        desribes what handle is:
+handleType      <Symbol>        desribes what handle is:
-					    win32: #fileHandle, #socketHandle,
+win32: #fileHandle, #socketHandle,
-						   #socketFileDescriptor
+#filePointer, #socketFilePointer, #pipeFilePointer
-						   #filePointer, #socketFilePointer, #pipeFilePointer
+unix: #filePointer, #socketFilePointer, #pipeFilePointer
-					    unix: #filePointer, #socketFilePointer, #pipeFilePointer
+needed for win32, which uses different APIs for the different handles (sigh)
-					needed for win32, which uses different APIs for the different handles (sigh)
+handle          <Integer>       used to be always a filePointer somehow mapped to an integer (FILE* - not the fd);
-	handle          <Integer>       used to be always a filePointer somehow mapped to an integer (FILE* - not the fd);
+now, either a filePointer or a handle (win32)
-					now, either a filePointer or a handle (win32)
+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)
+eolMode         <Symbol>        one of nil, #cr or #crlf.
-	eolMode         <Symbol>        one of nil, #cr or #crlf.
+determines how lines should be terminated.
-					determines how lines should be terminated.
+nil -> newLine (as in Unix);
-					nil -> newLine (as in Unix);
+#crlf -> with cr-lf (as in MSDOS)
-					#crlf -> with cr-lf (as in MSDOS)
+#cr -> with cr (as in VMS)
-					#cr -> with cr (as in VMS)
+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 -
-	lastErrorNumber <Integer>       the value of errno (only valid right after the error -
+updated with next i/o operation)
-					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)
-	StreamErrorSignal       <Signal> parent of all stream errors (see Stream class)
+StreamErrorSignal       <Signal> parent of all stream errors (see Stream class)
-	InvalidReadSignal       <Signal> raised on read from writeonly stream
+InvalidReadSignal       <Signal> raised on read from writeonly stream
-	InvalidWriteSignal      <Signal> raised on write to readonly stream
+InvalidWriteSignal      <Signal> raised on write to readonly stream
-	InvalidModeSignal       <Signal> raised on text I/O with binary-stream
+InvalidModeSignal       <Signal> raised on text I/O with binary-stream
-					 or binary I/O with text-stream
+or binary I/O with text-stream
-	OpenErrorSignal         <Signal> raised if open fails
+OpenErrorSignal         <Signal> raised if open fails
-	StreamNotOpenSignal     <Signal> raised on I/O with non-open 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
 fseek whenever we are about to read after write and vice versa.
 Two macros (__READING__ and __WRITING__) have been defined to be used before every
 fread/fgetc and fwrite/putc respectively.
 [author:]
-	Claus Gittinger
+Claus Gittinger
-	Stefan Vogel (many, many fixes ...)
+Stefan Vogel (many, many fixes ...)
 [see also:]
-	FileStream Socket PipeStream
+FileStream Socket PipeStream
-	Filename OperatingSystem
+Filename OperatingSystem
 "
 !
 examples
 "
 "return the fileDescriptor of the receiver -
 notice: this one returns the underlying OSs fileDescriptor -
 this may not be available on all platforms (i.e. non unix systems)."
 %{
-OBJ fp;
+OBJ _handle  = __INST(handle);
-if ((__INST(handleType) == nil)
+if (_handle != nil) {
-|| (__INST(handleType) == @symbol(filePointer))
+if (__INST(handleType) == @symbol(socketHandle)) {
-|| (__INST(handleType) == @symbol(socketFilePointer))
+RETURN (_handle);
-|| (__INST(handleType) == @symbol(pipeFilePointer))) {
+} else if ((__INST(handleType) == nil)
-	if ((fp = __INST(handle)) != nil) {
+|| (__INST(handleType) == @symbol(filePointer))
-	    FILEPOINTER f;
+|| (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(pipeFilePointer))) {
-	    f = __FILEVal(fp);
+RETURN ( __MKINT(fileno(__FILEVal(_handle))));
-	    RETURN ( __MKINT(fileno(f)) );
+}
-	}
 }
 %}.
 handle isNil ifTrue:[^ self errorNotOpen].
 ^ self fileDescriptorOfFile:handle
 !
 fileHandle
 "return the fileHandle of the receiver.
 Under unix, this is the fileDescriptor; under windows, this is the Handle."
 %{
-OBJ fp;
+OBJ _handle  = __INST(handle);
-if ((__INST(handleType) == nil)
+if (_handle != nil) {
-|| (__INST(handleType) == @symbol(filePointer))
+if ((__INST(handleType) == @symbol(fileHandle))
-|| (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))) {
-|| (__INST(handleType) == @symbol(pipeFilePointer))) {
+RETURN (_handle);
-	if ((fp = __INST(handle)) != nil) {
+} else if ((__INST(handleType) == nil)
-	    FILEPOINTER f;
+|| (__INST(handleType) == @symbol(filePointer))
-	    int fd;
+|| (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(pipeFilePointer))) {
-	    f = __FILEVal(fp);
-	    fd = fileno(f);
 #ifdef WIN32
-	    {
+RETURN(__MKEXTERNALADDRESS(_get_osfhandle(fileno(__FILEVal(_handle)))));
-		HANDLE h;
-		h = _get_osfhandle(fd);
-		RETURN (__MKEXTERNALADDRESS(h));
-	    }
 #else
-	    RETURN ( __MKINT(fileno(f)) );
+RETURN (__MKINT(fileno(__FILEVal(_handle))));
 #endif
-	}
+}
 }
-#ifdef WIN32
-if ((__INST(handleType) == @symbol(fileHandle)) || (__INST(handleType) == @symbol(socketHandle))) {
-	RETURN (__INST(handle));
-}
-#endif
 %}.
 handle isNil ifTrue:[^ self errorNotOpen].
-^ self fileHandleOfFile:handle
+^ handle
 !
 filePointer
 "return the filePointer of the receiver -
 notice: for portability stdio is used; this means you will get
 	^ handle
 ].
 ^ self error:'not a FILE*'
 !
+handleType
+^ handleType
+!
 lineEndCRLF
 eolMode := #crlf
 !
 lineEndTransparent
 ! !
 !ExternalStream methodsFor:'closing'!
 close
 "close the stream.
 No error of the stream is not open."
 self isOpen ifTrue:[
-Lobby unregister:self.
+	Lobby unregister:self.
-self closeFile.
+	self closeFile.
 ].
 !
 shutDown
 "close the stream - added for protocol compatibility with PipeStream.
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if (((fp = __INST(handle)) != nil)
+if (((fp = __INST(handle)) != nil)
-	    && (__INST(mode) != @symbol(writeonly))
+&& (__INST(mode) != @symbol(writeonly))
-	    && (__INST(binary) != true)
+&& (__INST(binary) != true)
-	) {
+) {
-	    f = __FILEVal(fp);
+f = __FILEVal(fp);
-	    buffer[0] = '\0';
+buffer[0] = '\0';
-	    _buffered = (__INST(buffered) == true);
+_buffered = (__INST(buffered) == true);
-	    if (_buffered) {
+if (_buffered) {
-		__READING__(f);
+__READING__(f);
-	    }
+}
-	    rslt = nextPtr = buffer;
+rslt = nextPtr = buffer;
-	    limit = buffer + sizeof(buffer) - 2;
+limit = buffer + sizeof(buffer) - 2;
-	    for (;;) {
+for (;;) {
-		__READBYTE__(ret, f, nextPtr, _buffered, __INST(handleType));
+__READBYTE__(ret, f, nextPtr, _buffered, __INST(handleType));
-		if (ret <= 0) {
+if (ret <= 0) {
-		    if (nextPtr == buffer)
+if (nextPtr == buffer)
-			rslt = NULL;
+rslt = NULL;
-		    if (ret == 0) {
+if (ret == 0) {
-			__INST(hitEOF) = true;
+__INST(hitEOF) = true;
-			break;
+break;
-		    } else {
+} else {
-			error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-			goto err;
+goto err;
-		    }
+}
-		}
+}
-		if (*nextPtr == '\n') {
+if (*nextPtr == '\n') {
-		    cutOff = 1;
+cutOff = 1;
-		    *nextPtr = '\0';
+*nextPtr = '\0';
-		    break;
+break;
-		}
+}
-		if (*nextPtr == '\r') {
+if (*nextPtr == '\r') {
-		    char peekChar;
+char peekChar;
-		    /*
+/*
-		     * peek ahead for a newLine ...
+* peek ahead for a newLine ...
-		     */
+*/
-		    __READBYTE__(ret, f, &peekChar, _buffered, __INST(handleType));
+__READBYTE__(ret, f, &peekChar, _buffered, __INST(handleType));
-		    if (ret <= 0) {
+if (ret <= 0) {
-			cutOff = 1;
+cutOff = 1;
-			*nextPtr = '\0';
+*nextPtr = '\0';
-			if (ret == 0) {
+if (ret == 0) {
-			    __INST(hitEOF) = true;
+__INST(hitEOF) = true;
-			    break;
+break;
-			}
+}
-			error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-			goto err;
+goto err;
-		    }
+}
-		    if (peekChar == '\n') {
+if (peekChar == '\n') {
-			cutOff = 2;
+cutOff = 2;
-			*nextPtr = '\0';
+*nextPtr = '\0';
-			break;
+break;
-		    }
+}
-		    __UNGETC__(peekChar, f, _buffered);
+__UNGETC__(peekChar, f, _buffered);
-		    cutOff = 1;
+cutOff = 1;
-		    *nextPtr = '\0';
+*nextPtr = '\0';
-		    break;
+break;
-		}
+}
-		nextPtr++;
+nextPtr++;
-		if (nextPtr >= limit) {
+if (nextPtr >= limit) {
-		    *nextPtr = '\0';
+*nextPtr = '\0';
-		    lineTooLong = 1;
+lineTooLong = 1;
-		    if (@global(InfoPrinting) == true) {
+if (@global(InfoPrinting) == true) {
-			fprintf(stderr, "ExtStream [warning]: line truncated in nextLine\n");
+fprintf(stderr, "ExtStream [warning]: line truncated in nextLine\n");
-		    }
+}
-		    break;
+break;
-		}
+}
-	    }
+}
-	    if (rslt != NULL) {
+if (rslt != NULL) {
-		len = nextPtr-buffer;
+len = nextPtr-buffer;
-		if (__isSmallInteger(__INST(position))) {
+if (__isSmallInteger(__INST(position))) {
-		    INT np = __intVal(__INST(position)) + len + cutOff;
+INT np = __intVal(__INST(position)) + len + cutOff;
-		    OBJ t;
+OBJ t;
-		    t = __MKINT(np); __INST(position) = t; __STORE(self, t);
+t = __MKINT(np); __INST(position) = t; __STORE(self, t);
-		} else {
+} else {
-		    __INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-		}
+}
-		/* remove any EOL character */
+/* remove any EOL character */
-		if (len != 0) {
+if (len != 0) {
-		    if (buffer[len-1] == '\n') {
+if (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';
-		    }
+}
-		}
+}
-		line = __MKSTRING_L(buffer, len);
+line = __MKSTRING_L(buffer, len);
-		if (! lineTooLong) {
+if (! lineTooLong) {
-		    RETURN ( line );
+RETURN ( line );
-		}
+}
-	    }
+}
-	}
+}
 }
 err: ;
 %}.
 line notNil ifTrue:[
-	"/ the line as read is longer than 32k characters (boy - what a line)
+"/ the line as read is longer than 32k characters (boy - what a line)
-	"/ The exception could be handled by reading more and returning the
+"/ The exception could be handled by reading more and returning the
-	"/ concatenation in your exception handler (the receiver and the partial
+"/ concatenation in your exception handler (the receiver and the partial
-	"/ line are passed as parameter)
+"/ line are passed as parameter)
-	LineTooLongErrorSignal isHandled ifTrue:[
+LineTooLongErrorSignal isHandled ifTrue:[
-	    ^ LineTooLongErrorSignal
+^ LineTooLongErrorSignal
-		raiseRequestWith:(Array with:self with:line)
+raiseRequestWith:(Array with:self with:line)
-		     errorString:('line too long read error')
+errorString:('line too long read error')
-	].
+].
-	^ line , self nextLine
+^ line , self nextLine
 ].
 (hitEOF == true) ifTrue:[^ self pastEndRead].
 error notNil ifTrue:[
-	lastErrorNumber := error.
+lastErrorNumber := error.
-	^ self readError:error
+^ self readError:error
 ].
 handle isNil ifTrue:[^ self errorNotOpen].
 (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
 (binary == true) ifTrue:[^ self errorBinary].
 ^ super nextLine
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if (((fp = __INST(handle)) != nil)
+if (((fp = __INST(handle)) != nil)
-	    && (__INST(mode) != @symbol(readonly))
+&& (__INST(mode) != @symbol(readonly))
-	    && (__INST(binary) != true)
+&& (__INST(binary) != true)
-	    && __isStringLike(aString)
+&& __isStringLike(aString)
-	) {
+) {
-	    f = __FILEVal(fp);
+f = __FILEVal(fp);
-	    len = __stringSize(aString);
+len = __stringSize(aString);
-	    if (_buffered = (__INST(buffered) == true)) {
+if (_buffered = (__INST(buffered) == true)) {
-		__WRITING__(f)
+__WRITING__(f)
-	    }
+}
 #ifdef WIN32
-	    if ((f == __win32_stdout()) || (f == __win32_stderr())) {
+if ((f == __win32_stdout()) || (f == __win32_stderr())) {
-		cnt = __win32_fwrite(__stringVal(aString), 1, len, f);
+cnt = __win32_fwrite(__stringVal(aString), 1, len, f);
-	    } else
+} else
 #endif
-	    {
+{
-		o_offs = (char *)__stringVal(aString)-(char *)aString;
+o_offs = (char *)__stringVal(aString)-(char *)aString;
-		__WRITEBYTES_OBJ__(cnt, f, aString, o_offs, len, _buffered, __INST(handleType));
+__WRITEBYTES_OBJ__(cnt, f, aString, o_offs, len, _buffered, __INST(handleType));
-	    }
+}
-	    if (cnt == len) {
+if (cnt == len) {
-		OBJ mode = __INST(eolMode);
+OBJ mode = __INST(eolMode);
-		len1 = len;
+len1 = len;
-		if (mode == @symbol(cr)) {
+if (mode == @symbol(cr)) {
-		    cp = "\r"; len = 1;
+cp = "\r"; len = 1;
-		} else if (mode == @symbol(crlf)) {
+} else if (mode == @symbol(crlf)) {
-		    cp = "\r\n"; len = 2;
+cp = "\r\n"; len = 2;
-		} else {
+} else {
-		    cp = "\n"; len = 1;
+cp = "\n"; len = 1;
-		}
+}
 #ifdef WIN32
-		if ((f == __win32_stdout()) || (f == __win32_stderr())) {
+if ((f == __win32_stdout()) || (f == __win32_stderr())) {
-		    cnt = __win32_fwrite(cp, 1, len, f);
+cnt = __win32_fwrite(cp, 1, len, f);
-		} else
+} else
 #endif
-		{
+{
-		    __WRITEBYTES__(cnt, f, cp, len, _buffered, __INST(handleType));
+__WRITEBYTES__(cnt, f, cp, len, _buffered, __INST(handleType));
-		}
+}
-		if (cnt > 0) {
+if (cnt > 0) {
-		    if (__isSmallInteger(__INST(position))) {
+if (__isSmallInteger(__INST(position))) {
-			INT np = __intVal(__INST(position)) + cnt;
+INT np = __intVal(__INST(position)) + cnt;
-			OBJ t;
+OBJ t;
-			t = __MKINT(np); __INST(position) = t; __STORE(self, t);
+t = __MKINT(np); __INST(position) = t; __STORE(self, t);
-		    } else {
+} else {
-			__INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-		    }
+}
-		    RETURN ( self );
+RETURN ( self );
-		}
+}
-	    }
+}
-	    error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-	}
+}
 }
 %}.
 error notNil ifTrue:[
-	lastErrorNumber := error.
+lastErrorNumber := error.
-	self writeError:error.
+self writeError:error.
-	^ self
+^ self
 ].
 super nextPutLine:aString.
 !
 nextPutLinesFrom:aStream upToLineStartingWith:aStringOrNil
 a pointer to the data is passed.
 This allows performing most ioctls
 - however, it might be tricky to setup the buffer.
 Be careful in what you pass - ST/X cannot validate its correctness."
+|error|
 %{
 #if !defined(MSDOS_LIKE) && !defined(__openVMS__)
-FILEPOINTER f;
+int fd;
 int ret;
 unsigned int ioNum;
-OBJ fp;
 INT ioArg;
+OBJ fp = __INST(handle);
-__INST(lastErrorNumber) = nil;
-if ((__INST(handleType) == nil)
+if (fp == nil)
-|| (__INST(handleType) == @symbol(filePointer))
+goto out;
-|| (__INST(handleType) == @symbol(socketFilePointer))
-|| (__INST(handleType) == @symbol(pipeFilePointer))) {
+if (!__isInteger(ioctlNumber)
-	if ((fp = __INST(handle)) != nil) {
+|| (!__isInteger(arg)
-	    if (__isInteger(ioctlNumber)
+&& (arg != nil)
-	     && (__isInteger(arg)
+&& !__isBytes(arg)
-		 || (arg == nil)
+&& !__isExternalBytesLike(arg)
-		 || __isBytes(arg)
+&& !__isExternalAddress(arg))) {
-		 || __isExternalBytesLike(arg)
+error = @symbol(badArgument);
-		 || __isExternalAddress(arg))) {
+goto out;
-		f = __FILEVal(fp);
-		ioNum = __unsignedLongIntVal(ioctlNumber);
-		__BEGIN_INTERRUPTABLE__
-		do {
-		    __threadErrno = 0;
-		    if (arg == nil) {
-			ioArg = 0;
-		    } else if (__isSmallInteger(arg)) {
-			ioArg = __intVal(arg);
-		    } else if (__isInteger(arg)) {
-			ioArg = __unsignedLongIntVal(arg);
-		    } else if (__isExternalBytesLike(arg)) {
-			ioArg = (INT)(__externalBytesAddress(arg));
-		    } else if (__isExternalAddress(arg)) {
-			ioArg = (INT)(__externalAddressVal(arg));
-		    } else {
-			ioArg = (INT)(__ByteArrayInstPtr(arg)->ba_element);
-		    }
-		    ret = ioctl(fileno(f), ioNum, ioArg);
-		} while (ret < 0 && __threadErrno == EINTR);
-		__END_INTERRUPTABLE__
-		if (ret >= 0) {
-		    RETURN ( __mkSmallInteger(ret) );
-		}
-		__INST(position) = nil; /* i.e. do not know */
-		__INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
-	    }
-	}
 }
+if (__INST(handleType) == @symbol(socketHandle)) {
+fd = __FILEVal(fp);
+} else if ((__INST(handleType) == nil)
+|| (__INST(handleType) == @symbol(filePointer))
+|| (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(pipeFilePointer))) {
+fd = fileno(__FILEVal(fp));
+} else {
+error = @symbol(badHandleType);
+goto out;
+}
+ioNum = __unsignedLongIntVal(ioctlNumber);
+__BEGIN_INTERRUPTABLE__
+do {
+__threadErrno = 0;
+if (arg == nil) {
+ioArg = 0;
+} else if (__isSmallInteger(arg)) {
+ioArg = __intVal(arg);
+} else if (__isInteger(arg)) {
+ioArg = __unsignedLongIntVal(arg);
+} else if (__isExternalBytesLike(arg)) {
+ioArg = (INT)(__externalBytesAddress(arg));
+} else if (__isExternalAddress(arg)) {
+ioArg = (INT)(__externalAddressVal(arg));
+} else {
+ioArg = (INT)(__ByteArrayInstPtr(arg)->ba_element);
+}
+ret = ioctl(fd, ioNum, ioArg);
+} while (ret < 0 && __threadErrno == EINTR);
+__END_INTERRUPTABLE__
+if (ret >= 0) {
+RETURN ( __mkSmallInteger(ret) );
+}
+error = __mkSmallInteger(__threadErrno);
 #endif
+out:;
 %}.
-lastErrorNumber notNil ifTrue:[^ self ioError].
+error notNil ifTrue:[
+lastErrorNumber := error.
+^ self ioError:error.
+].
 handle isNil ifTrue:[^ self errorNotOpen].
-"
-argument is not an integer
+"/ the system does not support ioctl (MSDOS or VMS)
-"
-(ioctlNumber isMemberOf:SmallInteger) ifFalse:[^ self primitiveFailed].
-"
-the system does not support ioctl (MSDOS or VMS)
-"
 ^ self errorUnsupportedOperation
 !
 reset
 "set the read position to the beginning of the collection"
 self flush.
 %{
 #if !defined(__openVMS__)
-FILEPOINTER f;
+int fd;
 int ret;
-OBJ fp;
+OBJ fp = __INST(handle);
-__INST(lastErrorNumber) = nil;
+if (fp == nil)
-if ((__INST(handleType) == nil)
+goto out;
-|| (__INST(handleType) == @symbol(filePointer))
-|| (__INST(handleType) == @symbol(socketFilePointer))
+if (__INST(handleType) == @symbol(socketHandle)) {
-|| (__INST(handleType) == @symbol(pipeFilePointer))) {
+fd = __FILEVal(fp);
-	if ((fp = __INST(handle)) != nil) {
+} else if ((__INST(handleType) == nil)
-	    f = __FILEVal(fp);
+|| (__INST(handleType) == @symbol(filePointer))
+|| (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(pipeFilePointer))) {
+fd = fileno(__FILEVal(fp));
+} else {
+error = @symbol(badHandleType);
+goto out;
+}
 #ifdef WIN32
-	    __threadErrno = 0;
+__threadErrno = 0;
-	    ret = __STX_API_NOINT_CALL1( "FlushFileBuffers", FlushFileBuffers, _get_osfhandle(fileno(f)));
+ret = __STX_API_NOINT_CALL1( "FlushFileBuffers", FlushFileBuffers, _get_osfhandle(fd));
-	    if (ret) {
+if (ret) {
-		RETURN (self);
+RETURN (self);
-	    }
+}
 #else
+__BEGIN_INTERRUPTABLE__
-	    __BEGIN_INTERRUPTABLE__
+do {
-	    do {
+ret = fsync(fd);
-		ret = fsync(fileno(f));
+} while ((ret < 0) && (__threadErrno == EINTR));
-	    } while ((ret < 0) && (__threadErrno == EINTR));
+__END_INTERRUPTABLE__
-	    __END_INTERRUPTABLE__
+if (ret >= 0) {
-	    if (ret >= 0) {
+RETURN (self);
-		RETURN (self);
+}
-	    }
 #endif /* ! WIN32 */
-	    error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-	}
-}
 #endif /* ! __openVMS__ */
+out:;
 %}.
 error notNil ifTrue:[
-	lastErrorNumber := error.
+lastErrorNumber := error.
-	self ioError:error.
+self ioError:error.
-	^ self.
+^ self.
 ].
 handle isNil ifTrue:[self errorNotOpen].
 "
-	|f|
+|f|
-	f := 'x' asFilename writeStream.
+f := 'x' asFilename writeStream.
-	f nextPutAll:'hallo'; sync; syncData; close
+f nextPutAll:'hallo'; sync; syncData; close
 "
 !
 syncData
 "make sure, that the OS writes cached data to the disk.
 In this case, metadata is only written, if it is
 required to read the file's data (so metadata will not be written,
 if only access/modification time has changed)."
 |error|
 self flush.
 %{
-#if defined(HAS_FDATASYNC)
+#if !defined(__openVMS__)
+int fd;
 int ret;
+OBJ fp = __INST(handle);
-__INST(lastErrorNumber) = nil;
-if ((__INST(handleType) == nil)
+if (fp == nil)
-|| (__INST(handleType) == @symbol(filePointer))
+goto out;
-|| (__INST(handleType) == @symbol(socketFilePointer))
-|| (__INST(handleType) == @symbol(pipeFilePointer))) {
+if (__INST(handleType) == @symbol(socketHandle)) {
-	OBJ fp;
+fd = __FILEVal(fp);
-	FILEPOINTER f;
+} else if ((__INST(handleType) == nil)
+|| (__INST(handleType) == @symbol(filePointer))
-	if ((fp = __INST(handle)) != nil) {
+|| (__INST(handleType) == @symbol(socketFilePointer))
-	    f = __FILEVal(fp);
+|| (__INST(handleType) == @symbol(pipeFilePointer))) {
+fd = fileno(__FILEVal(fp));
+} else {
+error = @symbol(badHandleType);
+goto out;
+}
 #ifdef WIN32
-	    __threadErrno = 0;
+__threadErrno = 0;
-	    ret = __STX_API_NOINT_CALL1( "FlushFileBuffers", FlushFileBuffers, _get_osfhandle(fileno(f)));
+ret = __STX_API_NOINT_CALL1( "FlushFileBuffers", FlushFileBuffers, _get_osfhandle(fd));
-	    if (ret) {
+if (ret) {
-		RETURN (self);
+RETURN (self);
-	    }
+}
 #else
+__BEGIN_INTERRUPTABLE__
-	    __BEGIN_INTERRUPTABLE__
+do {
-	    do {
+ret = fdatasync(fd);
-		ret = fdatasync(fileno(f));
+} while ((ret < 0) && (__threadErrno == EINTR));
-	    } while ((ret < 0) && (__threadErrno == EINTR));
+__END_INTERRUPTABLE__
-	    __END_INTERRUPTABLE__
+if (ret >= 0) {
-	    if (ret >= 0) {
+RETURN (self);
-		RETURN (self);
+}
-	    }
 #endif /* ! WIN32 */
-	    error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-	}
-}
 #endif /* ! __openVMS__ */
+out:;
 %}.
 error notNil ifTrue:[
-	lastErrorNumber := error.
+lastErrorNumber := error.
-	self ioError:error.
+self ioError:error.
-	^ self.
+^ self.
 ].
 handle isNil ifTrue:[^ self errorNotOpen].
 "if notdef HAS_DATASYNC, fall back"
 self sync.
 "
-	|f|
+|f|
-	f := 'x' asFilename writeStream.
+f := 'x' asFilename writeStream.
-	f nextPutAll:'hallo'; sync; syncData; close
+f nextPutAll:'hallo'; sync; syncData; close
-"
-!
-truncateTo:newSize
-"truncate the underlying OS file to newSize.
-Warning: this may not be implemented on all platforms."
-%{
-#ifdef HAS_FTRUNCATE
-FILEPOINTER f;
-OBJ fp;
-off_t truncateSize;
-if ((__INST(handleType) == nil)
-|| (__INST(handleType) == @symbol(filePointer))
-|| (__INST(handleType) == @symbol(socketFilePointer))
-|| (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if (((fp = __INST(handle)) != nil)
-	    && (__INST(mode) != @symbol(readonly))) {
-	    if (__isSmallInteger(newSize)) {
-		truncateSize = __intVal(newSize);
-		if (truncateSize < 0) {
-		    goto getOutOfHere;
-		}
-	    } else {
-		truncateSize = __signedLongIntVal(newSize);
-		if (truncateSize < 0) {
-		    goto getOutOfHere;
-		}
-		if (truncateSize == 0) {
-		    if (sizeof(truncateSize) == 8) {
-			if (__signedLong64IntVal(newSize, &truncateSize) == 0 || truncateSize < 0) {
-			    goto getOutOfHere;
-			}
-		    } else {
-			goto getOutOfHere;
-		    }
-		}
-	    }
-	    f = __FILEVal(fp);
-	    if (__INST(buffered) == true) {
-		__READING__(f)
-#ifdef WIN32
-		if ((dst == __win32_stdout()) || (dst == __win32_stderr())) {
-		    win32_fflush(f);
-		} else
-#endif
-		{
-		    FFLUSH(f);
-		}
-		OPT_FSEEK(f, 0L, SEEK_END); /* needed in stdio */
-	    }
-	    ftruncate(fileno(f), truncateSize);
-	    RETURN (self);
-	}
-}
-getOutOfHere: ;
-#endif
-%}.
-handle isNil ifTrue:[self errorNotOpen. ^ self].
-(mode == #readonly) ifTrue:[self errorReadOnly. ^ self].
-newSize < 0 ifTrue:[
-	self error:'wrong arg'.
-].
-self errorUnsupportedOperation
-"
-|s|
-s := 'test' asFilename writeStream.
-s next:1000 put:$a.
-s truncateTo:100.
-s close.
-('test' asFilename fileSize) printNL
 "
 ! !
 !ExternalStream methodsFor:'non homogenous reading'!
 Use with care - non object oriented I/O.
 Warning: in general, you cannot use this method to pass data from other
 architectures since it does not care for byte order or float representation."
 |error|
 %{
 FILEPOINTER f;
 int cnt, offs, ret, _buffered;
 int objSize, nInstBytes;
 char *cp;
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if (((fp = __INST(handle)) != nil)
+if (((fp = __INST(handle)) != nil)
-	    && (__INST(mode) != @symbol(writeonly))
+&& (__INST(mode) != @symbol(writeonly))
-	    && __bothSmallInteger(count, start)
+&& __bothSmallInteger(count, start)
-	) {
+) {
-	    f = __FILEVal(fp);
+f = __FILEVal(fp);
-	    cnt = __intVal(count);
+cnt = __intVal(count);
-	    offs = __intVal(start) - 1;
+offs = __intVal(start) - 1;
-	    if (__isExternalBytesLike(anObject)) {
+if (__isExternalBytesLike(anObject)) {
-		OBJ sz;
+OBJ sz;
-		nInstBytes = 0;
+nInstBytes = 0;
-		extPtr = (char *)(__externalBytesAddress(anObject));
+extPtr = (char *)(__externalBytesAddress(anObject));
-		if (extPtr == NULL) goto bad;
+if (extPtr == NULL) goto bad;
-		sz = __externalBytesSize(anObject);
+sz = __externalBytesSize(anObject);
-		if (__isSmallInteger(sz)) {
+if (__isSmallInteger(sz)) {
-		    objSize = __intVal(sz);
+objSize = __intVal(sz);
-		} else {
+} else {
-		    objSize = 0; /* unknown */
+objSize = 0; /* unknown */
-		}
+}
-	    } else {
+} else {
-		OBJ oClass = __Class(anObject);
+OBJ oClass = __Class(anObject);
-		int nInstVars = __intVal(__ClassInstPtr(oClass)->c_ninstvars);
+int nInstVars = __intVal(__ClassInstPtr(oClass)->c_ninstvars);
-		nInstBytes = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
+nInstBytes = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
-		switch (__intVal(__ClassInstPtr(oClass)->c_flags) & ARRAYMASK) {
+switch (__intVal(__ClassInstPtr(oClass)->c_flags) & ARRAYMASK) {
-		    case BYTEARRAY:
+case BYTEARRAY:
-		    case WORDARRAY:
+case WORDARRAY:
-		    case LONGARRAY:
+case LONGARRAY:
-		    case SWORDARRAY:
+case SWORDARRAY:
-		    case SLONGARRAY:
+case SLONGARRAY:
-		    case FLOATARRAY:
+case FLOATARRAY:
-			break;
+break;
-		    case DOUBLEARRAY:
+case DOUBLEARRAY:
 #ifdef __NEED_DOUBLE_ALIGN
-			nInstBytes = (nInstBytes-1+__DOUBLE_ALIGN) &~ (__DOUBLE_ALIGN-1);
+nInstBytes = (nInstBytes-1+__DOUBLE_ALIGN) &~ (__DOUBLE_ALIGN-1);
 #endif
-			break;
+break;
-		    case LONGLONGARRAY:
+case LONGLONGARRAY:
-		    case SLONGLONGARRAY:
+case SLONGLONGARRAY:
 #ifdef __NEED_LONGLONG_ALIGN
-			nInstBytes = (nInstBytes-1+__LONGLONG_ALIGN) &~ (__LONGLONG_ALIGN-1);
+nInstBytes = (nInstBytes-1+__LONGLONG_ALIGN) &~ (__LONGLONG_ALIGN-1);
 #endif
-			break;
+break;
-		    default:
+default:
-			goto bad;
+goto bad;
-		}
+}
-		extPtr = (char *)0;
+extPtr = (char *)0;
-		objSize = __Size(anObject) - nInstBytes;
+objSize = __Size(anObject) - nInstBytes;
-	    }
+}
-	    if ((offs >= 0) && (cnt >= 0) && (objSize >= (cnt + offs))) {
+if ((offs >= 0) && (cnt >= 0) && (objSize >= (cnt + offs))) {
-		_buffered = (__INST(buffered) == true);
+_buffered = (__INST(buffered) == true);
-		if (_buffered) {
+if (_buffered) {
-		    __READING__(f);
+__READING__(f);
-		}
+}
-		if (extPtr) {
+if (extPtr) {
-		    __READAVAILBYTES__(ret, f, extPtr+offs, cnt, _buffered, __INST(handleType));
+__READAVAILBYTES__(ret, f, extPtr+offs, cnt, _buffered, __INST(handleType));
-		} else {
+} else {
-		    /*
+/*
-		     * on interrupt, anObject may be moved to another location.
+* on interrupt, anObject may be moved to another location.
-		     * So we pass (char *)__InstPtr(anObject) + nInstBytes + offs to the macro __READ_BYTES__,
+* So we pass (char *)__InstPtr(anObject) + nInstBytes + offs to the macro __READ_BYTES__,
-		     * to get a new address.
+* to get a new address.
-		     */
+*/
-		    offs += nInstBytes;
+offs += nInstBytes;
-		    __READAVAILBYTES_OBJ__(ret, f, anObject, offs, cnt, _buffered, __INST(handleType));
+__READAVAILBYTES_OBJ__(ret, f, anObject, offs, cnt, _buffered, __INST(handleType));
-		}
+}
-		/* 0 is NOT an EOF condition here ... */
+/* 0 is NOT an EOF condition here ... */
-		if (ret >= 0) {
+if (ret >= 0) {
-		    if (__isSmallInteger(__INST(position))) {
+if (__isSmallInteger(__INST(position))) {
-			INT np = __intVal(__INST(position)) + ret;
+INT np = __intVal(__INST(position)) + ret;
-			OBJ t;
+OBJ t;
-			t = __MKINT(np); __INST(position) = t; __STORE(self, t);
+t = __MKINT(np); __INST(position) = t; __STORE(self, t);
-		    } else {
+} else {
-			__INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-		    }
+}
-		    RETURN (__mkSmallInteger(ret));
+RETURN (__mkSmallInteger(ret));
-		}
+}
-		__INST(position) = nil;
+__INST(position) = nil;
-		error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-	    }
+}
-	}
+}
 }
 bad: ;
 %}.
 (hitEOF and:[self pastEndRead isNil]) ifTrue:[^ 0].
 error notNil ifTrue:[
-	lastErrorNumber := error.
+lastErrorNumber := error.
-	^ self readError:error
+^ self readError:error
 ].
 handle isNil ifTrue:[^ self errorNotOpen].
 (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
 "
 count not integer or arg not bit-like (String, ByteArray etc)
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if (((fp = __INST(handle)) != nil)
+if (((fp = __INST(handle)) != nil)
-	 && (__INST(mode) != @symbol(writeonly))) {
+&& (__INST(mode) != @symbol(writeonly))) {
-	    f = __FILEVal(fp);
+f = __FILEVal(fp);
-	    _buffered = (__INST(buffered) == true);
+_buffered = (__INST(buffered) == true);
-	    if (_buffered) {
+if (_buffered) {
-		__READING__(f)
+__READING__(f)
-	    }
+}
-	    __READBYTE__(ret, f, &byte, _buffered, __INST(handleType));
+__READBYTE__(ret, f, &byte, _buffered, __INST(handleType));
-	    if (ret > 0) {
+if (ret > 0) {
-		if (__isSmallInteger(__INST(position))) {
+if (__isSmallInteger(__INST(position))) {
-		    INT np = __intVal(__INST(position)) + 1;
+INT np = __intVal(__INST(position)) + 1;
-		    OBJ t;
+OBJ t;
-		    t = __MKINT(np); __INST(position) = t; __STORE(self, t);
+t = __MKINT(np); __INST(position) = t; __STORE(self, t);
-		} else {
+} else {
-		    __INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-		}
+}
-		RETURN (__mkSmallInteger(byte));
+RETURN (__mkSmallInteger(byte));
-	    }
+}
-	    if (ret == 0) {
+if (ret == 0) {
-		__INST(hitEOF) = true;
+__INST(hitEOF) = true;
-	    } else /* ret < 0 */ {
+} else /* ret < 0 */ {
-		__INST(position) = nil;
+__INST(position) = nil;
-		error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-	    }
+}
-	}
+}
 }
 %}.
 hitEOF ifTrue:[^ self pastEndRead].
 error notNil ifTrue:[
-	lastErrorNumber := error.
+lastErrorNumber := error.
-	^ self readError:error
+^ self readError:error
 ].
 handle isNil ifTrue:[^ self errorNotOpen].
 ^ self errorWriteOnly
 !
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if (((fp = __INST(handle)) != nil)
+if (((fp = __INST(handle)) != nil)
-	    && (__INST(mode) != @symbol(writeonly))
+&& (__INST(mode) != @symbol(writeonly))
-	    && __bothSmallInteger(count, start)
+&& __bothSmallInteger(count, start)
-	) {
+) {
-	    f = __FILEVal(fp);
+f = __FILEVal(fp);
-	    cnt = __intVal(count);
+cnt = __intVal(count);
-	    offs = __intVal(start) - 1;
+offs = __intVal(start) - 1;
-	    if (__isExternalBytesLike(anObject)) {
+if (__isExternalBytesLike(anObject)) {
-		OBJ sz;
+OBJ sz;
-		nInstBytes = 0;
+nInstBytes = 0;
-		extPtr = (char *)(__externalBytesAddress(anObject));
+extPtr = (char *)(__externalBytesAddress(anObject));
-		if (extPtr == NULL) goto bad;
+if (extPtr == NULL) goto bad;
-		sz = __externalBytesSize(anObject);
+sz = __externalBytesSize(anObject);
-		if (__isSmallInteger(sz)) {
+if (__isSmallInteger(sz)) {
-		    objSize = __intVal(sz);
+objSize = __intVal(sz);
-		} else {
+} else {
-		    objSize = 0; /* unknown */
+objSize = 0; /* unknown */
-		}
+}
-	    } else {
+} else {
-		OBJ oClass = __Class(anObject);
+OBJ oClass = __Class(anObject);
-		int nInstVars = __intVal(__ClassInstPtr(oClass)->c_ninstvars);
+int nInstVars = __intVal(__ClassInstPtr(oClass)->c_ninstvars);
-		nInstBytes = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
+nInstBytes = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
-		switch (__intVal(__ClassInstPtr(oClass)->c_flags) & ARRAYMASK) {
+switch (__intVal(__ClassInstPtr(oClass)->c_flags) & ARRAYMASK) {
-		    case BYTEARRAY:
+case BYTEARRAY:
-		    case WORDARRAY:
+case WORDARRAY:
-		    case LONGARRAY:
+case LONGARRAY:
-		    case SWORDARRAY:
+case SWORDARRAY:
-		    case SLONGARRAY:
+case SLONGARRAY:
-		    case FLOATARRAY:
+case FLOATARRAY:
-			break;
+break;
-		    case DOUBLEARRAY:
+case DOUBLEARRAY:
 #ifdef __NEED_DOUBLE_ALIGN
-			nInstBytes = (nInstBytes-1+__DOUBLE_ALIGN) &~ (__DOUBLE_ALIGN-1);
+nInstBytes = (nInstBytes-1+__DOUBLE_ALIGN) &~ (__DOUBLE_ALIGN-1);
 #endif
-			break;
+break;
-		    case LONGLONGARRAY:
+case LONGLONGARRAY:
-		    case SLONGLONGARRAY:
+case SLONGLONGARRAY:
 #ifdef __NEED_LONGLONG_ALIGN
-			nInstBytes = (nInstBytes-1+__LONGLONG_ALIGN) &~ (__LONGLONG_ALIGN-1);
+nInstBytes = (nInstBytes-1+__LONGLONG_ALIGN) &~ (__LONGLONG_ALIGN-1);
 #endif
-			break;
+break;
-		    default:
+default:
-			goto bad;
+goto bad;
-		}
+}
-		extPtr = (char *)0;
+extPtr = (char *)0;
-		objSize = __Size(anObject) - nInstBytes;
+objSize = __Size(anObject) - nInstBytes;
-	    }
+}
-	    if ((offs >= 0) && (cnt >= 0) && (objSize >= (cnt + offs))) {
+if ((offs >= 0) && (cnt >= 0) && (objSize >= (cnt + offs))) {
-		_buffered = (__INST(buffered) == true);
+_buffered = (__INST(buffered) == true);
-		if (_buffered) {
+if (_buffered) {
-		    __READING__(f);
+__READING__(f);
-		}
+}
-		if (extPtr) {
+if (extPtr) {
-		    __READBYTES__(ret, f, extPtr+offs, cnt, _buffered, __INST(handleType));
+__READBYTES__(ret, f, extPtr+offs, cnt, _buffered, __INST(handleType));
-		} else {
+} else {
-		    /*
+/*
-		     * on interrupt, anObject may be moved to another location.
+* on interrupt, anObject may be moved to another location.
-		     * So we pass anObject, and the offset to the __READBYTES_OBJ__ macro.
+* So we pass anObject, and the offset to the __READBYTES_OBJ__ macro.
-		     */
+*/
-		    offs += nInstBytes;
+offs += nInstBytes;
-		    __READBYTES_OBJ__(ret, f, anObject, offs, cnt, _buffered, __INST(handleType));
+__READBYTES_OBJ__(ret, f, anObject, offs, cnt, _buffered, __INST(handleType));
-		}
+}
-		if (ret > 0) {
+if (ret > 0) {
-		    if (__isSmallInteger(__INST(position))) {
+if (__isSmallInteger(__INST(position))) {
-			INT np = __intVal(__INST(position)) + ret;
+INT np = __intVal(__INST(position)) + ret;
-			OBJ t = __MKINT(np); __INST(position) = t; __STORE(self, t);
+OBJ t = __MKINT(np); __INST(position) = t; __STORE(self, t);
-		    } else {
+} else {
-			__INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-		    }
+}
-		    RETURN (__mkSmallInteger(ret));
+RETURN (__mkSmallInteger(ret));
-		}
+}
-		if (ret == 0) {
+if (ret == 0) {
-		    __INST(hitEOF) = true;
+__INST(hitEOF) = true;
-		} else /* ret < 0 */ {
+} else /* ret < 0 */ {
-		    __INST(position) = nil;
+__INST(position) = nil;
-		    error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-		}
+}
-	    }
+}
-	}
+}
 }
 bad: ;
 %}.
 (hitEOF and:[self pastEndRead isNil]) ifTrue:[^ 0].
 error notNil ifTrue:[
-	lastErrorNumber := error.
+lastErrorNumber := error.
-	^ self readError:error
+^ self readError:error
 ].
 handle isNil ifTrue:[^ self errorNotOpen].
 (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
 "
 count not integer or arg not bit-like (String, ByteArray etc)
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if (((fp = __INST(handle)) != nil)
+if (((fp = __INST(handle)) != nil)
-	    && (__INST(mode) != @symbol(writeonly))
+&& (__INST(mode) != @symbol(writeonly))
-	) {
+) {
-	    FILEPOINTER f;
+FILEPOINTER f;
-	    int ret, _buffered;
+int ret, _buffered;
-	    int value;
+int value;
-	    union {
+union {
-		unsigned char buffer[4];
+unsigned char buffer[4];
-		int intVal;
+int intVal;
-	    } u;
+} u;
-	    f = __FILEVal(fp);
+f = __FILEVal(fp);
-	    _buffered = (__INST(buffered) == true);
+_buffered = (__INST(buffered) == true);
-	    if (_buffered) {
+if (_buffered) {
-		__READING__(f)
+__READING__(f)
-	    }
+}
-	    __READBYTES__(ret, f, u.buffer, 4, _buffered, __INST(handleType));
+__READBYTES__(ret, f, u.buffer, 4, _buffered, __INST(handleType));
-	    if (ret == 4) {
+if (ret == 4) {
-		if (__isSmallInteger(__INST(position))) {
+if (__isSmallInteger(__INST(position))) {
-		    INT np = __intVal(__INST(position)) + 4;
+INT np = __intVal(__INST(position)) + 4;
-		    OBJ t;
+OBJ t;
-		    t = __MKINT(np); __INST(position) = t; __STORE(self, t);
+t = __MKINT(np); __INST(position) = t; __STORE(self, t);
-		} else {
+} else {
-		    __INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-		}
+}
-		if (msbFlag == true) {
+if (msbFlag == true) {
 #if defined(__MSBFIRST__)
-		    value = u.intVal;
+value = u.intVal;
 #else
-		    value = (u.buffer[0] & 0xFF);
+value = (u.buffer[0] & 0xFF);
-		    value = (value << 8) | (u.buffer[1] & 0xFF);
+value = (value << 8) | (u.buffer[1] & 0xFF);
-		    value = (value << 8) | (u.buffer[2] & 0xFF);
+value = (value << 8) | (u.buffer[2] & 0xFF);
-		    value = (value << 8) | (u.buffer[3] & 0xFF);
+value = (value << 8) | (u.buffer[3] & 0xFF);
 #endif
-		} else {
+} else {
 #if defined(__LSBFIRST__)
-		    value = u.intVal;
+value = u.intVal;
 #else
-		    value = (u.buffer[3] & 0xFF);
+value = (u.buffer[3] & 0xFF);
-		    value = (value << 8) | (u.buffer[2] & 0xFF);
+value = (value << 8) | (u.buffer[2] & 0xFF);
-		    value = (value << 8) | (u.buffer[1] & 0xFF);
+value = (value << 8) | (u.buffer[1] & 0xFF);
-		    value = (value << 8) | (u.buffer[0] & 0xFF);
+value = (value << 8) | (u.buffer[0] & 0xFF);
 #endif
-		}
+}
 #if __POINTER_SIZE__ == 8
-		RETURN ( __mkSmallInteger(value));
+RETURN ( __mkSmallInteger(value));
 #else
-		if ((value >= _MIN_INT) && (value <= _MAX_INT)) {
+if ((value >= _MIN_INT) && (value <= _MAX_INT)) {
-		    RETURN ( __mkSmallInteger(value));
+RETURN ( __mkSmallInteger(value));
-		}
+}
-		RETURN ( __MKLARGEINT(value) );
+RETURN ( __MKLARGEINT(value) );
 #endif
-	    }
+}
-	    if (ret < 0) {
+if (ret < 0) {
-		__INST(position) = nil;
+__INST(position) = nil;
-		error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-	    } else /* ret == 0 */ {
+} else /* ret == 0 */ {
-		__INST(hitEOF) = true;
+__INST(hitEOF) = true;
-	    }
+}
-	}
+}
 }
 %}.
 hitEOF ifTrue:[^ self pastEndRead].
 handle isNil ifTrue:[^ self errorNotOpen].
 (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if (((fp = __INST(handle)) != nil)
+if (((fp = __INST(handle)) != nil)
-	    && (__INST(mode) != @symbol(writeonly))
+&& (__INST(mode) != @symbol(writeonly))
-	) {
+) {
-	    FILEPOINTER f;
+FILEPOINTER f;
-	    int ret, _buffered;
+int ret, _buffered;
-	    short value;
+short value;
-	    union {
+union {
-		unsigned char buffer[2];
+unsigned char buffer[2];
-		short shortVal;
+short shortVal;
-	    } u;
+} u;
-	    f = __FILEVal(fp);
+f = __FILEVal(fp);
-	    _buffered = (__INST(buffered) == true);
+_buffered = (__INST(buffered) == true);
-	    if (_buffered) {
+if (_buffered) {
-		__READING__(f)
+__READING__(f)
-	    }
+}
-	    __READBYTES__(ret, f, u.buffer, 2, _buffered, __INST(handleType));
+__READBYTES__(ret, f, u.buffer, 2, _buffered, __INST(handleType));
-	    if (ret == 2) {
+if (ret == 2) {
-		if (__isSmallInteger(__INST(position))) {
+if (__isSmallInteger(__INST(position))) {
-		    INT np = __intVal(__INST(position)) + 2;
+INT np = __intVal(__INST(position)) + 2;
-		    OBJ t;
+OBJ t;
-		    t = __MKINT(np); __INST(position) = t; __STORE(self, t);
+t = __MKINT(np); __INST(position) = t; __STORE(self, t);
-		} else {
+} else {
-		    __INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-		}
+}
-		if (msbFlag == true) {
+if (msbFlag == true) {
 #if defined(__MSBFIRST__)
-		    value = u.shortVal;
+value = u.shortVal;
 #else
-		    value = ((u.buffer[0] & 0xFF) << 8) | (u.buffer[1] & 0xFF);
+value = ((u.buffer[0] & 0xFF) << 8) | (u.buffer[1] & 0xFF);
 #endif
-		} else {
+} else {
 #if defined(__LSBFIRST__)
-		    value = u.shortVal;
+value = u.shortVal;
 #else
-		    value = ((u.buffer[1] & 0xFF) << 8) | (u.buffer[0] & 0xFF);
+value = ((u.buffer[1] & 0xFF) << 8) | (u.buffer[0] & 0xFF);
 #endif
-		}
+}
-		RETURN (__mkSmallInteger(value));
+RETURN (__mkSmallInteger(value));
-	    }
+}
-	    if (ret < 0) {
+if (ret < 0) {
-		__INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-		error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-	    } else /* ret == 0 */ {
+} else /* ret == 0 */ {
-		__INST(hitEOF) = true;
+__INST(hitEOF) = true;
-	    }
+}
-	}
+}
 }
 %}.
 hitEOF ifTrue:[^ self pastEndRead].
 handle isNil ifTrue:[^ self errorNotOpen].
 (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if (((fp = __INST(handle)) != nil)
+if (((fp = __INST(handle)) != nil)
-	    && (__INST(mode) != @symbol(writeonly))
+&& (__INST(mode) != @symbol(writeonly))
-	) {
+) {
-	    FILEPOINTER f;
+FILEPOINTER f;
-	    int ret, _buffered;
+int ret, _buffered;
-	    unsigned INT value;
+unsigned INT value;
-	    union {
+union {
-		unsigned char buffer[4];
+unsigned char buffer[4];
-		unsigned int intVal;
+unsigned int intVal;
-	    } u;
+} u;
-	    f = __FILEVal(fp);
+f = __FILEVal(fp);
-	    _buffered = (__INST(buffered) == true);
+_buffered = (__INST(buffered) == true);
-	    if (_buffered) {
+if (_buffered) {
-		__READING__(f)
+__READING__(f)
-	    }
+}
-	    __READBYTES__(ret, f, u.buffer, 4, _buffered, __INST(handleType));
+__READBYTES__(ret, f, u.buffer, 4, _buffered, __INST(handleType));
-	    if (ret == 4) {
+if (ret == 4) {
-		if (__isSmallInteger(__INST(position))) {
+if (__isSmallInteger(__INST(position))) {
-		    INT np = __intVal(__INST(position)) + 4;
+INT np = __intVal(__INST(position)) + 4;
-		    OBJ t;
+OBJ t;
-		    t = __MKINT(np); __INST(position) = t; __STORE(self, t);
+t = __MKINT(np); __INST(position) = t; __STORE(self, t);
-		} else {
+} else {
-		    __INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-		}
+}
-		if (msbFlag == true) {
+if (msbFlag == true) {
 #if defined(__MSBFIRST__)
-		    value = u.intVal;
+value = u.intVal;
 #else
-		    value = u.buffer[0];
+value = u.buffer[0];
-		    value = (value << 8) | u.buffer[1];
+value = (value << 8) | u.buffer[1];
-		    value = (value << 8) | u.buffer[2];
+value = (value << 8) | u.buffer[2];
-		    value = (value << 8) | u.buffer[3];
+value = (value << 8) | u.buffer[3];
 #endif
-		} else {
+} else {
 #if defined(__LSBFIRST__)
-		    value = u.intVal;
+value = u.intVal;
 #else
-		    value = u.buffer[3];
+value = u.buffer[3];
-		    value = (value << 8) | u.buffer[2];
+value = (value << 8) | u.buffer[2];
-		    value = (value << 8) | u.buffer[1];
+value = (value << 8) | u.buffer[1];
-		    value = (value << 8) | u.buffer[0];
+value = (value << 8) | u.buffer[0];
 #endif
-		}
+}
 #if __POINTER_SIZE__ == 8
-		value &= 0xFFFFFFFF;
+value &= 0xFFFFFFFF;
-		RETURN (__mkSmallInteger(value));
+RETURN (__mkSmallInteger(value));
 #else
-		if (value <= _MAX_INT) {
+if (value <= _MAX_INT) {
-		    RETURN (__mkSmallInteger(value));
+RETURN (__mkSmallInteger(value));
-		}
+}
-		RETURN (__MKULARGEINT(value) );
+RETURN (__MKULARGEINT(value) );
 #endif
-	    }
+}
-	    if (ret < 0) {
+if (ret < 0) {
-		__INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-		error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-	    } else /* ret == 0 */ {
+} else /* ret == 0 */ {
-		__INST(hitEOF) = true;
+__INST(hitEOF) = true;
-	    }
+}
-	}
+}
 }
 %}.
 hitEOF ifTrue:[^ self pastEndRead].
 handle isNil ifTrue:[^ self errorNotOpen].
 (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if (((fp = __INST(handle)) != nil)
+if (((fp = __INST(handle)) != nil)
-	    && (__INST(mode) != @symbol(writeonly))
+&& (__INST(mode) != @symbol(writeonly))
-	) {
+) {
-	    FILEPOINTER f;
+FILEPOINTER f;
-	    int ret, _buffered;
+int ret, _buffered;
-	    unsigned int value;
+unsigned int value;
-	    union {
+union {
-		unsigned char buffer[2];
+unsigned char buffer[2];
-		unsigned short shortVal;
+unsigned short shortVal;
-	    } u;
+} u;
-	    f = __FILEVal(fp);
+f = __FILEVal(fp);
-	    _buffered = (__INST(buffered) == true);
+_buffered = (__INST(buffered) == true);
-	    if (_buffered) {
+if (_buffered) {
-		__READING__(f)
+__READING__(f)
-	    }
+}
-	    __READBYTES__(ret, f, u.buffer, 2, _buffered, __INST(handleType));
+__READBYTES__(ret, f, u.buffer, 2, _buffered, __INST(handleType));
-	    if (ret == 2) {
+if (ret == 2) {
-		if (__isSmallInteger(__INST(position))) {
+if (__isSmallInteger(__INST(position))) {
-		    INT np = __intVal(__INST(position)) + 2;
+INT np = __intVal(__INST(position)) + 2;
-		    OBJ t;
+OBJ t;
-		    t = __MKINT(np); __INST(position) = t; __STORE(self, t);
+t = __MKINT(np); __INST(position) = t; __STORE(self, t);
-		} else {
+} else {
-		    __INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-		}
+}
-		if (msbFlag == true) {
+if (msbFlag == true) {
 #if defined(__MSBFIRST__)
-		    value = u.shortVal;
+value = u.shortVal;
 #else
-		    value = (u.buffer[0] << 8) | u.buffer[1];
+value = (u.buffer[0] << 8) | u.buffer[1];
 #endif
-		} else {
+} else {
 #if defined(__LSBFIRST__)
-		    value = u.shortVal;
+value = u.shortVal;
 #else
-		    value = (u.buffer[1] << 8) | u.buffer[0];
+value = (u.buffer[1] << 8) | u.buffer[0];
 #endif
-		}
+}
-		RETURN (__mkSmallInteger(value));
+RETURN (__mkSmallInteger(value));
-	    }
+}
-	    if (ret < 0) {
+if (ret < 0) {
-		__INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-		error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-	    } else /* ret == 0 */ {
+} else /* ret == 0 */ {
-		__INST(hitEOF) = true;
+__INST(hitEOF) = true;
-	    }
+}
-	}
+}
 }
 %}.
 hitEOF ifTrue:[^ self pastEndRead].
 handle isNil ifTrue:[^ self errorNotOpen].
 (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
 nextPutByte:aByteValue
 "write a byte.
 Works in both binary and text modes."
 |error|
 %{
 FILEPOINTER f;
 char c;
 OBJ fp;
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if (((fp = __INST(handle)) != nil)
+if (((fp = __INST(handle)) != nil)
-	    && (__INST(mode) != @symbol(readonly))
+&& (__INST(mode) != @symbol(readonly))
-	    && __isSmallInteger(aByteValue)
+&& __isSmallInteger(aByteValue)
-	) {
+) {
-	    c = __intVal(aByteValue);
+c = __intVal(aByteValue);
-	    f = __FILEVal(fp);
+f = __FILEVal(fp);
-	    if (_buffered = (__INST(buffered) == true)) {
+if (_buffered = (__INST(buffered) == true)) {
-		__WRITING__(f)
+__WRITING__(f)
-	    }
+}
 #ifdef WIN32
-	    if ((f == __win32_stdout()) || (f == __win32_stderr())) {
+if ((f == __win32_stdout()) || (f == __win32_stderr())) {
-		cnt = __win32_fwrite(&c, 1, 1, f);
+cnt = __win32_fwrite(&c, 1, 1, f);
-	    } else
+} else
 #endif
-	    {
+{
-		__WRITEBYTE__(cnt, f, &c, _buffered, __INST(handleType));
+__WRITEBYTE__(cnt, f, &c, _buffered, __INST(handleType));
-	    }
+}
-	    if (cnt == 1) {
+if (cnt == 1) {
-		if (__isSmallInteger(__INST(position))) {
+if (__isSmallInteger(__INST(position))) {
-		    INT np = __intVal(__INST(position)) + 1;
+INT np = __intVal(__INST(position)) + 1;
-		    OBJ t;
+OBJ t;
-		    t = __MKINT(np); __INST(position) = t; __STORE(self, t);
+t = __MKINT(np); __INST(position) = t; __STORE(self, t);
-		} else {
+} else {
-		    __INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-		}
+}
-		RETURN (self);
+RETURN (self);
-	    }
+}
-	    if (cnt < 0) {
+if (cnt < 0) {
-		__INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-	    }
+}
-	    error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-	}
+}
 }
 %}.
 handle isNil ifTrue:[self errorNotOpen. ^ self].
 (mode == #readonly) ifTrue:[self errorReadOnly. ^ self].
 lastErrorNumber := error.
 (i.e. be a ByteArray, String, Float- or DoubleArray),
 or an externalBytes object (with known size).
 Use with care - non object oriented i/o.
 Warning:
-	in general, you cannot use this method to pass non-byte data to other
+in general, you cannot use this method to pass non-byte data to other
-	architectures (unless you prepared the buffer with care),
+architectures (unless you prepared the buffer with care),
-	since it does not care for byte order or float representation."
+since it does not care for byte order or float representation."
 |error|
 %{
 FILEPOINTER f;
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if (((fp = __INST(handle)) != nil)
+if (((fp = __INST(handle)) != nil)
-	    && (__INST(mode) != @symbol(readonly))
+&& (__INST(mode) != @symbol(readonly))
-	    && __bothSmallInteger(count, start)
+&& __bothSmallInteger(count, start)
-	) {
+) {
-	    len = __intVal(count);
+len = __intVal(count);
-	    offs = __intVal(start) - 1;
+offs = __intVal(start) - 1;
-	    f = __FILEVal(fp);
+f = __FILEVal(fp);
-	    if (__isExternalBytesLike(anObject)) {
+if (__isExternalBytesLike(anObject)) {
-		OBJ sz;
+OBJ sz;
-		nInstBytes = 0;
+nInstBytes = 0;
-		extPtr = (char *)__externalBytesAddress(anObject);
+extPtr = (char *)__externalBytesAddress(anObject);
-		if (extPtr == NULL) goto bad;
+if (extPtr == NULL) goto bad;
-		sz = __externalBytesSize(anObject);
+sz = __externalBytesSize(anObject);
-		if (__isSmallInteger(sz)) {
+if (__isSmallInteger(sz)) {
-		    objSize = __intVal(sz);
+objSize = __intVal(sz);
-		} else {
+} else {
-		    objSize = 0; /* unknown */
+objSize = 0; /* unknown */
-		}
+}
-	    } else {
+} else {
-		OBJ oClass = __Class(anObject);
+OBJ oClass = __Class(anObject);
-		int nInstVars = __intVal(__ClassInstPtr(oClass)->c_ninstvars);
+int nInstVars = __intVal(__ClassInstPtr(oClass)->c_ninstvars);
-		nInstBytes = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
+nInstBytes = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
-		switch (__intVal(__ClassInstPtr(oClass)->c_flags) & ARRAYMASK) {
+switch (__intVal(__ClassInstPtr(oClass)->c_flags) & ARRAYMASK) {
-		    case BYTEARRAY:
+case BYTEARRAY:
-		    case WORDARRAY:
+case WORDARRAY:
-		    case LONGARRAY:
+case LONGARRAY:
-		    case SWORDARRAY:
+case SWORDARRAY:
-		    case SLONGARRAY:
+case SLONGARRAY:
-		    case FLOATARRAY:
+case FLOATARRAY:
-			break;
+break;
-		    case DOUBLEARRAY:
+case DOUBLEARRAY:
 #ifdef __NEED_DOUBLE_ALIGN
-			nInstBytes = (nInstBytes-1+__DOUBLE_ALIGN) &~ (__DOUBLE_ALIGN-1);
+nInstBytes = (nInstBytes-1+__DOUBLE_ALIGN) &~ (__DOUBLE_ALIGN-1);
 #endif
-			break;
+break;
-		    case LONGLONGARRAY:
+case LONGLONGARRAY:
-		    case SLONGLONGARRAY:
+case SLONGLONGARRAY:
 #ifdef __NEED_LONGLONG_ALIGN
-			nInstBytes = (nInstBytes-1+__LONGLONG_ALIGN) &~ (__LONGLONG_ALIGN-1);
+nInstBytes = (nInstBytes-1+__LONGLONG_ALIGN) &~ (__LONGLONG_ALIGN-1);
 #endif
-			break;
+break;
-		    default:
+default:
-			goto bad;
+goto bad;
-		}
+}
-		extPtr = (char *)0;
+extPtr = (char *)0;
-		objSize = __Size(anObject) - nInstBytes;
+objSize = __Size(anObject) - nInstBytes;
-	    }
+}
-	    if ( (offs >= 0) && (len >= 0) && (objSize >= (len + offs)) ) {
+if ( (offs >= 0) && (len >= 0) && (objSize >= (len + offs)) ) {
-		if (_buffered = (__INST(buffered) == true)) {
+if (_buffered = (__INST(buffered) == true)) {
-		    __WRITING__(f)
+__WRITING__(f)
-		}
+}
-		if (extPtr) {
+if (extPtr) {
-		    __WRITEBYTES__(cnt, f, extPtr+offs, len, _buffered, __INST(handleType));
+__WRITEBYTES__(cnt, f, extPtr+offs, len, _buffered, __INST(handleType));
-		} else {
+} else {
-		    /*
+/*
-		     * on interrupt, anObject may be moved to another location.
+* on interrupt, anObject may be moved to another location.
-		     * So we pass anObject, and the offset to the __WRITEBYTES_OBJ__ macro.
+* So we pass anObject, and the offset to the __WRITEBYTES_OBJ__ macro.
-		     */
+*/
-		    offs += nInstBytes;
+offs += nInstBytes;
-		    __WRITEBYTES_OBJ__(cnt, f, anObject, offs, len, _buffered, __INST(handleType));
+__WRITEBYTES_OBJ__(cnt, f, anObject, offs, len, _buffered, __INST(handleType));
-		}
+}
-		if (cnt >= 0) {
+if (cnt >= 0) {
-		    if (__isSmallInteger(__INST(position))) {
+if (__isSmallInteger(__INST(position))) {
-			INT np = __intVal(__INST(position)) + cnt;
+INT np = __intVal(__INST(position)) + cnt;
-			OBJ t;
+OBJ t;
-			t = __MKINT(np); __INST(position) = t; __STORE(self, t);
+t = __MKINT(np); __INST(position) = t; __STORE(self, t);
-		    } else {
+} else {
-			__INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-		    }
+}
-		    RETURN ( __mkSmallInteger(cnt) );
+RETURN ( __mkSmallInteger(cnt) );
-		} else /* cnt < 0 */ {
+} else /* cnt < 0 */ {
-		    if (
+if (
 #ifdef EWOULDBLOCK
-			(__threadErrno == EWOULDBLOCK) ||
+(__threadErrno == EWOULDBLOCK) ||
 #endif
-			(__threadErrno == EAGAIN)
+(__threadErrno == EAGAIN)
-		    ) {
+) {
-			RETURN ( __mkSmallInteger(0) );
+RETURN ( __mkSmallInteger(0) );
-		    }
+}
-		    __INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-		    error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-		}
+}
-	    }
+}
-	}
+}
 }
 bad: ;
 %}.
 error notNil ifTrue:[
-	lastErrorNumber := error.
+lastErrorNumber := error.
-	self writeError:error.
+self writeError:error.
-	^ self
+^ self
 ].
 handle isNil ifTrue:[^ self errorNotOpen].
 (mode == #readonly) ifTrue:[^ self errorReadOnly].
 ^ self primitiveFailed
 !
 |error|
 %{
 int num;
 union {
-	char bytes[4];
+char bytes[4];
-	int intVal;
+int intVal;
 } u;
 FILEPOINTER f;
 int cnt, _buffered;
 OBJ fp;
 __INST(lastErrorNumber) = nil;
 if (__isSmallInteger(aNumber)) {
-	num = __intVal(aNumber);
+num = __intVal(aNumber);
 } else {
 #if __POINTER_SIZE__ == 8
-	goto badArg;
+goto badArg;
 #else
-	num = __longIntVal(aNumber);
+num = __longIntVal(aNumber);
-	if (num == 0) {
+if (num == 0) {
-	    num = __signedLongIntVal(aNumber);
+num = __signedLongIntVal(aNumber);
-	    if (num == 0) {
+if (num == 0) {
-		/* bad arg or out-of-range integer
+/* bad arg or out-of-range integer
-		 * (handled by the fallBack code)
+* (handled by the fallBack code)
-		 */
+*/
-		goto badArg;
+goto badArg;
-	    }
+}
-	}
+}
 #endif
 }
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if (((fp = __INST(handle)) != nil)
+if (((fp = __INST(handle)) != nil)
-	 && (__INST(mode) != @symbol(readonly))
+&& (__INST(mode) != @symbol(readonly))
-	) {
+) {
-	    if (msbFlag == true) {
+if (msbFlag == true) {
 #if defined(__MSBFIRST__)
-		u.intVal = num;
+u.intVal = num;
 #else
-		u.bytes[0] = (num >> 24) & 0xFF;
+u.bytes[0] = (num >> 24) & 0xFF;
-		u.bytes[1] = (num >> 16) & 0xFF;
+u.bytes[1] = (num >> 16) & 0xFF;
-		u.bytes[2] = (num >> 8) & 0xFF;
+u.bytes[2] = (num >> 8) & 0xFF;
-		u.bytes[3] = num & 0xFF;
+u.bytes[3] = num & 0xFF;
 #endif
-	    } else {
+} else {
 #if defined(__LSBFIRST__)
-		u.intVal = num;
+u.intVal = num;
 #else
-		u.bytes[3] = (num >> 24) & 0xFF;
+u.bytes[3] = (num >> 24) & 0xFF;
-		u.bytes[2] = (num >> 16) & 0xFF;
+u.bytes[2] = (num >> 16) & 0xFF;
-		u.bytes[1] = (num >> 8) & 0xFF;
+u.bytes[1] = (num >> 8) & 0xFF;
-		u.bytes[0] = num & 0xFF;
+u.bytes[0] = num & 0xFF;
 #endif
-	    }
+}
-	    f = __FILEVal(fp);
+f = __FILEVal(fp);
-	    if (_buffered = (__INST(buffered) == true)) {
+if (_buffered = (__INST(buffered) == true)) {
-		__WRITING__(f)
+__WRITING__(f)
-	    }
+}
-	    __WRITEBYTES__(cnt, f, u.bytes, 4, _buffered, __INST(handleType));
+__WRITEBYTES__(cnt, f, u.bytes, 4, _buffered, __INST(handleType));
-	    if (cnt == 4) {
+if (cnt == 4) {
-		if (__isSmallInteger(__INST(position))) {
+if (__isSmallInteger(__INST(position))) {
-		    INT np = __intVal(__INST(position)) + 4;
+INT np = __intVal(__INST(position)) + 4;
-		    OBJ t;
+OBJ t;
-		    t = __MKINT(np); __INST(position) = t; __STORE(self, t);
+t = __MKINT(np); __INST(position) = t; __STORE(self, t);
-		} else {
+} else {
-		    __INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-		}
+}
-		RETURN ( self );
+RETURN ( self );
-	    }
+}
-	    __INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-	    error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-	}
+}
 }
 badArg: ;
 %}.
 handle isNil ifTrue:[self errorNotOpen. ^ self].
 (mode == #readonly) ifTrue:[self errorReadOnly. ^ self].
 error notNil ifTrue:[
-	lastErrorNumber := error.
+lastErrorNumber := error.
-	self writeError:error.
+self writeError:error.
-	^ self
+^ self
 ].
 aNumber isInteger ifTrue:[
-	^ super nextPutLong:aNumber MSB:msbFlag
+^ super nextPutLong:aNumber MSB:msbFlag
 ].
 self argumentMustBeInteger
 !
 nextPutShort:anIntegerOrCharacter MSB:msbFlag
 |error|
 %{
 int num;
 union {
-	char bytes[2];
+char bytes[2];
-	short shortVal;
+short shortVal;
 } u;
 FILEPOINTER f;
 int cnt, _buffered;
 OBJ fp;
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if (((fp = __INST(handle)) != nil)
+if (((fp = __INST(handle)) != nil)
-	    && (__INST(mode) != @symbol(readonly))
+&& (__INST(mode) != @symbol(readonly))
-	) {
+) {
-	    if (__isSmallInteger(anIntegerOrCharacter)) {
+if (__isSmallInteger(anIntegerOrCharacter)) {
-		num = __intVal(anIntegerOrCharacter);
+num = __intVal(anIntegerOrCharacter);
-	    } else if (__isCharacter(anIntegerOrCharacter)) {
+} else if (__isCharacter(anIntegerOrCharacter)) {
-		num = __smallIntegerVal(__characterVal(anIntegerOrCharacter));
+num = __smallIntegerVal(__characterVal(anIntegerOrCharacter));
-	    } else
+} else
-		goto out;
+goto out;
-	    if (msbFlag == true) {
+if (msbFlag == true) {
 #if defined(__MSBFIRST__)
-		u.shortVal = num;
+u.shortVal = num;
 #else
-		u.bytes[0] = (num >> 8) & 0xFF;
+u.bytes[0] = (num >> 8) & 0xFF;
-		u.bytes[1] = num & 0xFF;
+u.bytes[1] = num & 0xFF;
 #endif
-	    } else {
+} else {
 #if defined(__LSBFIRST__)
-		u.shortVal = num;
+u.shortVal = num;
 #else
-		u.bytes[1] = (num >> 8) & 0xFF;
+u.bytes[1] = (num >> 8) & 0xFF;
-		u.bytes[0] = num & 0xFF;
+u.bytes[0] = num & 0xFF;
 #endif
-	    }
+}
-	    f = __FILEVal(fp);
+f = __FILEVal(fp);
-	    if (_buffered = (__INST(buffered) == true)) {
+if (_buffered = (__INST(buffered) == true)) {
-		__WRITING__(f)
+__WRITING__(f)
-	    }
+}
-	    __WRITEBYTES__(cnt, f, u.bytes, 2, _buffered, __INST(handleType));
+__WRITEBYTES__(cnt, f, u.bytes, 2, _buffered, __INST(handleType));
-	    if (cnt == 2) {
+if (cnt == 2) {
-		if (__isSmallInteger(__INST(position))) {
+if (__isSmallInteger(__INST(position))) {
-		    INT np = __intVal(__INST(position)) + 2;
+INT np = __intVal(__INST(position)) + 2;
-		    OBJ t;
+OBJ t;
-		    t = __MKINT(np); __INST(position) = t; __STORE(self, t);
+t = __MKINT(np); __INST(position) = t; __STORE(self, t);
-		} else {
+} else {
-		    __INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-		}
+}
-		RETURN ( self );
+RETURN ( self );
-	    }
+}
-	    __INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-	    error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-	}
+}
 }
 out:;
 %}.
 error notNil ifTrue:[
-	lastErrorNumber := error.
+lastErrorNumber := error.
-	self writeError:error.
+self writeError:error.
-	^ self
+^ self
 ].
 handle isNil ifTrue:[self errorNotOpen. ^ self].
 (mode == #readonly) ifTrue:[self errorReadOnly. ^ self].
 self argumentMustBeInteger
 ! !
 "low level close - may be redefined in subclasses
 Don't send this message, send #close instead"
 |fp error|
+fp := handle.
 %{
-if ((__INST(handleType) == nil)
+int rslt;
-|| (__INST(handleType) == @symbol(filePointer))
-|| (__INST(handleType) == @symbol(socketFilePointer))
+if (fp == nil) {
-|| (__INST(handleType) == @symbol(pipeFilePointer))) {
+error = @symbol(errorNotOpen);
-if ((fp = __INST(handle)) == nil) {
+goto out;
-error = @symbol(errorNotOpen);
+}
-} else {
-FILEPOINTER f = __FILEVal(fp);
+if (__INST(handleType) == @symbol(socketHandle)) {
-int rslt;
+SOCKET sock = __FILEVal(fp);
-// whether the fclose() will be successful or not - the handle is invalid now!
+if (@global(FileOpenTrace) == true) {
-__INST(handle) = nil;
+fprintf(stderr, "close socket [ExternalStream] %"_lx_"\n", sock);
+}
-if (@global(FileOpenTrace) == true) {
-fprintf(stderr, "fclose [ExternalStream] %"_lx_"\n", (INT)f);
+// whether the close() will be successful or not - the handle is invalid now!
-}
+__INST(handle) = nil;
+do {
 #ifdef WIN32
-if (__INST(mode) != @symbol(readonly) && __INST(buffered) != false) {
+rslt = __STX_WSA_NOINT_CALL1("closesocket", closesocket, sock);
-// do a fflush() first, so that fclose() doesn't block
+#else
-// we suspect, that EINTR causes problems in fclose()
+rslt = close(sock);
-do {
+#endif
-__threadErrno = 0;
+} while((rslt < 0) && (__threadErrno == EINTR));
-rslt = __STX_C_CALL1("fflush", fflush, f);
+} else if ((__INST(handleType) == nil)
-} while((rslt < 0) && (__threadErrno == EINTR));
+|| (__INST(handleType) == @symbol(filePointer))
-}
+|| (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(pipeFilePointer)))
+{
+FILEPOINTER f = __FILEVal(fp);
+if (@global(FileOpenTrace) == true) {
+fprintf(stderr, "fclose [ExternalStream] %"_lx_"\n", f);
+}
+// whether the close() will be successful or not - the handle is invalid now!
+__INST(handle) = nil;
+#ifdef WIN32
+if (__INST(mode) != @symbol(readonly) && __INST(buffered) != false) {
+// do a fflush() first, so that fclose() doesn't block
+// we suspect, that EINTR causes problems in fclose()
 do {
 __threadErrno = 0;
-rslt = __STX_C_NOINT_CALL1("fclose", fclose, f);
+rslt = __STX_C_CALL1("fflush", fflush, f);
 } while((rslt < 0) && (__threadErrno == EINTR));
+}
+do {
+__threadErrno = 0;
+rslt = __STX_C_NOINT_CALL1("fclose", fclose, f);
+} while((rslt < 0) && (__threadErrno == EINTR));
 #else
 __BEGIN_INTERRUPTABLE__
 rslt = fclose(f);
 __END_INTERRUPTABLE__
 #endif
-if (rslt < 0) {
+} else {
-error = __mkSmallInteger(__threadErrno);
+error = @symbol(badHandleType);
 goto out;
-}
-}
-RETURN (self);
 }
+if (rslt < 0) {
+error = __mkSmallInteger(__threadErrno);
+goto out;
+}
+RETURN (self);
 out:;
 %}.
 error notNil ifTrue:[
 error == #errorNotOpen ifTrue:[
 self setAccessor:#socketHandle to:something
 ! !
 !ExternalStream methodsFor:'queries'!
-isBinary
+nextError
-"return true, if the stream is in binary (as opposed to text-) mode.
+"return the error by trying to read something.
-The default when created is false."
+Should only be used, when we know, that a read operation
+will return an error (otherwise a character may be lost).
-^ binary
+Return an integer (error number), 0 (EOF) or nil (no error)"
-!
+%{ /*NOCONTEXT*/
-isBlocking
+FILEPOINTER f;
-"return true, if O_NONBLOCK is NOT set in the fileDescriptor (probably UNIX specific)"
+int ret, _buffered;
+OBJ fp;
+unsigned char ch;
+if ((__INST(handleType) == nil)
+|| (__INST(handleType) == @symbol(filePointer))
+|| (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
+|| (__INST(handleType) == @symbol(pipeFilePointer))) {
+if (((fp = __INST(handle)) != nil)
+&& (__INST(mode) != @symbol(writeonly))
+) {
+f = __FILEVal(fp);
+_buffered = (__INST(buffered) == true);
+if (_buffered) {
+__READING__(f)
+}
+__READBYTE__(ret, f, &ch, _buffered, __INST(handleType));
+if (ret > 0) {
+RETURN(nil)
+}
+if (ret < 0) {
+RETURN(__mkSmallInteger(__threadErrno));
+} else /* ret == 0 */ {
+RETURN(__mkSmallInteger(0)); /* EOF */
+}
+}
+}
+%}.
+!
+numAvailable
+"return the number of bytes available for reading"
+|fd|
 handle isNil ifTrue:[^ self errorNotOpen].
-^ OperatingSystem isBlockingOn:self fileDescriptor
+mode == #writeonly ifTrue:[^ self errorWriteOnly].
-!
+fd := self fileDescriptor.
-isExternalStream
+%{
-"return true, if the receiver is some kind of externalStream;
+#ifdef WIN32
-true is returned here - the method redefined from Object."
+int res = 1;
+int success = 0;
-^ true
-!
+if (__INST(handleType) == @symbol(socketHandle)) {
+success = ioctlsocket((SOCKET)__externalAddressVal(fd), FIONREAD, &res) == 0;
-isOpen
+} else if (__INST(handleType) == @symbol(socketFilePointer)) {
-"return true, if this stream is open"
+success = ioctlsocket((SOCKET)_get_osfhandle(__intVal(fd)), FIONREAD, &res) == 0;
+} else if (__INST(handleType) == @symbol(pipeFilePointer)) {
-^ handle notNil
+success = PeekNamedPipe((HANDLE)_get_osfhandle(__intVal(fd)),0,0,0,&res,0);
-!
+}
+if (success) {
-isReadable
+if (__INST(readAhead) != nil) res++;
-"return true, if this stream can be read from"
+RETURN(__mkSmallInteger(res));
+}
-^ (mode ~~ #writeonly)
+#endif
-!
+%}.
-isWritable
+^ (readAhead notNil or:[OperatingSystem readCheck:fd]) ifTrue:[1] ifFalse:[0].
-"return true, if this stream can be written to"
+"Created: / 4.2.1998 / 16:56:01 / cg"
-^ (mode ~~ #readonly)
+"Modified: / 4.2.1998 / 17:31:11 / cg"
 ! !
 !ExternalStream methodsFor:'reading'!
 next
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if (((fp = __INST(handle)) != nil)
+if (((fp = __INST(handle)) != nil)
-	    && (__INST(mode) != @symbol(writeonly))
+&& (__INST(mode) != @symbol(writeonly))
-	) {
+) {
-	    f = __FILEVal(fp);
+f = __FILEVal(fp);
-	    _buffered = (__INST(buffered) == true);
+_buffered = (__INST(buffered) == true);
-	    if (_buffered) {
+if (_buffered) {
-		__READING__(f)
+__READING__(f)
-	    }
+}
-	    __READBYTE__(ret, f, &ch, _buffered, __INST(handleType));
+__READBYTE__(ret, f, &ch, _buffered, __INST(handleType));
-	    if (ret > 0) {
+if (ret > 0) {
-		pos = __INST(position);
+pos = __INST(position);
-		if (__isSmallInteger(pos)) {
+if (__isSmallInteger(pos)) {
-		    OBJ t;
+OBJ t;
-		    t = __MKINT(__intVal(pos) + 1); __INST(position) = t; __STORE(self, t);
+t = __MKINT(__intVal(pos) + 1); __INST(position) = t; __STORE(self, t);
-		} else {
+} else {
-		    __INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-		}
+}
-		if (__INST(binary) == true) {
+if (__INST(binary) == true) {
-		    RETURN ( __mkSmallInteger(ch) );
+RETURN ( __mkSmallInteger(ch) );
-		}
+}
-		RETURN ( __MKCHARACTER(ch) );
+RETURN ( __MKCHARACTER(ch) );
-	    }
+}
-	    __INST(position) = nil;
+__INST(position) = nil;
-	    if (ret < 0) {
+if (ret < 0) {
-		error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-	    } else /* ret == 0 */ {
+} else /* ret == 0 */ {
-		__INST(hitEOF) = true;
+__INST(hitEOF) = true;
-	    }
+}
-	}
+}
 }
 %}.
 hitEOF == true ifTrue:[^ self pastEndRead].
 error notNil ifTrue:[
-	lastErrorNumber := error.
+lastErrorNumber := error.
-	^ self readError:error
+^ self readError:error
 ].
 handle isNil ifTrue:[^ self errorNotOpen].
 (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
 readAhead notNil ifTrue:[
-	c := readAhead.
+c := readAhead.
-	readAhead := nil.
+readAhead := nil.
-	^ c.
+^ c.
 ].
 c := self nextByteFromFile:handle.
 c isNil ifTrue:[
-	^ self pastEndRead.
+^ self pastEndRead.
 ].
 binary == true ifTrue:[
-	^ c
+^ c
 ].
 ^ Character value:c
 !
 next:count
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if (((fp = __INST(handle)) != nil)
+if (((fp = __INST(handle)) != nil)
-	    && (__INST(mode) != @symbol(writeonly))
+&& (__INST(mode) != @symbol(writeonly))
-	) {
+) {
-	    f = __FILEVal(fp);
+f = __FILEVal(fp);
-	    _buffered = (__INST(buffered) == true);
+_buffered = (__INST(buffered) == true);
-	    if (_buffered) {
+if (_buffered) {
-		__READING__(f)
+__READING__(f)
-	    }
+}
-	    __READBYTE__(ret, f, &ch, _buffered, __INST(handleType));
+__READBYTE__(ret, f, &ch, _buffered, __INST(handleType));
-	    if (ret > 0) {
+if (ret > 0) {
-		pos = __INST(position);
+pos = __INST(position);
-		if (__isSmallInteger(pos)) {
+if (__isSmallInteger(pos)) {
-		    OBJ t;
+OBJ t;
-		    t = __MKINT(__intVal(pos) + 1); __INST(position) = t; __STORE(self, t);
+t = __MKINT(__intVal(pos) + 1); __INST(position) = t; __STORE(self, t);
-		} else {
+} else {
-		    __INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-		}
+}
-		if (__INST(binary) == true) {
+if (__INST(binary) == true) {
-		    RETURN ( __mkSmallInteger(ch) );
+RETURN ( __mkSmallInteger(ch) );
-		}
+}
-		RETURN ( __MKCHARACTER(ch) );
+RETURN ( __MKCHARACTER(ch) );
-	    }
+}
-	    __INST(position) = nil;
+__INST(position) = nil;
-	    if (ret < 0) {
+if (ret < 0) {
-		error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-	    } else /* ret == 0 */ {
+} else /* ret == 0 */ {
-		__INST(hitEOF) = true;
+__INST(hitEOF) = true;
-	    }
+}
-	}
+}
 }
 %}.
 hitEOF == true ifTrue:[^ nil].
 error notNil ifTrue:[
-	lastErrorNumber := error.
+lastErrorNumber := error.
-	^ self readError:error.
+^ self readError:error.
 ].
 handle isNil ifTrue:[^ self errorNotOpen].
 (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
 readAhead notNil ifTrue:[
-	c := readAhead.
+c := readAhead.
-	readAhead := nil.
+readAhead := nil.
-	^ c.
+^ c.
 ].
 c := self nextByteFromFile:handle.
 c isNil ifTrue:[
-	^ nil.
+^ nil.
 ].
 binary == true ifTrue:[
-	^ c
+^ c
 ].
 ^ Character value:c
 !
 peek
 int ret, _buffered;
 OBJ fp;
 OBJ ra;
 if ((ra = __INST(readAhead)) != nil) {
-	if (__INST(binary) == true) {
+if (__INST(binary) == true) {
-	    RETURN ( ra );
+RETURN ( ra );
-	}
+}
-	c = __intVal(ra);
+c = __intVal(ra);
-	RETURN ( __MKCHARACTER(c) );
+RETURN ( __MKCHARACTER(c) );
 }
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if (((fp = __INST(handle)) != nil)
+if (((fp = __INST(handle)) != nil)
-	    && (__INST(mode) != @symbol(writeonly))
+&& (__INST(mode) != @symbol(writeonly))
-	) {
+) {
-	    f = __FILEVal(fp);
+f = __FILEVal(fp);
-	    _buffered = (__INST(buffered) == true);
+_buffered = (__INST(buffered) == true);
-	    if (_buffered) {
+if (_buffered) {
-		__READING__(f)
+__READING__(f)
-	    }
+}
-	    __READBYTE__(ret, f, &c, _buffered, __INST(handleType));
+__READBYTE__(ret, f, &c, _buffered, __INST(handleType));
-	    if (ret > 0) {
+if (ret > 0) {
-		__UNGETC__(c, f, _buffered);
+__UNGETC__(c, f, _buffered);
-		if (__INST(binary) == true) {
+if (__INST(binary) == true) {
-		    RETURN ( __mkSmallInteger(c) );
+RETURN ( __mkSmallInteger(c) );
-		}
+}
-		RETURN ( __MKCHARACTER(c) );
+RETURN ( __MKCHARACTER(c) );
-	    }
+}
-	    if (ret < 0) {
+if (ret < 0) {
-		error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-	    } else /* ret == 0 */ {
+} else /* ret == 0 */ {
-		__INST(hitEOF) = true;
+__INST(hitEOF) = true;
-	    }
+}
-	}
+}
 }
 %}.
 hitEOF == true ifTrue:[^ self pastEndRead].
 error notNil ifTrue:[
-	lastErrorNumber := error.
+lastErrorNumber := error.
-	^ self readError:error.
+^ self readError:error.
 ].
 handle isNil ifTrue:[^ self errorNotOpen].
 (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
 readAhead isNil ifTrue:[
-	readAhead := self nextOrNil.
+readAhead := self nextOrNil.
-	readAhead isNil ifTrue:[
+readAhead isNil ifTrue:[
-	    ^ self pastEndRead.
+^ self pastEndRead.
-	].
+].
 ].
 ^ readAhead
 !
 peekOrNil
 int ret, _buffered;
 OBJ fp;
 OBJ ra;
 if ((ra = __INST(readAhead)) != nil) {
-	if (__INST(binary) == true) {
+if (__INST(binary) == true) {
-	    RETURN ( ra );
+RETURN ( ra );
-	}
+}
-	c = __intVal(ra);
+c = __intVal(ra);
-	RETURN ( __MKCHARACTER(c) );
+RETURN ( __MKCHARACTER(c) );
 }
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if (((fp = __INST(handle)) != nil)
+if (((fp = __INST(handle)) != nil)
-	    && (__INST(mode) != @symbol(writeonly))
+&& (__INST(mode) != @symbol(writeonly))
-	) {
+) {
-	    f = __FILEVal(fp);
+f = __FILEVal(fp);
-	    _buffered = (__INST(buffered) == true);
+_buffered = (__INST(buffered) == true);
-	    if (_buffered) {
+if (_buffered) {
-		__READING__(f)
+__READING__(f)
-	    }
+}
-	    __READBYTE__(ret, f, &c, _buffered, __INST(handleType));
+__READBYTE__(ret, f, &c, _buffered, __INST(handleType));
-	    if (ret > 0) {
+if (ret > 0) {
-		__UNGETC__(c, f, _buffered);
+__UNGETC__(c, f, _buffered);
-		if (__INST(binary) == true) {
+if (__INST(binary) == true) {
-		    RETURN ( __mkSmallInteger(c) );
+RETURN ( __mkSmallInteger(c) );
-		}
+}
-		RETURN ( __MKCHARACTER(c) );
+RETURN ( __MKCHARACTER(c) );
-	    }
+}
-	    if (ret < 0) {
+if (ret < 0) {
-		error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-	    } else /* ret == 0 */ {
+} else /* ret == 0 */ {
-		__INST(hitEOF) = true;
+__INST(hitEOF) = true;
-	    }
+}
-	}
+}
 }
 %}.
 hitEOF == true ifTrue:[^ nil].
 error notNil ifTrue:[
-	lastErrorNumber := error.
+lastErrorNumber := error.
-	^ self readError:error.
+^ self readError:error.
 ].
 handle isNil ifTrue:[^ self errorNotOpen].
 (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
 readAhead isNil ifTrue:[
-	readAhead := self nextOrNil.
+readAhead := self nextOrNil.
 ].
 ^ readAhead
 !
 upToEnd
 OBJ fp, pos, lim;
 char c;
 int ret, _buffered;
 if (__INST(hitEOF) == true) {
-	RETURN (true);
+RETURN (true);
 }
 pos = __INST(position);
 lim = __INST(readLimit);
 if (lim != nil) {
-	off_t _pos, _readLimit;
+off_t _pos, _readLimit;
-	_pos = __signedLongIntVal(pos);
+_pos = __signedLongIntVal(pos);
-	_pos = _pos - __intVal( @global(PositionableStream:ZeroPosition)) + 1;
+_pos = _pos - __intVal( @global(PositionableStream:ZeroPosition)) + 1;
-	_readLimit = __signedLongIntVal(lim);
+_readLimit = __signedLongIntVal(lim);
-	if (_pos > _readLimit) {
+if (_pos > _readLimit) {
-	    RETURN (true);
+RETURN (true);
-	}
+}
 }
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if ((fp = __INST(handle)) != nil) {
+if ((fp = __INST(handle)) != nil) {
-	    f = __FILEVal(fp);
+f = __FILEVal(fp);
-	    if (_buffered = (__INST(buffered) == true)) {
+if (_buffered = (__INST(buffered) == true)) {
-		__READING__(f);
+__READING__(f);
-	    } else {
+} else {
-		if (__INST(readAhead) != nil) {
+if (__INST(readAhead) != nil) {
-		    RETURN (false);
+RETURN (false);
-		}
+}
-	    }
+}
-	    /*
+/*
-	     * read ahead ...
+* read ahead ...
-	     */
+*/
-	    do {
+do {
 #ifdef WIN32
 # if 1
-		__READBYTE__(ret, f, &c, _buffered, __INST(handleType));
+__READBYTE__(ret, f, &c, _buffered, __INST(handleType));
 # else
-		__BEGIN_INTERRUPTABLE__
+__BEGIN_INTERRUPTABLE__
-		__READBYTE__(ret, f, &c, _buffered, __INST(handleType));
+__READBYTE__(ret, f, &c, _buffered, __INST(handleType));
-		__END_INTERRUPTABLE__
+__END_INTERRUPTABLE__
 # endif
 #else /* not WIN32 */
-		__BEGIN_INTERRUPTABLE__
+__BEGIN_INTERRUPTABLE__
-		__READBYTE__(ret, f, &c, _buffered, __INST(handleType));
+__READBYTE__(ret, f, &c, _buffered, __INST(handleType));
-		__END_INTERRUPTABLE__
+__END_INTERRUPTABLE__
 #endif
-	    } while ((ret < 0) && (__threadErrno == EINTR));
+} while ((ret < 0) && (__threadErrno == EINTR));
 #if defined(WIN32) && defined(EPIPE)
-	    if (ret < 0) {
+if (ret < 0) {
-		if (__threadErrno == EPIPE) {
+if (__threadErrno == EPIPE) {
-		    ret = 0;
+ret = 0;
-		    __threadErrno = 0;
+__threadErrno = 0;
-		}
+}
-		if (__threadErrno == 0) {
+if (__threadErrno == 0) {
-		    ret = 0;   /* how comes ? */
+ret = 0;   /* how comes ? */
-		}
+}
-	    }
+}
 #endif
-	    if (ret > 0) {
+if (ret > 0) {
-		__UNGETC__(c&0xff, f, _buffered);
+__UNGETC__(c&0xff, f, _buffered);
-		RETURN (false);
+RETURN (false);
-	    }
+}
-	    if (ret == 0) {
+if (ret == 0) {
-		__INST(hitEOF) = true;
+__INST(hitEOF) = true;
-		RETURN (true);
+RETURN (true);
-	    }
+}
-	    /* ret < 0 */
+/* ret < 0 */
-	    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
+__INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
-	}
+}
 }
 %}.
 lastErrorNumber notNil ifTrue:[^ self readError].
 handle isNil ifTrue:[^ self errorNotOpen].
 mode == #writeonly ifTrue:[^ self errorWriteOnly].
 readAhead notNil ifTrue:[^ false].
 "/ migration support
 ^ self
-	atEndFile:handle
+atEndFile:handle
 "Modified: / 30.10.1998 / 20:16:06 / cg"
 !
 canReadWithoutBlocking
 "return true, if any data is available for reading (i.e.
-a read operation will not block the smalltalk process), false otherwise."
+a read operation will not block the smalltalk process), false otherwise.
+We know, that error conditions do not block, so return true for errors."
-|fd|
+^ readAhead notNil
-readAhead notNil ifTrue:[^ true].
+	or:[handle isNil]
-handle isNil ifTrue:[^ self errorNotOpen].
+	or:[mode == #writeonly
-mode == #writeonly ifTrue:[^ self errorWriteOnly].
+	or:[OperatingSystem readCheck:self fileDescriptor]]
-fd := self fileDescriptor.
-^ OperatingSystem readCheck:fd
 "
 |pipe|
 pipe := PipeStream readingFrom:'(sleep 10; echo hello)'.
 "Modified: 25.9.1997 / 13:08:45 / stefan"
 !
 canWriteWithoutBlocking
 "return true, if data can be written into the stream
-(i.e. a write operation will not block the smalltalk process)."
+(i.e. a write operation will not block the smalltalk process).
+We know, that error conditions do not block, so return true for errors."
-|fd|
+^ handle isNil
-handle isNil ifTrue:[^ self errorNotOpen].
+	or:[mode == #readonly
-mode == #readonly ifTrue:[^ self errorReadOnly].
+	or:[OperatingSystem writeCheck:self fileDescriptor]]
-fd := self fileDescriptor.
-^ OperatingSystem writeCheck:fd
 !
 gotErrorOrEOF
 "answerv true, if amn error or eof has been occured on the stream"
 ^ hitEOF == true or:[lastErrorNumber notNil]
 !
-nextError
+isBinary
-"return the error by trying to read something.
+"return true, if the stream is in binary (as opposed to text-) mode.
-Should only be used, when we know, that a read operation
+The default when created is false."
-will return an error (otherwise a character may be lost).
-Return an integer (error number), 0 (EOF) or nil (no error)"
+^ binary
+!
-%{ /*NOCONTEXT*/
-FILEPOINTER f;
+isBlocking
-int ret, _buffered;
+"return true, if O_NONBLOCK is NOT set in the fileDescriptor (probably UNIX specific)"
-OBJ fp;
-unsigned char ch;
-if ((__INST(handleType) == nil)
-|| (__INST(handleType) == @symbol(filePointer))
-|| (__INST(handleType) == @symbol(socketFilePointer))
-|| (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if (((fp = __INST(handle)) != nil)
-	    && (__INST(mode) != @symbol(writeonly))
-	) {
-	    f = __FILEVal(fp);
-	    _buffered = (__INST(buffered) == true);
-	    if (_buffered) {
-		__READING__(f)
-	    }
-	    __READBYTE__(ret, f, &ch, _buffered, __INST(handleType));
-	    if (ret > 0) {
-		RETURN(nil)
-	    }
-	    if (ret < 0) {
-		RETURN(__mkSmallInteger(__threadErrno));
-	    } else /* ret == 0 */ {
-		RETURN(__mkSmallInteger(0)); /* EOF */
-	    }
-	}
-}
-%}.
-!
-numAvailable
-"return the number of bytes available for reading"
-|fd|
 handle isNil ifTrue:[^ self errorNotOpen].
-mode == #writeonly ifTrue:[^ self errorWriteOnly].
+^ OperatingSystem isBlockingOn:self fileDescriptor
+!
-fd := self fileDescriptor.
-^ OperatingSystem numAvailableForReadOn:fd.
+isExternalStream
+"return true, if the receiver is some kind of externalStream;
-"/    self atEnd ifTrue:[^ 0].
+true is returned here - the method redefined from Object."
-"/    self canReadWithoutBlocking ifTrue:[
-"/        ^ 1
+^ true
-"/    ].
+!
-"/    ^ 0
+isOpen
-"Created: / 4.2.1998 / 16:56:01 / cg"
+"return true, if this stream is open"
-"Modified: / 4.2.1998 / 17:31:11 / cg"
+^ handle notNil
+!
+isReadable
+"return true, if this stream can be read from"
+^ (mode ~~ #writeonly)
+!
+isWritable
+"return true, if this stream can be written to"
+^ (mode ~~ #readonly)
 ! !
 !ExternalStream methodsFor:'waiting for I/O'!
 canBeSelected
 OBJ fp;
 char *cp;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(socketFilePointer))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-	__INST(lastErrorNumber) = nil;
+__INST(lastErrorNumber) = nil;
-	if (((fp = __INST(handle)) != nil)
+if (((fp = __INST(handle)) != nil)
-	    && (__INST(mode) != @symbol(readonly))
+&& (__INST(mode) != @symbol(readonly))
-	    && (__INST(binary) != true)
+&& (__INST(binary) != true)
-	) {
+) {
-	    f = __FILEVal(fp);
+f = __FILEVal(fp);
-	    if (_buffered = (__INST(buffered) == true)) {
+if (_buffered = (__INST(buffered) == true)) {
-		__WRITING__(f)
+__WRITING__(f)
-	    }
+}
-	    {
+{
-		OBJ mode = __INST(eolMode);
+OBJ mode = __INST(eolMode);
-		if (mode == @symbol(cr)) {
+if (mode == @symbol(cr)) {
-		    cp = "\r"; len = 1;
+cp = "\r"; len = 1;
-		} else if (mode == @symbol(crlf)) {
+} else if (mode == @symbol(crlf)) {
-		    cp = "\r\n"; len = 2;
+cp = "\r\n"; len = 2;
-		} else {
+} else {
-		    cp = "\n"; len = 1;
+cp = "\n"; len = 1;
-		}
+}
-	    }
+}
 #ifdef WIN32
-	    if ((f == __win32_stdout()) || (f == __win32_stderr())) {
+if ((f == __win32_stdout()) || (f == __win32_stderr())) {
-		cnt = __win32_fwrite(cp, 1, len, f);
+cnt = __win32_fwrite(cp, 1, len, f);
-	    } else
+} else
 #endif
-	    {
+{
-		__WRITEBYTES__(cnt, f, cp, len, _buffered, __INST(handleType));
+__WRITEBYTES__(cnt, f, cp, len, _buffered, __INST(handleType));
-	    }
+}
-	    if (cnt == len) {
+if (cnt == len) {
-		if (__isSmallInteger(__INST(position))) {
+if (__isSmallInteger(__INST(position))) {
-		    INT np = __intVal(__INST(position)) + len;
+INT np = __intVal(__INST(position)) + len;
-		    OBJ t;
+OBJ t;
-		    t = __MKINT(np); __INST(position) = t; __STORE(self, t);
+t = __MKINT(np); __INST(position) = t; __STORE(self, t);
-		} else {
+} else {
-		    __INST(position) = nil; /* i.e: dont know */
+__INST(position) = nil; /* i.e: dont know */
-		}
+}
-		RETURN ( self );
+RETURN ( self );
-	    }
+}
-	    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
+__INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
-	}
+}
 }
 %}.
 lastErrorNumber notNil ifTrue:[self writeError. ^ self].
 handle isNil ifTrue:[self errorNotOpen. ^ self].
 (mode == #readonly) ifTrue:[self errorReadOnly. ^ self].
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if (((fp = __INST(handle)) != nil)
+if (((fp = __INST(handle)) != nil)
-	    && (__INST(mode) != @symbol(readonly))
+&& (__INST(mode) != @symbol(readonly))
-	) {
+) {
-	    if (__INST(binary) != true) {
+if (__INST(binary) != true) {
-		if (__isCharacter(aCharacter)) {
+if (__isCharacter(aCharacter)) {
-		    codePoint = __intVal(__characterVal(aCharacter));
+codePoint = __intVal(__characterVal(aCharacter));
-		    if (codePoint <= 0xFF) {
+if (codePoint <= 0xFF) {
-			c = codePoint;
+c = codePoint;
 doWrite:
-			f = __FILEVal(fp);
+f = __FILEVal(fp);
-			if (! f) {
+if (! f) {
-			    fprintf(stderr, "oops - fileHandle is NULL in nextPut:\n");
+fprintf(stderr, "oops - fileHandle is NULL in nextPut:\n");
-			    __INST(handle) = nil;
+__INST(handle) = nil;
-			    goto out;
+goto out;
-			}
+}
-			if (_buffered = (__INST(buffered) == true)) {
+if (_buffered = (__INST(buffered) == true)) {
-			    __WRITING__(f)
+__WRITING__(f)
-			}
+}
 #ifdef WIN32
-			if ((f == __win32_stdout()) || (f == __win32_stderr())) {
+if ((f == __win32_stdout()) || (f == __win32_stderr())) {
-			    cnt = __win32_fwrite(&c, 1, 1, f);
+cnt = __win32_fwrite(&c, 1, 1, f);
-			} else
+} else
 #endif
-			__WRITEBYTE__(cnt, f, &c, _buffered, __INST(handleType));
+__WRITEBYTE__(cnt, f, &c, _buffered, __INST(handleType));
-			if (cnt == 1) {
+if (cnt == 1) {
-			    if (__isSmallInteger(__INST(position))) {
+if (__isSmallInteger(__INST(position))) {
-				INT np = __intVal(__INST(position)) + 1;
+INT np = __intVal(__INST(position)) + 1;
-				OBJ t;
+OBJ t;
-				t = __MKINT(np); __INST(position) = t; __STORE(self, t);
+t = __MKINT(np); __INST(position) = t; __STORE(self, t);
-			    } else {
+} else {
-				__INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-			    }
+}
-			    RETURN ( self );
+RETURN ( self );
-			}
+}
-			error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-		    }
+}
-		}
+}
-	    } else {
+} else {
-		if (__isSmallInteger(aCharacter)) {
+if (__isSmallInteger(aCharacter)) {
-		    c = __intVal(aCharacter);
+c = __intVal(aCharacter);
-		    goto doWrite;
+goto doWrite;
-		}
+}
-	    }
+}
-	}
+}
 }
 out: ;
 %}.
 error notNil ifTrue:[
-	lastErrorNumber := error.
+lastErrorNumber := error.
-	self writeError:error.
+self writeError:error.
-	^ self
+^ self
 ].
 handle isNil ifTrue:[self errorNotOpen. ^ self].
 (mode == #readonly) ifTrue:[self errorReadOnly. ^ self].
 binary == true ifFalse:[
-	(aCharacter isCharacter not
+(aCharacter isCharacter not
-	or:[aCharacter codePoint > 16rFF]) ifTrue:[
+or:[aCharacter codePoint > 16rFF]) ifTrue:[
-	    self argumentMustBeCharacter.
+self argumentMustBeCharacter.
-	    ^ self.
+^ self.
-	].
+].
 ] ifTrue:[
-	aCharacter isInteger ifFalse:[
+aCharacter isInteger ifFalse:[
-	    self argumentMustBeInteger.
+self argumentMustBeInteger.
-	    ^ self.
+^ self.
-	].
+].
 ].
 "/ migration support
 self
-	nextPutByte:aCharacter asInteger
+nextPutByte:aCharacter asInteger
-	toFile:handle
+toFile:handle
 !
 nextPutAll:aCollection
 "write all elements of the argument, aCollection.
 Reimplemented for speed when writing strings or byteArrays.
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if (((fp = __INST(handle)) != nil)
+if (((fp = __INST(handle)) != nil)
-	    && (__INST(mode) != @symbol(readonly))
+&& (__INST(mode) != @symbol(readonly))
-	) {
+) {
-	    f = __FILEVal(fp);
+f = __FILEVal(fp);
-	    if (! f) {
+if (! f) {
-		fprintf(stderr, "oops - fileHandle is NULL in nextPutAll:\n");
+fprintf(stderr, "oops - fileHandle is NULL in nextPutAll:\n");
-		__INST(handle) = nil;
+__INST(handle) = nil;
-		goto out;
+goto out;
-	    }
+}
-	    if (_buffered = (__INST(buffered) == true)) {
+if (_buffered = (__INST(buffered) == true)) {
-		__WRITING__(f)
+__WRITING__(f)
-	    }
+}
-	    if (__isStringLike(aCollection)) {
+if (__isStringLike(aCollection)) {
-		len = __stringSize(aCollection);
+len = __stringSize(aCollection);
 #ifdef WIN32
-		if ((f == __win32_stdout()) || (f == __win32_stderr())) {
+if ((f == __win32_stdout()) || (f == __win32_stderr())) {
-		    cnt = __win32_fwrite(__stringVal(aCollection), 1, len, f);
+cnt = __win32_fwrite(__stringVal(aCollection), 1, len, f);
-		} else
+} else
 #endif
-		{
+{
-		    o_offs = (char *)__stringVal(aCollection)-(char *)__InstPtr(aCollection);
+o_offs = (char *)__stringVal(aCollection)-(char *)__InstPtr(aCollection);
-		    __WRITEBYTES_OBJ__(cnt, f, aCollection, o_offs, len, _buffered, __INST(handleType));
+__WRITEBYTES_OBJ__(cnt, f, aCollection, o_offs, len, _buffered, __INST(handleType));
-		}
+}
-	    } else {
+} else {
-		if (__INST(binary) == true) {
+if (__INST(binary) == true) {
-		    INT offs;
+INT offs;
-		    if (__isByteArrayLike(aCollection)) {
+if (__isByteArrayLike(aCollection)) {
-			offs = 0;
+offs = 0;
-			len = __byteArraySize(aCollection);
+len = __byteArraySize(aCollection);
-		    } else if (__isBytes(aCollection)) {
+} else if (__isBytes(aCollection)) {
-			offs = __OBJS2BYTES__(__intVal(__ClassInstPtr(__qClass(aCollection))->c_ninstvars));
+offs = __OBJS2BYTES__(__intVal(__ClassInstPtr(__qClass(aCollection))->c_ninstvars));
-			len = __byteArraySize(aCollection) - offs;
+len = __byteArraySize(aCollection) - offs;
-		    } else
+} else
-			goto out;
+goto out;
 #ifdef WIN32
-		    if ((f == __win32_stdout()) || (f == __win32_stderr())) {
+if ((f == __win32_stdout()) || (f == __win32_stderr())) {
-			cnt = __win32_fwrite(__stringVal(aCollection), 1, len, f);
+cnt = __win32_fwrite(__stringVal(aCollection), 1, len, f);
-		    } else
+} else
 #endif
-		    {
+{
-			o_offs = (char *)(__ByteArrayInstPtr(aCollection)->ba_element) - (char *)__InstPtr(aCollection);
+o_offs = (char *)(__ByteArrayInstPtr(aCollection)->ba_element) - (char *)__InstPtr(aCollection);
-			o_offs += offs;
+o_offs += offs;
-			__WRITEBYTES_OBJ__(cnt, f, aCollection, o_offs, len, _buffered, __INST(handleType));
+__WRITEBYTES_OBJ__(cnt, f, aCollection, o_offs, len, _buffered, __INST(handleType));
-		    }
+}
-		} else
+} else
-		    goto out;
+goto out;
-	    }
+}
-	    if (cnt == len) {
+if (cnt == len) {
-		if (__isSmallInteger(__INST(position))) {
+if (__isSmallInteger(__INST(position))) {
-		    INT np = __intVal(__INST(position)) + len;
+INT np = __intVal(__INST(position)) + len;
-		    OBJ t;
+OBJ t;
-		    t = __MKINT(np); __INST(position) = t; __STORE(self, t);
+t = __MKINT(np); __INST(position) = t; __STORE(self, t);
-		} else {
+} else {
-		    __INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-		}
+}
-		RETURN (self);
+RETURN (self);
-	    }
+}
-	    error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-	}
+}
 }
 out: ;
 %}.
 error notNil ifTrue:[
-	lastErrorNumber := error.
+lastErrorNumber := error.
-	self writeError:error.
+self writeError:error.
-	^ self
+^ self
 ].
 handle isNil ifTrue:[self errorNotOpen. ^ self].
 (mode == #readonly) ifTrue:[self errorReadOnly. ^ self].
 ^ super nextPutAll:aCollection
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-	if (((fp = __INST(handle)) != nil)
+if (((fp = __INST(handle)) != nil)
-	    && (__INST(mode) != @symbol(readonly))
+&& (__INST(mode) != @symbol(readonly))
-	    && __bothSmallInteger(start, stop)
+&& __bothSmallInteger(start, stop)
-	) {
+) {
-	    f = __FILEVal(fp);
+f = __FILEVal(fp);
-	    if (_buffered = (__INST(buffered) == true)) {
+if (_buffered = (__INST(buffered) == true)) {
-		__WRITING__(f)
+__WRITING__(f)
-	    }
+}
-	    iStart = __intVal(start);
+iStart = __intVal(start);
-	    iStop = __intVal(stop);
+iStop = __intVal(stop);
-	    if ((iStart < 1) || (iStop < iStart)) {
+if ((iStart < 1) || (iStop < iStart)) {
-		RETURN(self);
+RETURN(self);
-	    }
+}
-	    if (__isStringLike(aCollection)) {
+if (__isStringLike(aCollection)) {
-		len = __stringSize(aCollection);
+len = __stringSize(aCollection);
-		if (iStop > len) {
+if (iStop > len) {
-		    RETURN(self);
+RETURN(self);
-		}
+}
-		if (iStop > len)
+if (iStop > len)
-		    iStop = len;
+iStop = len;
-		len = iStop - iStart + 1;
+len = iStop - iStart + 1;
 #ifdef WIN32
-		if ((f == __win32_stdout()) || (f == __win32_stderr())) {
+if ((f == __win32_stdout()) || (f == __win32_stderr())) {
-		    cnt = __win32_fwrite(__stringVal(aCollection)+iStart-1, 1, len, f);
+cnt = __win32_fwrite(__stringVal(aCollection)+iStart-1, 1, len, f);
-		} else
+} else
 #endif
-		{
+{
-		    o_offs = (char *)__stringVal(aCollection)-(char *)__InstPtr(aCollection);
+o_offs = (char *)__stringVal(aCollection)-(char *)__InstPtr(aCollection);
-		    __WRITEBYTES_OBJ__(cnt, f, aCollection, o_offs+iStart-1, len, _buffered, __INST(handleType));
+__WRITEBYTES_OBJ__(cnt, f, aCollection, o_offs+iStart-1, len, _buffered, __INST(handleType));
-		}
+}
-	    } else {
+} else {
-		if (__INST(binary) == true) {
+if (__INST(binary) == true) {
-		    int offs;
+int offs;
-		    if (__isByteArrayLike(aCollection)) {
+if (__isByteArrayLike(aCollection)) {
-			offs = 0;
+offs = 0;
-			len = __byteArraySize(aCollection);
+len = __byteArraySize(aCollection);
-		    } else if (__isBytes(aCollection)) {
+} else if (__isBytes(aCollection)) {
-			offs = __OBJS2BYTES__(__intVal(__ClassInstPtr(__qClass(aCollection))->c_ninstvars));
+offs = __OBJS2BYTES__(__intVal(__ClassInstPtr(__qClass(aCollection))->c_ninstvars));
-			len = __byteArraySize(aCollection) - offs;
+len = __byteArraySize(aCollection) - offs;
-		    } else
+} else
-			goto out;
+goto out;
-		    if (iStop > len) {
+if (iStop > len) {
-			RETURN(self);
+RETURN(self);
-		    }
+}
-		    if (iStop > len)
+if (iStop > len)
-			iStop = len;
+iStop = len;
-		    len = iStop - iStart + 1;
+len = iStop - iStart + 1;
-		    offs += iStart - 1;
+offs += iStart - 1;
 #ifdef WIN32
-		    if ((f == __win32_stdout()) || (f == __win32_stderr())) {
+if ((f == __win32_stdout()) || (f == __win32_stderr())) {
-			cnt = __win32_fwrite(__stringVal(aCollection)+iStart-1, 1, len, f);
+cnt = __win32_fwrite(__stringVal(aCollection)+iStart-1, 1, len, f);
-		    } else
+} else
 #endif
-		    {
+{
-			o_offs = (char *)(__ByteArrayInstPtr(aCollection)->ba_element)-(char *)__InstPtr(aCollection);
+o_offs = (char *)(__ByteArrayInstPtr(aCollection)->ba_element)-(char *)__InstPtr(aCollection);
-			__WRITEBYTES_OBJ__(cnt, f,  aCollection, o_offs+offs, len, _buffered, __INST(handleType));
+__WRITEBYTES_OBJ__(cnt, f,  aCollection, o_offs+offs, len, _buffered, __INST(handleType));
-		    }
+}
-		} else
+} else
-		    goto out;
+goto out;
-	    }
+}
-	    if (cnt == len) {
+if (cnt == len) {
-		if (__isSmallInteger(__INST(position))) {
+if (__isSmallInteger(__INST(position))) {
-		    INT np = __intVal(__INST(position)) + len;
+INT np = __intVal(__INST(position)) + len;
-		    OBJ t;
+OBJ t;
-		    t = __MKINT(np); __INST(position) = t; __STORE(self, t);
+t = __MKINT(np); __INST(position) = t; __STORE(self, t);
-		} else {
+} else {
-		    __INST(position) = nil; /* i.e. do not know */
+__INST(position) = nil; /* i.e. do not know */
-		}
+}
-		RETURN (self);
+RETURN (self);
-	    }
+}
-	    error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-	}
+}
 }
 out: ;
 %}.
 error notNil ifTrue:[
-	lastErrorNumber := error.
+lastErrorNumber := error.
-	self writeError:error.
+self writeError:error.
-	^ self
+^ self
 ].
 ^ super nextPutAll:aCollection startingAt:start to:stop
 !
 nextPutAllUnicode:aString
 ! !
 !ExternalStream class methodsFor:'documentation'!
 version
-^ '$Header: /cvs/stx/stx/libbasic/ExternalStream.st,v 1.384 2014-04-09 21:10:05 stefan Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/ExternalStream.st,v 1.385 2014-04-18 13:06:29 stefan Exp $'
 !
 version_CVS
-^ '$Header: /cvs/stx/stx/libbasic/ExternalStream.st,v 1.384 2014-04-09 21:10:05 stefan Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/ExternalStream.st,v 1.385 2014-04-18 13:06:29 stefan Exp $'
 ! !
 ExternalStream initialize!

changeset 16368	1efe4d36fd3f
parent 16308	4f0cb8a09d1d
child 16373	9b9827530bf4