hg/stx-libbasic: comparison ExternalStream.st

equal deleted inserted replaced

-:fb8c5591428b
+:83c74234945e
+"{ Encoding: utf8 }"
 "
 COPYRIGHT (c) 1988 by Claus Gittinger
 	      All Rights Reserved
 This software is furnished under a license and may be used
 %{
 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) == 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))) {
 #ifdef __win32__
-	    RETURN(__MKEXTERNALADDRESS(_get_osfhandle(fileno(__FILEVal(_handle)))));
+RETURN(__MKEXTERNALADDRESS(_get_osfhandle(fileno(__FILEVal(_handle)))));
 #else
-	    RETURN (__MKINT(fileno(__FILEVal(_handle))));
+RETURN (__MKINT(fileno(__FILEVal(_handle))));
 #endif
-	}
+}
 }
 %}.
-handle isNil ifTrue:[^ self errorNotOpen].
 ^ handle
 !
 filePointer
 "return the filePointer of the receiver -
 mode := #writeonly
 ! !
 !ExternalStream methodsFor:'closing'!
+abortAndClose
+"close the stream - added for protocol compatibility with Socket and PipeStream.
+see comment there"
+self close.
+"Modified: 30.8.1996 / 00:39:21 / cg"
+!
 close
 "Close the stream.
 No error if the stream is not open."
 self isOpen ifTrue:[
 ].
 ].
 !
 shutDown
-"close the stream - added for protocol compatibility with PipeStream.
+"close the stream - added for protocol compatibility with Socket.
 see comment there"
 self close.
 "Modified: 30.8.1996 / 00:39:21 / cg"
 !
 finalize
 "some Stream has been collected - close the file if not already done"
-"/ with timeout to avoid blocking in a bad pty/socket
+self closeFile
-[
-	self closeFile
-] valueWithTimeout:30 seconds.
 !
 reRegisterForFinalization
 Lobby registerChange:self.
 !
 self nextPutUtf16Bytes:aCharacter MSB:true
 "
 (FileStream newTemporary
 nextPutUtf16:$B;
-nextPutUtf16:$�;
+nextPutUtf16:$Ä;
 nextPutUtf16:(Character codePoint:16r10CCCC);
 reset;
 binary;
 contents)
 "
 !ExternalStream methodsFor:'private'!
 clearEOF
 hitEOF := false
-!
+! !
+!ExternalStream protectedMethodsFor:'private'!
 closeFile
 "low level close - may be redefined in subclasses
 Don't send this message, send #close instead"
 |fp error|
+handle isNil ifTrue:[
+^ self.
+].
 fp := handle.
 "/ (didWrite==true and:[binary ~~ true and:[eolMode = #crlf]]) ifTrue: [ self breakPoint:#sr ].
 %{
 int rslt;
-if (fp == nil) {
-	error = @symbol(errorNotOpen);
-	goto out;
-}
 if (__INST(handleType) == @symbol(socketHandle)) {
-	SOCKET sock = (SOCKET)(__FILEVal(fp));
+SOCKET sock = (SOCKET)(__FILEVal(fp));
-	if (@global(FileOpenTrace) == true) {
+if (@global(FileOpenTrace) == true) {
-	    fprintf(stderr, "close socket [ExternalStream] %"_lx_"\n", (INT)sock);
+fprintf(stderr, "close socket [ExternalStream] %"_lx_"\n", (INT)sock);
-	}
+}
-	// whether the close() will be successful or not - the handle is invalid now!
+// whether the close() will be successful or not - the handle is invalid now!
-	__INST(handle) = nil;
+__INST(handle) = nil;
-	do {
+do {
 #ifdef __win32__
-	    rslt = __STX_WSA_NOINT_CALL1("closesocket", closesocket, sock);
+rslt = __STX_WSA_NOINT_CALL1("closesocket", closesocket, sock);
 #else
-	    rslt = close(sock);
+rslt = close(sock);
 #endif
-	} while((rslt < 0) && (__threadErrno == EINTR));
+} while((rslt < 0) && (__threadErrno == EINTR));
 } else 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)))
 {
-	FILEPOINTER f = __FILEVal(fp);
+FILEPOINTER f = __FILEVal(fp);
-	if (@global(FileOpenTrace) == true) {
+if (@global(FileOpenTrace) == true) {
-	    fprintf(stderr, "fclose [ExternalStream] %"_lx_"\n", (INT)f);
+fprintf(stderr, "fclose [ExternalStream] %"_lx_"\n", (INT)f);
-	}
+}
-	// whether the close() will be successful or not - the handle is invalid now!
+// whether the close() will be successful or not - the handle is invalid now!
-	__INST(handle) = nil;
+__INST(handle) = nil;
 #ifdef __win32__
-	if (__INST(mode) != @symbol(readonly) && __INST(buffered) != false) {
+if (__INST(mode) != @symbol(readonly) && __INST(buffered) != false) {
-	    // do a fflush() first, so that fclose() doesn't block
+// do a fflush() first, so that fclose() doesn't block
-	    // we suspect, that EINTR causes problems in fclose()
+// we suspect, that EINTR causes problems in fclose()
-	    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));
-	}
+}
-	do {
+do {
-	    __threadErrno = 0;
+__threadErrno = 0;
-	    rslt = __STX_C_NOINT_CALL1("fclose", fclose, f);
+rslt = __STX_C_NOINT_CALL1("fclose", fclose, f);
-	} while((rslt < 0) && (__threadErrno == EINTR));
+} while((rslt < 0) && (__threadErrno == EINTR));
 #else
-	// cg: the pre Nov2014 code always did the fclose interruptable;
+// cg: the pre Nov2014 code always did the fclose interruptable;
-	// I am not sure, if fclose is actually prepared to do this;
+// I am not sure, if fclose is actually prepared to do this;
-	// at least when only reading, this should not block, and we
+// at least when only reading, this should not block, and we
-	// should be ableto do it without being interruptable.
+// should be ableto do it without being interruptable.
-	// Must watch this - if it leads to blockings, change and think about it.
+// Must watch this - if it leads to blockings, change and think about it.
-	if (__INST(mode) != @symbol(readonly)) {
+if (__INST(mode) != @symbol(readonly)) {
-	    __BEGIN_INTERRUPTABLE__
+__BEGIN_INTERRUPTABLE__
-	    rslt = fclose(f);
+rslt = fclose(f);
-	    __END_INTERRUPTABLE__
+__END_INTERRUPTABLE__
-	} else {
+} else {
-	    rslt = fclose(f);
+rslt = fclose(f);
-	}
+}
 #endif
 } else {
-	error = @symbol(badHandleType);
+error = @symbol(badHandleType);
-	goto out;
+goto out;
 }
 if (rslt < 0) {
-	error = __mkSmallInteger(__threadErrno);
+error = __mkSmallInteger(__threadErrno);
-	goto out;
+goto out;
 }
 RETURN (self);
 out:;
 %}.
 error notNil ifTrue:[
-	error == #errorNotOpen ifTrue:[
+error isInteger ifTrue:[
-	    self errorNotOpen.
+lastErrorNumber := error.
-	].
+mode == #readonly ifTrue:[
-	error isInteger ifTrue:[
+self ioError:error.
-	    lastErrorNumber := error.
+] ifFalse:[
-	    mode == #readonly ifTrue:[
+self writeError:error.
-		self ioError:error.
+].
-	    ] ifFalse:[
+^ self.
-		self writeError:error.
+].
-	    ].
+self primitiveFailed:error.
-	    ^ self.
+^ self.
-	].
-	self primitiveFailed:error.
-	^ self.
 ].
 "/ fallback for rel5
 fp := handle.
 fp notNil ifTrue:[
-	handle := nil.
+handle := nil.
-	self closeFile:fp
+self closeFile:fp
 ]
-!
+! !
+!ExternalStream methodsFor:'private'!
 closeFile:handle
 "for rel5 only"
 self primitiveFailed
 "duplicate my file descriptor"
 |fd dupFd|
 fd := self fileHandle.
+fd isNil ifTrue:[
+^ self errorNotOpen.
+].
 dupFd := OperatingSystem dup:fd.
 self setFileHandle:dupFd mode:self fopenMode.
 !
 fopenMode
 %{
 #ifdef __SCHTEAM__
 STObject handle = self.instVarAt(I_handle);
 if (handle != STObject.Nil) {
-	STObject next;
+STObject next;
-	if (self.instVarAt(I_binary) == STObject.True) {
+if (self.instVarAt(I_binary) == STObject.True) {
-	    next = handle.nextByte();
+next = handle.nextByte();
-	} else {
+} else {
-	    next = handle.nextChar();
+next = handle.nextChar();
-	}
+}
-	if (next != STObject.EOF) {
+if (next != STObject.EOF) {
-	    self.instVarAt_put(I_position, STObject.Nil);
+self.instVarAt_put(I_position, STObject.Nil);
-	    return __c__._RETURN( next );
+return __c__._RETURN( next );
-	}
+}
-	self.instVarAt_put(I_hitEOF, STObject.True);
+self.instVarAt_put(I_hitEOF, STObject.True);
 }
 #else
 FILEPOINTER f;
 int ret, _buffered;
 OBJ pos, fp;
 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) {
-# ifdef ECONNRESET
+error = __mkSmallInteger(__threadErrno);
-		&& (__threadErrno != ECONNRESET)
+} else /* ret == 0 */ {
-# endif
+__INST(hitEOF) = true;
-	    ){
+}
-		error = __mkSmallInteger(__threadErrno);
+}
-	    } else /* ret == 0 */ {
-		__INST(hitEOF) = true;
-	    }
-	}
 }
 #endif /* not SCHTEAM */
 %}.
 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.
 ].
+"unknown handleType - future"
 c := self nextByteFromFile:handle.
 c isNil ifTrue:[
-	^ self pastEndRead.
+^ self pastEndRead.
 ].
 binary == true ifTrue:[
-	^ c
+^ c
 ].
 ^ Character value:c
 !
 next:count
 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) {
-#ifdef ECONNRESET
+error = __mkSmallInteger(__threadErrno);
-		&& (__threadErrno != ECONNRESET)
+} else /* ret == 0 */ {
-#endif
+__INST(hitEOF) = true;
-	    ){
+}
-		error = __mkSmallInteger(__threadErrno);
+}
-	    } else /* ret == 0 */ {
-		__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.
 ].
+"unknown handleType - future"
 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) {
-#ifdef ECONNRESET
+error = __mkSmallInteger(__threadErrno);
-		&& (__threadErrno != ECONNRESET)
+} else /* ret == 0 */ {
-#endif
+__INST(hitEOF) = true;
-	    ){
+}
-		error = __mkSmallInteger(__threadErrno);
+}
-	    } else /* ret == 0 */ {
-		__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) {
-#ifdef ECONNRESET
+error = __mkSmallInteger(__threadErrno);
-		&& (__threadErrno != ECONNRESET)
+} else /* ret == 0 */ {
-#endif
+__INST(hitEOF) = true;
-	    ){
+}
-		error = __mkSmallInteger(__threadErrno);
+}
-	    } else /* ret == 0 */ {
-		__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
 ! !
 !ExternalStream methodsFor:'testing'!
 atEnd
-"return true, if position is at end"
+"return true, if position is at end.
+A stream is at the end, if the next read operation
+would return immediately without waiting."
 %{
 OBJ fp, pos, lim;
 char c;
 }
 if (ret == 0) {
 __INST(hitEOF) = true;
 RETURN (true);
 }
-#ifdef ECONNRESET
+/* ret < 0 -> error */
-// connection reset by peer is also an EOF
-if (__threadErrno == ECONNRESET) {
-__INST(hitEOF) = true;
-RETURN (true);
-}
-#endif
-/* ret < 0 */
 __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 }
+// we do not raise an error here - the next read operation will raise the error.
+RETURN(false);
 }
 %}.
-lastErrorNumber notNil ifTrue:[^ self readError].
-handle isNil ifTrue:[^ self errorNotOpen].
+"/ we come here if the handle type is unknown
-mode == #writeonly ifTrue:[^ self errorWriteOnly].
-readAhead notNil ifTrue:[^ false].
 "/ migration support
-^ self
+^ self atEndFile:handle
-atEndFile:handle
 "Modified: / 30.10.1998 / 20:16:06 / cg"
 !
 canReadWithoutBlocking
 	or:[mode == #readonly
 	or:[OperatingSystem writeCheck:self fileDescriptor]]
 !
 gotErrorOrEOF
-"answerv true, if amn error or eof has been occurred on the stream"
+"answer true, if amn error or eof has been occurred on the stream"
 ^ hitEOF == true or:[lastErrorNumber notNil]
 !
 isBinary
 aString do:[:eachCharacter|
 	self nextPutUtf8:eachCharacter.
 ].
 "
-	'B�nnigheim' asUnicode16String errorPrintCR
+	'Bönnigheim' asUnicode16String errorPrintCR
 "
 !
 nextPutBytes:count from:anObject startingAt:start
 "write count bytes from an object starting at index start.

branch	jv
changeset 20728	83c74234945e
parent 20580	bb4e5c4f84ef
parent 20690	f6a11f77b230
child 21024	8734987eb5c7