hg/stx-libbasic: comparison ExternalStream.st

equal deleted inserted replaced

-:98f799af1e48
+:1665620b0c7d
 %{
 OBJ _handle  = __INST(handle);
 if (_handle != nil) {
-	if ((__INST(handleType) == @symbol(fileHandle))
+if ((__INST(handleType) == @symbol(fileHandle))
-	 || (__INST(handleType) == @symbol(socketHandle))) {
+|| (__INST(handleType) == @symbol(socketHandle))) {
-	    RETURN (_handle);
+RETURN (_handle);
-	}
+}
-	if (__INST(handleType) == @symbol(pipeFilePointer)) {
+if (__INST(handleType) == @symbol(pipeFilePointer)) {
-	    RETURN (__MKINT(fileno(__FILEVal(_handle))));
+RETURN (__MKINT(fileno(__FILEVal(_handle))));
-	}
+}
-	if ((__INST(handleType) == nil)
+if ((__INST(handleType) == nil)
-	 || (__INST(handleType) == @symbol(filePointer))
+|| (__INST(handleType) == @symbol(filePointer))
-	 || (__INST(handleType) == @symbol(socketFilePointer))
+|| (__INST(handleType) == @symbol(socketFilePointer))
-	 || (__INST(handleType) == @symbol(pipeFilePointer))) {
+|| (__INST(handleType) == @symbol(pipeFilePointer))) {
+FILE *file = __FILEVal(_handle);
+if (file != NULL) {
+int fileNo = fileno(file);
+if (fileNo >= 0) {
 #ifdef __win32__
-	    RETURN(__MKEXTERNALADDRESS(_get_osfhandle(fileno(__FILEVal(_handle)))));
+RETURN(__MKEXTERNALADDRESS(_get_osfhandle(fileNo)));
 #else
-	    FILE *file = __FILEVal(_handle);
+RETURN (__MKINT(fileNo));
-	    if (file != NULL) {
-		int fileNo = fileno(file);
-		if (fileNo >= 0) {
-		    RETURN (__MKINT(fileNo));
-		}
-	    }
 #endif
-	}
+}
+}
+}
 }
 %}.
 ^ handle
 "Modified: / 07-04-2017 / 16:34:40 / cg"
 ! !
 !ExternalStream methodsFor:'defaults'!
 bufferSizeForBulkCopy
 "return the size of buffer used when copying big files/bulk data
 from one stream to another.
 Due to a bug on older Windows systems, the default used
 is chosen very conservatively, as the copy used to fail with big buffers.
 However, modern Windows systems seem to not suffer from that bug,
 and bigger buffer sizes will dramatically increase the performance of
 When nil, a somewhat conservative compromise is used."
 DefaultCopyBufferSize notNil ifTrue:[^ DefaultCopyBufferSize].
 (OperatingSystem isMSWINDOWSlike and:[OperatingSystem isWin7Like not]) ifTrue:[
-"/ mhmh - NT hangs, when copying bigger blocks to a network drive - why ?
+	"/ mhmh - NT hangs, when copying bigger blocks to a network drive - why ?
-^ 1 * 1024.
+	^ 1 * 1024.
 ].
 ^ 64 * 1024.
 "Created: / 13-03-2019 / 16:49:17 / Stefan Vogel"
 "Modified: / 13-03-2019 / 23:19:43 / Stefan Vogel"
 "{ Pragma: +optSpace }"
 "report an error, that the stream is in binary mode"
 ^ InvalidModeError
-raiseRequestWith:self
+	raiseRequestWith:self
-errorString:(self className , ' is in binary mode')
+	errorString:(self className , ' is in binary mode')
-"/ in:thisContext sender
+	"/ in:thisContext sender
 "Modified: / 08-05-1999 / 20:12:43 / cg"
 "Modified: / 28-06-2019 / 08:43:06 / Claus Gittinger"
 !
 "{ Pragma: +optSpace }"
 "report an error, that the stream is not in binary mode"
 ^ InvalidModeError
-raiseRequestWith:self
+	raiseRequestWith:self
-errorString:(self className , ' is not in binary mode')
+	errorString:(self className , ' is not in binary mode')
-"/ in:thisContext sender
+	"/ in:thisContext sender
 "Modified: / 08-05-1999 / 20:12:40 / cg"
 "Modified: / 28-06-2019 / 08:43:11 / Claus Gittinger"
 !
 "{ Pragma: +optSpace }"
 "report an error, that the stream is not in buffered mode"
 ^ StreamError
-raiseRequestWith:self
+	raiseRequestWith:self
-errorString:(self className , ' is unbuffered - operation not allowed')
+	errorString:(self className , ' is unbuffered - operation not allowed')
-"/ in:thisContext sender
+	"/ in:thisContext sender
 "Modified: / 08-05-1999 / 20:12:36 / cg"
 "Modified: / 28-06-2019 / 08:43:14 / Claus Gittinger"
 !
 so it's possible to read alien (i.e. ms-dos) text as well.
 The line must be shorter than 32K characters - otherwise an error is signalled."
 |line error|
-%{  /* STACK:100000 */
+%{  /* STACK:50000 */
 FILEPOINTER f;
 int len, ret;
 char buffer[32*1024];
 char *rslt, *nextPtr, *limit;
 |buffer n|
 buffer := ByteArray uninitializedNew:count.
 n := self nextAvailableBytes:count into:buffer startingAt:1.
 n == 0 ifTrue:[
-^ #[]
+	^ #[]
 ].
 n ~~ count ifTrue:[
-^ buffer copyTo:n
+	^ buffer copyTo:n
 ].
 ^ buffer.
 "
 (ReadStream on:#(1 2 3 4 5)) nextAvailable:3
 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;
 # ifdef __win32__
-__threadErrno = __WIN32_ERR(GetLastError());
+		__threadErrno = __WIN32_ERR(GetLastError());
 # endif
-error = __mkSmallInteger(__threadErrno);
+		error = __mkSmallInteger(__threadErrno);
-}
+	    }
-}
+	}
 }
 bad: ;
 %}.
 hitEOF 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)
 |error|
 %{
 int num;
 union {
-char bytes[2];
+	char bytes[2];
-short shortVal;
+	short shortVal;
 } u;
 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))
-) {
+	) {
-FILEPOINTER f = __FILEVal(fp);
+	    FILEPOINTER f = __FILEVal(fp);
-int _buffered = (__INST(buffered) == true);
+	    int _buffered = (__INST(buffered) == true);
-int cnt;
+	    int cnt;
-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;
-u.shortVal = num;
+	    u.shortVal = num;
-if (_buffered) {
+	    if (_buffered) {
-__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 */
 # ifdef __win32__
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
 # endif
-error = __mkSmallInteger(__threadErrno);
+	    error = __mkSmallInteger(__threadErrno);
-}
+	}
 }
 out:;
 %}.
 self nextPutInt16:anIntegerOrCharacter MSB:(UninterpretedBytes isBigEndian).
 This is the CPU-specific byte order (LSB on x86 and VAX, MSB on sparc and possibly on ARM).
 Notice that integers in the range 16r-80000000 to +16rFFFFFFFF can be written
 (i.e. both signed and unsigned int32 values can be written.
 Works in both binary and text modes.
 Notice: this message should not be sent explicitly by ANY program.
-the following implementation replaces the code of either nextPutInt32MSB or LSB
+	     the following implementation replaces the code of either nextPutInt32MSB or LSB
-dynamically (see #initialize on the class side)"
+	     dynamically (see #initialize on the class side)"
 |error|
 %{
 int num;
 union {
-char bytes[4];
+	char bytes[4];
-int intVal;
+	int intVal;
 } u;
 OBJ fp;
 __INST(lastErrorNumber) = nil;
 if (__isSmallInteger(anInteger)) {
-num = __intVal(anInteger);
+	num = __intVal(anInteger);
 } else {
 #if __POINTER_SIZE__ == 8
-// always more than 4-bytes
+	// always more than 4-bytes
-goto badArg;
+	goto badArg;
 #else
-num = __longIntVal(anInteger);
+	num = __longIntVal(anInteger);
-if (num == 0) {
+	if (num == 0) {
-num = __signedLongIntVal(anInteger);
+	    num = __signedLongIntVal(anInteger);
-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))
-) {
+	) {
-int _buffered = (__INST(buffered) == true);
+	    int _buffered = (__INST(buffered) == true);
-FILEPOINTER f = __FILEVal(fp);
+	    FILEPOINTER f = __FILEVal(fp);
-int cnt;
+	    int cnt;
-u.intVal = num;
+	    u.intVal = num;
-if (_buffered) {
+	    if (_buffered) {
-__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 */
 # ifdef __win32__
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
 # endif
-error = __mkSmallInteger(__threadErrno);
+	    error = __mkSmallInteger(__threadErrno);
-}
+	}
 }
 badArg: ;
 %}.
 self nextPutInt32:anInteger MSB:(UninterpretedBytes isBigEndian)
 ^ self errorNotOpen
 ].
 mode == #readonly ifTrue:[
 ^ self errorReadOnly
 ].
+%{
+#ifdef __win32__
+{
+FILEPOINTER f = __FILEVal(__INST(handle));
+if ((f == __win32_stdout()) || (f == __win32_stderr())) {
+RETURN(false);
+}
+}
+#endif
+%}.
 fd := self fileHandle.
 (OperatingSystem writeCheck:fd) ifTrue:[^ false].
 wasBlocked := OperatingSystem blockInterrupts.
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-OBJ fp;
+	OBJ fp;
-int _buffered = (__INST(buffered) == true);
+	int _buffered = (__INST(buffered) == true);
-if ((fp = __INST(handle)) != nil) {
+	if ((fp = __INST(handle)) != nil) {
-if (__INST(mode) != @symbol(readonly)) {
+	    if (__INST(mode) != @symbol(readonly)) {
-if (1 /* _buffered */) {
+		if (1 /* _buffered */) {
-FILEPOINTER f = __FILEVal(fp);
+		    FILEPOINTER f = __FILEVal(fp);
 #ifdef __win32__
-if ((f == __win32_stdout()) || (f == __win32_stderr())) {
+		    if ((f == __win32_stdout()) || (f == __win32_stderr())) {
-__win32_fflush(f);
+			__win32_fflush(f);
-} else {
+		    } else {
-int rslt;
+			int rslt;
-do {
+			do {
-__threadErrno = 0;
+			    __threadErrno = 0;
-rslt = __STX_C_CALL1("fflush", fflush, f);
+			    rslt = __STX_C_CALL1("fflush", fflush, f);
-} while((rslt < 0) && (__threadErrno == EINTR));
+			} while((rslt < 0) && (__threadErrno == EINTR));
-}
+		    }
 #else /* ! __win32__ */
-__BEGIN_INTERRUPTABLE__
+		    __BEGIN_INTERRUPTABLE__
-FFLUSH(f);
+		    FFLUSH(f);
-__END_INTERRUPTABLE__
+		    __END_INTERRUPTABLE__
 #endif /* ! __win32__ */
-}
+		}
-}
+	    }
-}
+	}
 }
 %}
 "Modified: / 03-04-2019 / 16:15:11 / Claus Gittinger"
 !
 #ifdef __SCHTEAM__
 STObject handle = self.instVarAt(I_handle);
 if ((handle != STObject.Nil)
 && (aCharacter.isSTCharacter())) {
-handle.writeChar( aCharacter );
+	handle.writeChar( aCharacter );
-self.instVarAt_put(I_position, STObject.Nil);
+	self.instVarAt_put(I_position, STObject.Nil);
-return __c__._RETURN(aCharacter);
+	return __c__._RETURN(aCharacter);
 }
 #else
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
 || (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-OBJ fp;
+	OBJ fp;
-if (((fp = __INST(handle)) != nil)
+	if (((fp = __INST(handle)) != nil)
-&& (__INST(mode) != @symbol(readonly))
+	 && (__INST(mode) != @symbol(readonly))
-) {
+	) {
-FILEPOINTER f = __FILEVal(fp);
+	    FILEPOINTER f = __FILEVal(fp);
-int _buffered = (__INST(buffered) == true);
+	    int _buffered = (__INST(buffered) == true);
-int cnt;
+	    int cnt;
-char buff[2];
+	    char buff[2];
-int nBytes = 1;
+	    int nBytes = 1;
-if (__INST(binary) != true) {
+	    if (__INST(binary) != true) {
-if (__isCharacter(aCharacter)) {
+		if (__isCharacter(aCharacter)) {
-unsigned int codePoint = __intVal(__characterVal(aCharacter));
+		    unsigned int codePoint = __intVal(__characterVal(aCharacter));
-if (codePoint <= 0xFF) {
+		    if (codePoint <= 0xFF) {
-unsigned char c = codePoint;
+			unsigned char c = codePoint;
-buff[0] = c; nBytes = 1;
+			buff[0] = c; nBytes = 1;
-if (c == '\n') {
+			if (c == '\n') {
-OBJ mode = __INST(eolMode);
+			    OBJ mode = __INST(eolMode);
-if (mode == @symbol(nl)) {
+			    if (mode == @symbol(nl)) {
-// no EOL translation
+				// no EOL translation
-} else if (mode == nil) {
+			    } else if (mode == nil) {
-// no EOL translation
+				// no EOL translation
-} else if (mode == @symbol(cr)) {
+			    } else if (mode == @symbol(cr)) {
-buff[0] = '\r';
+				buff[0] = '\r';
-} else if (mode == @symbol(eot)) {
+			    } else if (mode == @symbol(eot)) {
-buff[0] = '\004';
+				buff[0] = '\004';
-} else if (mode == @symbol(etx)) {
+			    } else if (mode == @symbol(etx)) {
-buff[0] = '\003';
+				buff[0] = '\003';
-} else if (mode == @symbol(crlf)) {
+			    } else if (mode == @symbol(crlf)) {
-buff[0] = '\r';
+				buff[0] = '\r';
-buff[1] = '\n';
+				buff[1] = '\n';
-nBytes = 2;
+				nBytes = 2;
-}
+			    }
-}
+			}
 doWrite:
-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) {
+			if (_buffered) {
-__WRITING__(f)
+			    __WRITING__(f)
-}
+			}
 # ifdef __win32__
-if ((f == __win32_stdout()) || (f == __win32_stderr())) {
+			if ((f == __win32_stdout()) || (f == __win32_stderr())) {
-cnt = __win32_fwrite(buff, 1, nBytes, f);
+			    cnt = __win32_fwrite(buff, 1, nBytes, f);
-} else
+			} else
 # endif
-{
+			{
-__WRITEBYTES__(cnt, f, buff, nBytes, _buffered, __INST(handleType));
+			    __WRITEBYTES__(cnt, f, buff, nBytes, _buffered, __INST(handleType));
-}
+			}
-if (cnt == nBytes) {
+			if (cnt == nBytes) {
-if (__isSmallInteger(__INST(position))) {
+			    if (__isSmallInteger(__INST(position))) {
-INT np = __intVal(__INST(position)) + nBytes;
+				INT np = __intVal(__INST(position)) + nBytes;
-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 ( aCharacter );
+			    RETURN ( aCharacter );
-}
+			}
 # ifdef __win32__
-__threadErrno = __WIN32_ERR(GetLastError());
+			__threadErrno = __WIN32_ERR(GetLastError());
 # endif
-error = __mkSmallInteger(__threadErrno);
+			error = __mkSmallInteger(__threadErrno);
-}
+		    }
-}
+		}
-} else {
+	    } else {
-if (__isSmallInteger(aCharacter)) {
+		if (__isSmallInteger(aCharacter)) {
-unsigned char c = __intVal(aCharacter);
+		    unsigned char c = __intVal(aCharacter);
-buff[0] = c; nBytes = 1;
+		    buff[0] = c; nBytes = 1;
-goto doWrite;
+		    goto doWrite;
-}
+		}
-}
+	    }
-}
+	}
 }
 out: ;
 #endif /* not SCHTEAM */
 %}.
 error notNil ifTrue:[
-lastErrorNumber := error.
+	lastErrorNumber := error.
-self writeError:error.
+	self writeError:error.
-^ aCharacter
+	^ aCharacter
 ].
 handle isNil ifTrue:[self errorNotOpen. ^ self].
 (mode == #readonly) ifTrue:[self errorReadOnly. ^ self].
 binary == true ifTrue:[
-aCharacter isInteger ifFalse:[
+	aCharacter isInteger ifFalse:[
-self argumentMustBeInteger.
+	    self argumentMustBeInteger.
-^ aCharacter.
+	    ^ aCharacter.
-].
+	].
 ] ifFalse:[
-(aCharacter isCharacter not
+	(aCharacter isCharacter not
-or:[aCharacter codePoint > 16rFF]) ifTrue:[
+	 or:[aCharacter codePoint > 16rFF]) ifTrue:[
-self argumentMustBeCharacter.
+	    self argumentMustBeCharacter.
-^ aCharacter.
+	    ^ aCharacter.
-].
+	].
 ].
 "/ migration support
 self
-nextPutByte:aCharacter asInteger
+	nextPutByte:aCharacter asInteger
-toFile:handle.
+	toFile:handle.
 ^ aCharacter
 "Modified: / 22-11-2018 / 14:47:13 / Stefan Vogel"
 !
 #ifdef __SCHTEAM__
 STObject handle = self.instVarAt(I_handle);
 if ((handle != STObject.Nil)
 && (aCollection.isSTString())) {
-handle.writeCharacters( aCollection.asSTString().characters );
+	handle.writeCharacters( aCollection.asSTString().characters );
-self.instVarAt_put(I_position, STObject.Nil);
+	self.instVarAt_put(I_position, STObject.Nil);
-return __c__._RETURN_self();
+	return __c__._RETURN_self();
 }
 #else
 __INST(lastErrorNumber) = nil;
 if ((__INST(handleType) == nil)
 || (__INST(handleType) == @symbol(filePointer))
 || (__INST(handleType) == @symbol(socketFilePointer))
 || (__INST(handleType) == @symbol(socketHandle))
 || (__INST(handleType) == @symbol(pipeFilePointer))) {
-OBJ fp;
+	OBJ fp;
-if (((fp = __INST(handle)) != nil)
+	if (((fp = __INST(handle)) != nil)
-&& (__INST(mode) != @symbol(readonly))
+	    && (__INST(mode) != @symbol(readonly))
-) {
+	) {
-INT len, cnt;
+	    INT len, cnt;
-INT o_offs;
+	    INT o_offs;
-FILEPOINTER f = __FILEVal(fp);
+	    FILEPOINTER f = __FILEVal(fp);
-int _buffered = (__INST(buffered) == true);
+	    int _buffered = (__INST(buffered) == true);
-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) {
+	    if (_buffered) {
-__WRITING__(f)
+		__WRITING__(f)
-}
+	    }
-if (__isStringLike(aCollection)) {
+	    if (__isStringLike(aCollection)) {
-OBJ mode = __INST(eolMode);
+		OBJ mode = __INST(eolMode);
-char *stringP = __stringVal(aCollection);
+		char *stringP = __stringVal(aCollection);
-len = __stringSize(aCollection);
+		len = __stringSize(aCollection);
-if (__INST(binary) != true
+		if (__INST(binary) != true
-&& ((mode == @symbol(cr))
+		    && ((mode == @symbol(cr))
-|| (mode == @symbol(etx))
+			|| (mode == @symbol(etx))
-|| (mode == @symbol(eot))
+			|| (mode == @symbol(eot))
-|| (mode == @symbol(crlf)))
+			|| (mode == @symbol(crlf)))
-&& memchr(stringP, '\n', len) != NULL)
+		    && memchr(stringP, '\n', len) != NULL)
-{
+		{
-// there is a '\n' to be translated, replace it into a buffer
+		    // there is a '\n' to be translated, replace it into a buffer
-char *end;
+		    char *end;
-char sep[2];
+		    char sep[2];
-int sepLen = 1;
+		    int sepLen = 1;
-int bufLen;
+		    int bufLen;
-char *buf, *endBuf, *sp, *dp;
+		    char *buf, *endBuf, *sp, *dp;
-sep[0] = '\n';
+		    sep[0] = '\n';
-if (mode == @symbol(crlf)) {
+		    if (mode == @symbol(crlf)) {
-sep[0] = '\r'; sep[1] = '\n'; sepLen = 2;
+			 sep[0] = '\r'; sep[1] = '\n'; sepLen = 2;
-} else if (mode == @symbol(cr)) {
+		    } else if (mode == @symbol(cr)) {
-sep[0] = '\r';
+			 sep[0] = '\r';
-} else if (mode == @symbol(eot)) {
+		    } else if (mode == @symbol(eot)) {
-sep[0] = '\004';
+			 sep[0] = '\004';
-} else if (mode == @symbol(etx)) {
+		    } else if (mode == @symbol(etx)) {
-sep[0] = '\003';
+			 sep[0] = '\003';
-}
+		    }
-// estimate size of buffer - assume every 4th char is a separator
+		    // estimate size of buffer - assume every 4th char is a separator
-bufLen = (sepLen == 1) ? len : (len + ((len/4) + 1) * sepLen);
+		    bufLen = (sepLen == 1) ? len : (len + ((len/4) + 1) * sepLen);
-buf = (char *)malloc(bufLen);
+		    buf = (char *)malloc(bufLen);
-if (buf == NULL) {
+		    if (buf == NULL) {
-error = __mkSmallInteger(ENOMEM);
+			error = __mkSmallInteger(ENOMEM);
-goto out;
+			goto out;
-}
+		    }
-endBuf = buf + bufLen;
+		    endBuf = buf + bufLen;
-end = stringP + len;
+		    end = stringP + len;
-for (sp = stringP, dp = buf; sp < end; sp++) {
+		    for (sp = stringP, dp = buf; sp < end; sp++) {
-char c;
+			char c;
-if ((dp+sepLen) >= endBuf) {
+			if ((dp+sepLen) >= endBuf) {
-char *newBuf;
+			    char *newBuf;
-bufLen = bufLen * 2;
+			    bufLen = bufLen * 2;
-newBuf = (char *)realloc(buf, bufLen);
+			    newBuf = (char *)realloc(buf, bufLen);
-if (newBuf == NULL) {
+			    if (newBuf == NULL) {
-free(buf);
+				free(buf);
-error = __mkSmallInteger(ENOMEM);
+				error = __mkSmallInteger(ENOMEM);
-goto out;
+				goto out;
-}
+			    }
-endBuf = newBuf + bufLen;
+			    endBuf = newBuf + bufLen;
-dp = newBuf + (dp-buf);
+			    dp = newBuf + (dp-buf);
-buf = newBuf;
+			    buf = newBuf;
-}
+			}
-if ((c = *sp) != '\n') {
+			if ((c = *sp) != '\n') {
-*dp++ = c;
+			    *dp++ = c;
-} else {
+			} else {
-*dp++ = sep[0];
+			    *dp++ = sep[0];
-if (sepLen == 2) {
+			    if (sepLen == 2) {
-*dp++ = sep[1];
+				*dp++ = sep[1];
-};
+			    };
-}
+			}
-}
+		    }
-len = dp - buf;
+		    len = dp - buf;
 # ifdef __win32__
-if ((f == __win32_stdout()) || (f == __win32_stderr())) {
+		    if ((f == __win32_stdout()) || (f == __win32_stderr())) {
-cnt = __win32_fwrite(buf, 1, len, f);
+			cnt = __win32_fwrite(buf, 1, len, f);
-} else
+		    } else
 # endif
-{
+		    {
-__WRITEBYTES__(cnt, f, buf, len, _buffered, __INST(handleType));
+			__WRITEBYTES__(cnt, f, buf, len, _buffered, __INST(handleType));
-}
+		    }
-free(buf);
+		    free(buf);
-} else  {  // No EOL conversion needed
+		} else  {  // No EOL conversion needed
 # ifdef __win32__
-if ((f == __win32_stdout()) || (f == __win32_stderr())) {
+		    if ((f == __win32_stdout()) || (f == __win32_stderr())) {
-cnt = __win32_fwrite(stringP, 1, len, f);
+			cnt = __win32_fwrite(stringP, 1, len, f);
-} else
+		    } else
 # endif
-{
+		    {
-o_offs = stringP - (char *)__InstPtr(aCollection);
+			o_offs = stringP - (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 {   // Not a String
+	    } else {   // Not a String
-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  // Not binary mode
+		} else  // Not binary mode
-goto out;
+		    goto out;
-}
+	    }
-// Now check for errors
+	    // Now check for errors
-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);
-}
+	    }
 # ifdef __win32__
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
 # endif
-error = __mkSmallInteger(__threadErrno);
+	    error = __mkSmallInteger(__threadErrno);
-fprintf(stderr, "cnt=%"_ld_" len=%"_ld_"\n", (INT)cnt, (INT)len);
+	    fprintf(stderr, "cnt=%"_ld_" len=%"_ld_"\n", (INT)cnt, (INT)len);
-}
+	}
 }
 out: ;
 #endif /* not SCHTEAM */
 %}.
 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

changeset 25136	1665620b0c7d
parent 25134	9eac80392554
child 25142	bd49177015de