hg/stx-libbasic: comparison Stream.st

equal deleted inserted replaced

-:b5cdb27022c8
+:20922299fd44
 ^ self subclassResponsibility
 !
 signalAtEnd
 "return the signalAtEnd flag setting.
 If true, reading past the end will always raise an EndOfStream exception.
 If false, no exception is raised and nil is returned from all reading messages.
 If nil (default), the exception is raised if there is a handler; otherwise, nil is returned.
 The default is nil (for ST80 compatibility) i.e. to only raise a signal if there is a handler."
 ^ signalAtEnd
 !Stream methodsFor:'converting'!
 asLineNumberReadStream
 "returns a new stream, which keeps track of the line number.
 It can be asked for the current linenumber,
 which is useful eg. for error message generation"
 ^ LineNumberReadStream on:self
 !
 ^ self
 "Created: 14.5.1996 / 17:38:07 / cg"
 !
 italic
 "set emphasis to #italic.
 this allows Streams to be used interchangeable with printStreams"
 self emphasis:#italic.
 s linesDo:[:line | Transcript showCR:line].
 s close
 "
 "
 Filename readingFile:'/etc/hosts'
 do:[:s |
 s linesDo:[:line | Transcript showCR:line].
 ].
 "
 ! !
 "Modified: / 18-11-2006 / 15:36:44 / cg"
 !
 pastEndRead
 "someone tried to read after the end of the stream.
 If signalAtEnd == true, raise a signal.
 If it is false, return nil.
 Otherwise raise a notification, which is ignored if not handled;
 otherwise return nil."
 |shouldSignalAtEnd|
 shouldSignalAtEnd := self signalAtEnd.
 binary
 "switch to binary mode. In binary mode, reading of text streams
 returns byte-valued integers instead of characters; writing expects
 byte-valued integers respectively.
 Ignored here, but added to make internalStreams protocol compatible
 with externalStreams."
 "Modified: 15.5.1996 / 17:38:36 / cg"
 !
 ^ false.
 !
 eolMode
 "Dummy here, but added to make internalStreams protocol compatible
 with externalStreams."
 ^ nil  "/ transparent
 !
 eolMode:aSymbol
 "Ignored here, but added to make internalStreams protocol compatible
 with externalStreams."
 !
 lineEndCRLF
 "Ignored here, but added to make internalStreams protocol compatible
 with externalStreams."
 !
 lineEndLF
 "Ignored here, but added to make internalStreams protocol compatible
 with externalStreams."
 !
 lineEndTransparent
 "Ignored here, but added to make internalStreams protocol compatible
 with externalStreams."
 !
 stream
 "for compatibility with encodedStream"
 ^ self
 !
 text
 "switch to text mode.
 Ignored here, but added to make internalStreams protocol compatible
 with externalStreams."
 "Modified: 15.5.1996 / 17:38:36 / cg"
 "Created: 13.9.1996 / 18:33:26 / cg"
 ! !
 writeCount := 0.
 "write loop: write until all is written"
 [
 |count|
 count := aWriteStream
 nextPutAll:readCount-writeCount
 from:buffer
 startingAt:writeCount+1.
 writeCount := writeCount + count.
 writeCount < readCount ifTrue:[
 aWriteStream writeWait.
 true.
 ] ifFalse:[
 false
 ].
 ] whileTrue.
 countWritten := countWritten + writeCount.
 ].
 "Note: atEnd will block if reading from an empty pipe or socket.
 avoid atEnd if possible, because it reads a single byte."
 bytesLeft ~~ 0 or:[self atEnd not]
 ] whileTrue.
 "/
 "/t := Time millisecondsToRun:[
 "/    retVal := self copyToEndInto:outStream bufferSize:(64*1024).
 "/].
 "/
 "/Transcript showCR:('%1 KB copied in %2s (%3 KB/s)'
 "/        bindWith:((retVal/1024)asFixedPoint:2)
 "/        with:((t/1000)asFixedPoint:2)
 "/        with:((retVal/1024/(t/1000))asFixedPoint:2)).
 "/^ retVal.
 "/
 !
 writeCount := 0.
 "write loop: write until all is written"
 [
 |count|
 count := outStream
 nextPutAll:readCount-writeCount
 from:buffer
 startingAt:writeCount+1.
 writeCount := writeCount + count.
 writeCount < readCount ifTrue:[
 outStream writeWait.
 true.
 ] ifFalse:[
 false
 ].
 ] whileTrue.
 countWritten := countWritten + writeCount.
 ].
 "Note: atEnd will block if reading from an empty pipe or socket.
 avoid atEnd if possible, because it reads a single byte."
 readCount ~~ 0 or:[self atEnd not]
 ] whileTrue.
 "read the next count bytes into an object and return the number of
 bytes read. On EOF, 0 is returned.
 If the receiver is some socket/pipe-like stream, an exception
 is raised if the connection is broken.
 The object must have non-pointer indexed instvars (i.e. it must be
 a ByteArray, String, Float- or DoubleArray).
 If anObject is a string or byteArray and reused, this provides the
 fastest possible physical I/O (since no new objects are allocated).
 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."
 ^ self nextBytes:count into:anObject startingAt:1
 "Modified: 22.4.1997 / 10:41:39 / cg"
 The number of bytes to read is defined by the object's size.
 Return the number of bytes read. On EOF, 0 is returned.
 If the receiver is some socket/pipe-like stream, an exception
 is raised if the connection is broken.
 The object to read into must have non-pointer indexed instvars
 (i.e. it must be a ByteArray, String, Float- or DoubleArray).
 If anObject is a string or byteArray and reused, this provides the
 fastest possible physical I/O (since no new objects are allocated).
 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."
 ^ self nextBytes:(anObject byteSize) into:anObject startingAt:1
 " to read 100 bytes from a stream:
 |b aStream|
 aStream := 'smalltalk.rc' asFilename readStream.
 b := ByteArray new:100.
 aStream nextBytesInto:b.
 uval := b2 bitShift:8.
 uval := uval bitOr:b1.
 ].
 "change from unsigned 0..FFFF to signed -8000..7FFF"
 uval >= 16r8000 ifTrue:[
 ^ uval - 16r10000
 ].
 ^ uval
 "Modified: 11.7.1996 / 10:07:04 / cg"
 !
 |uval "{ Class: SmallInteger }"|
 uval := self nextUnsignedInt24MSB:msbFlag.
 "change from unsigned 0..FFFFFF to signed -800000..7FFFFF"
 uval >= 16r800000 ifTrue:[
 ^ uval - 16r1000000
 ].
 ^ uval
 "
 ((ReadStream on:#[16r10 16r20 16rFF]) nextInt24MSB:true) hexPrintString
 val := (uval bitShift:8) bitOr:b1.
 ].
 "change from unsigned 0..FFFFFFFF to signed -80000000..7FFFFFFF"
 val >= 16r80000000 ifTrue:[
 ^ val - 16r100000000
 ].
 ^ val
 "
 |bytes s|
 uval := self nextUnsignedInt64MSB:msbFlag.
 "change from unsigned 0..FF..FF to signed -80..00..7FF..FF"
 uval >= 16r8000000000000000 ifTrue:[
 ^ uval - 16r10000000000000000
 ].
 ^ uval
 "
 |bytes s|
 |uval "{ Class: SmallInteger }"|
 uval := self nextByte.
 "change from unsigned 0..FF to signed -80..7F"
 uval >= 16r80 ifTrue:[
 ^ uval - 16r100
 ].
 ^ uval
 "
 #[16rFF 16r80 16r7F 16r01] readStream nextSignedByte
 "
 !
 nextString:count
 "read the next count bytes and return it as a string.
 If EOF is encountered while reading, a truncated string is returned.
 If EOF is already reached before the first byte can be read,
 an error is raised."
 |data n|
 ^ self nextUnsignedInt64MSB:msbFlag
 ].
 "/ bytes
 bytes := self nextBytes:numBytes.
 ^ (LargeInteger digitBytes:bytes MSB:msbFlag) compressed
 "/    val := 0.
 "/    msbFlag ifTrue:[
 "/        numBytes timesRepeat:[
 "/            val := (val bitShift:8) + self nextByte
 "/        ].
 "
 |s|
 s := #[ 16r01 16r02 16r03 16r04 16r05 ] readStream.
 (s nextUnsigned:3 MSB:true) hexPrintString.
 s := #[ 16r01 16r02 16r03 16r04 16r05 16r06 16r07 16r08 16r09 ] readStream.
 (s nextUnsigned:9 MSB:true) hexPrintString.
 s := #[ 16r01 16r02 16r03 16r04 16r05 ] readStream.
 (s nextUnsigned:3 MSB:false) hexPrintString.
 s := #[ 16r01 16r02 16r03 16r04 16r05 16r06 16r07 16r08 16r09 ] readStream.
 (s nextUnsigned:9 MSB:false) hexPrintString.
 "
 !
 nextUnsignedInt16MSB:msbFlag
 "return an unsigned short (2 bytes) from the stream.
 bL := b3.
 ] ifFalse:[
 bH := b3.
 bM := b2.
 bL := b1.
 ].
 ^ (((bH bitShift:8) bitOr:bM) bitShift:8) bitOr:bL
 "
 ((ReadStream on:#[16r10 16r20 16r30]) nextUnsignedInt24MSB:true) hexPrintString
 ((ReadStream on:#[16r10 16r20 16r30]) nextUnsignedInt24MSB:false) hexPrintString
 Network byte order is MSB-first per definition"
 ^ self nextInt64MSB:true
 !
 nextNumber:numBytes
 "Return the next n bytes as a positive Integer;
 bytes are taken msb-first."
 ^ self nextUnsigned:numBytes MSB:true
 !
 s nextPutByte:2.
 s contents
 "
 !
 nextNumber:n put:v
 "Append to the receiver the argument, v, which is a positive Integer,
 as the next n bytes. Bytes are written msb first.
 Possibly pad with leading zeros.
 The receiver must support writing of binary bytes."
 self nextNumber:n put:v MSB:true
 !
 nextNumber:n put:v MSB:msb
 "Append to the receiver the argument, v, which is a positive Integer,
 as the next n bytes.
 Bytes are written in the specified byte order.
 Possibly pad with leading zeros (trailing zeros, if lsb).
 The receiver must support writing of binary bytes."
 |vlen "{ Class: SmallInteger }"
 i    "{ Class: SmallInteger }"
 (v between:0 and:16rFFFF) ifTrue:[
 bl := (v bitAnd:16rFF).
 bh := (v bitShift:-8) bitAnd:16rFF.
 msb ifTrue:[
 self nextPutByte:bh; nextPutByte:bl.
 ] ifFalse:[
 self nextPutByte:bl; nextPutByte:bh.
 ].
 ^ self
 ].
 ].
 n == 3 ifTrue:[
 (v between:0 and:16rFFFFFF) ifTrue:[
 self nextPutByte:bl.
 ] ifFalse:[
 self nextPutByte:bl.
 self nextPutByte:bm.
 self nextPutByte:bh.
 ].
 ^ self
 ].
 ].
 n == 4 ifTrue:[
 (v between:0 and:16rFFFFFFFF) ifTrue:[
 msb ifTrue:[
 "pad with leading zeros"
 i := n.
 [i > vlen] whileTrue:[
 self nextPutByte:0.
 i := i - 1
 ].
 i == 1 ifTrue:[
 ^ self nextPutByte:v
 ].
 [i > 0] whileTrue:[
 self nextPutByte:(v digitAt:i).
 i := i - 1
 ]
 ] ifFalse:[
 1 to:vlen do:[:i |
 self nextPutByte:(v digitAt:i).
 ].
 "pad with trailing zeros"
 vlen+1 to:n do:[:i |
 self nextPutByte:0.
 ].
 ].
 "Modified: / 22-06-2006 / 11:31:13 / fm"
 !
 nextPutAllUtf16:aString
 self nextPutUtf8:(aString at:idx).
 ].
 !
 nextPutByte:aByteValue
 "write a byte.
 Same as nextPut: here; for protocol compatibility with externalStream."
 self nextPut:aByteValue
 "Created: / 22-04-1997 / 10:43:55 / cg"
 nextPutBytes:anObject
 "write bytes from an object; the number of bytes is defined by
 the object's size.
 Return the number of bytes written or nil on error.
 The object must have non-pointer indexed instvars
 (i.e. be a ByteArray, String, Float- or DoubleArray).
 Use with care - non object oriented i/o.
 Warning: in general, you cannot use this method to pass non-byte data to other
 architectures since it does not care for byte order or float representation."
 ^ self nextPutBytes:(anObject size) from:anObject startingAt:1
 "Created: 22.4.1997 / 10:44:18 / cg"
 !
 nextPutBytes:count from:anObject
 "write count bytes from an object.
 Return the number of bytes written or nil on error.
 The object must have non-pointer indexed instvars
 (i.e. be a ByteArray, String, Float- or DoubleArray).
 Use with care - non object oriented i/o.
 Warning: in general, you cannot use this method to pass non-byte data to other
 architectures since it does not care for byte order or float representation."
 ^ self nextPutBytes:count from:anObject startingAt:1
 "Created: 22.4.1997 / 10:43:59 / cg"
 ShortFloat storeBinaryIEEESingle:aFloat on:self MSB:msb.
 !
 nextPutInt16:anIntegerOrCharacter MSB:msbFlag
 "Write the argument, anIntegerOrCharacter as a short (two bytes).
 If msbFlag is true, data is written most-significant byte first;
 otherwise least first.
 Returns the receiver on ok, nil on error.
 The receiver must support writing of binary bytes.
 This interface is provided to allow talking to external programs,
 where it's known that the byte order is some definite one.
 "
 |s|
 s := #[] writeStream.
 s nextPutInt16:16r1234 MSB:false.
 s contents.
 "
 "
 |s|
 s := #[] writeStream.
 "Created: 10.1.1996 / 19:50:33 / cg"
 !
 nextPutInt32:aNumber MSB:msbFlag
 "Write the argument, aNumber as a long (four bytes).
 If msbFlag is true, data is written most-significant byte first;
 otherwise least first.
 Returns the receiver on ok, nil on error.
 The receiver must support writing of binary bytes.
 This interface is provided to allow talking to external programs,
 where it's known that the byte order is some definite one.
 s := #[] writeStream.
 s nextPutInt32:16r12345678 MSB:false.
 bytes := s contents.
 s := bytes readStream.
 (s nextInt32MSB:false) hexPrintString.
 "
 "
 |s bytes|
 s := #[] writeStream.
 s nextPutInt32:16r12345678 MSB:true.
 bytes := s contents.
 s := bytes readStream.
 (s nextInt32MSB:true) hexPrintString.
 .
 "
 "
 |s bytes|
 s := #[] writeStream.
 s nextPutInt32:16r-80000000 MSB:true.
 bytes := s contents.
 s := bytes readStream.
 (s nextInt32MSB:true) hexPrintString.
 "
 "
 |s bytes|
 s := #[] writeStream.
 s nextPutInt32:16r-80000000 MSB:false.
 bytes := s contents.
 s := bytes readStream.
 (s nextInt32MSB:false) hexPrintString.
 "
 "Modified: / 01-11-1997 / 18:30:52 / cg"
 "Modified: / 22-06-2006 / 11:31:43 / fm"
 !
 ^ self nextPutInt32:aNumber MSB:true
 !
 nextPutInt64:aNumber MSB:msbFlag
 "Write the argument, aNumber as a longlong (8 bytes).
 If msbFlag is true, data is written most-significant byte first;
 otherwise least first.
 Returns the receiver on ok, nil on error.
 The receiver must support writing of binary bytes.
 This interface is provided to allow talking to external programs,
 where it's known that the byte order is some definite one.
 s := #[] writeStream.
 s nextPutInt64:16r123456789abcdef0 MSB:false.
 bytes := s contents.
 s := bytes readStream.
 (s nextUInt64MSB:false) hexPrintString.
 "
 "
 |s bytes|
 s := #[] writeStream.
 s nextPutInt64:16r123456789abcdef0 MSB:true.
 bytes := s contents.
 s := bytes readStream.
 (s nextUInt64MSB:true) hexPrintString.
 "
 "
 |s bytes|
 s := #[] writeStream.
 s nextPutInt64:16r-8000000000000000 MSB:true.
 bytes := s contents.
 s := bytes readStream.
 (s nextUInt64MSB:true) hexPrintString.
 "
 "
 |s bytes|
 s := #[] writeStream.
 s nextPutInt64:16r-8000000000000000 MSB:false.
 bytes := s contents.
 s := bytes readStream.
 (s nextUInt64MSB:false) hexPrintString.
 "
 "Modified: / 01-11-1997 / 18:30:52 / cg"
 "Modified: / 22-06-2006 / 11:31:37 / fm"
 !
 nextPutUtf16:(Character codePoint:16r10CCCC)
 yourself) contents
 "
 !
 nextPutUtf16Bytes:aCharacter MSB:msb
 "append my UTF-16 representation to the argument, aStream.
 UTF-16 can encode only characters with code points between 0 to 16r10FFFF.
 The underlying stream must support writing of bytes."
 |codePoint|
 codePoint := aCharacter codePoint.
 (codePoint <= 16rD7FF
 or:[ codePoint >= 16rE000 and:[ codePoint <= 16rFFFF ] ])
 ifTrue:[ self nextPutInt16:codePoint MSB:msb. ]
 ifFalse:[
 codePoint <= 16r10FFFF ifTrue:[
 |highBits lowBits|
 ].
 EncodingError raiseWith:aCharacter errorString:'codePoint > 31bit in #nextPutUtf8:'.
 "
 (String streamContents:[:s|
 s nextPutUtf8:$a.
 s nextPutUtf8:$�.
 s nextPutUtf8: (Character value:16r1fff).
 s nextPutUtf8: (Character value:16rffff).
 s nextPutUtf8: (Character value:16r1ffffff).
 s nextPutUtf8: (Character value:16r800).
 ])
 asByteArray
 "
 ! !
 !Stream methodsFor:'non homogenous writing - obsolete'!
 nextPutHyper:aNumber MSB:msbFlag
 <resource: #obsolete>
 "Write the argument, aNumber as a hyper (8 bytes).
 If msbFlag is true, data is written most-significant byte first;
 otherwise least first.
 Returns the receiver on ok, nil on error.
 The receiver must support writing of binary bytes.
 This interface is provided to allow talking to external programs,
 where it's known that the byte order is some definite one.
 s := #[] writeStream.
 s nextPutHyper:16r123456789abcdef0 MSB:false.
 bytes := s contents.
 s := bytes readStream.
 (s nextHyperMSB:false) hexPrintString.
 "
 "
 |s bytes|
 s := #[] writeStream.
 s nextPutHyper:16r123456789abcdef0 MSB:true.
 bytes := s contents.
 s := bytes readStream.
 (s nextHyperMSB:true) hexPrintString.
 .
 "
 "
 |s bytes|
 s := #[] writeStream.
 s nextPutHyper:16r-8000000000000000 MSB:true.
 bytes := s contents.
 s := bytes readStream.
 (s nextHyperMSB:true) hexPrintString.
 "
 "
 |s bytes|
 s := #[] writeStream.
 s nextPutHyper:16r-8000000000000000 MSB:false.
 bytes := s contents.
 s := bytes readStream.
 (s nextHyperMSB:false) hexPrintString.
 "
 "Modified: / 01-11-1997 / 18:30:52 / cg"
 "Modified: / 22-06-2006 / 11:31:37 / fm"
 !
 nextPutLong:aNumber MSB:msbFlag
 <resource: #obsolete>
 "Write the argument, aNumber as a long (four bytes).
 If msbFlag is true, data is written most-significant byte first;
 otherwise least first.
 Returns the receiver on ok, nil on error.
 The receiver must support writing of binary bytes.
 This interface is provided to allow talking to external programs,
 where it's known that the byte order is some definite one.
 s := #[] writeStream.
 s nextPutLong:16r12345678 MSB:false.
 bytes := s contents.
 s := bytes readStream.
 (s nextLongMSB:false) hexPrintString.
 "
 "
 |s bytes|
 s := #[] writeStream.
 s nextPutLong:16r12345678 MSB:true.
 bytes := s contents.
 s := bytes readStream.
 (s nextLongMSB:true) hexPrintString.
 .
 "
 "
 |s bytes|
 s := #[] writeStream.
 s nextPutLong:16r-80000000 MSB:true.
 bytes := s contents.
 s := bytes readStream.
 (s nextLongMSB:true) hexPrintString.
 "
 "
 |s bytes|
 s := #[] writeStream.
 s nextPutLong:16r-80000000 MSB:false.
 bytes := s contents.
 s := bytes readStream.
 (s nextLongMSB:false) hexPrintString.
 "
 "Modified: / 01-11-1997 / 18:30:52 / cg"
 "Modified: / 22-06-2006 / 11:31:43 / fm"
 !
 "Created: 10.1.1996 / 19:50:23 / cg"
 !
 nextPutShort:anIntegerOrCharacter MSB:msbFlag
 <resource: #obsolete>
 "Write the argument, anIntegerOrCharacter as a short (two bytes).
 If msbFlag is true, data is written most-significant byte first;
 otherwise least first.
 Returns the receiver on ok, nil on error.
 The receiver must support writing of binary bytes.
 This interface is provided to allow talking to external programs,
 where it's known that the byte order is some definite one.
 "
 |s|
 s := #[] writeStream.
 s nextPutShort:16r1234 MSB:false.
 s contents.
 "
 "
 |s|
 s := #[] writeStream.
 !Stream methodsFor:'private'!
 contentsSpecies
 "this should return the class of which an instance is
 returned by the #contents method. Here, Array is returned,
 since the abstract Stream-class has no idea of the underlying
 collection class.
 It is redefined in some subclasses - for example, to return String."
 ^ Array
 "Modified: 15.5.1996 / 17:53:31 / cg"
 ^ nil
 !
 numAvailableForRead
-"answer the nuber of bytes available for reading"
+"answer the number of bytes available for reading"
 ^ self size
 !
 numberOfTerminalCols
 ^ self lineLength
 next:count
 "return the next count elements of the stream as aCollection,
 which depends on the streams type - (see #contentsSpecies)."
 |answerStream
 cnt  "{ Class: SmallInteger }" |
 cnt := count.
 answerStream := WriteStream on:(self contentsSpecies new:cnt).
 1 to:cnt do:[:index | |next|
 answerStream nextPut:(self next)
 ].
 ^ answerStream contents
 "
 (ReadStream on:#(1 2 3 4 5)) nextAvailable:3
 (ReadStream on:#(1 2 3 4 5)) nextAvailable:10
 (ReadStream on:'hello') nextAvailable:3
 (ReadStream on:'hello') nextAvailable:10
 "
 "Modified: / 16.6.1998 / 15:52:41 / cg"
 !
 self atEnd ifTrue:[^ nil].
 ^ self next
 !
 skip:numberToSkip
 "skip numberToSkip objects, return the receiver"
 "don't know how to unread ..."
 numberToSkip < 0 ifTrue:[
 PositionError raiseRequest.
 "Modified: / 30.7.1999 / 12:12:10 / cg"
 !
 skipFor:anObject
 "skip all objects up-to and including anObject;
 read and return the element after anObject."
 (self skipThrough:anObject) notNil ifTrue:[
 ^ self next
 ].
 ^ nil
 "
 |s next rest|
 s := ReadStream on:#(1 2 3 4 5 6 7 8).
 next := s skipFor:4.
 rest := s upToEnd.
 "
 "
 |s next rest|
 s := ReadStream on:'12345678'.
 next := s skipFor:$4.
 ^ self skipThrough:Character cr
 !
 skipThrough:anObject
 "skip all objects up-to and including anObject.
 Return the receiver if skip was successful,
 otherwise (i.e. if not found) return nil and leave the stream positioned at the end.
 The next read operation will return the element after anObject."
 |nextElement|
 "
 |s|
 s := ReadStream on:#(1 2 3 4 5 6 7 8).
 s skipThrough:4.
 s skipThrough:4.
 s next
 "
 "
 |s|
 s := ReadStream on:'12345678'.
 s skipThrough:$4.
 s next
 "
 "
 |s|
 s := ReadStream on:'12345678'.
 s skipThrough:$4.
 s skipThrough:$4.
 s next
 "
 "
 |s|
 s := ReadStream on:'12345678'.
 s skipThrough:$4.
 s skipThrough:$4.
 s atEnd
 "
 !
 skipThroughAll:aCollection
 "skip for and through the sequence given by the argument, aCollection;
 return nil if not found, the receiver otherwise.
 On a successful match, the next read will return elements after aCollection;
 if no match was found, the receiver will be positioned at the end."
 |buffer l first idx|
 l := aCollection size.
 first := aCollection at:1.
 [self atEnd] whileFalse:[
-	buffer isNil ifTrue:[
+buffer isNil ifTrue:[
-	    buffer := self nextAvailable:l.
+buffer := self nextAvailable:l.
-	].
+].
-	buffer = aCollection ifTrue:[
+buffer = aCollection ifTrue:[
-	    ^ self
+^ self
-	].
+].
-	idx := buffer indexOf:first startingAt:2.
+idx := buffer indexOf:first startingAt:2.
-	idx == 0 ifTrue:[
+idx == 0 ifTrue:[
-	    buffer := nil
+buffer := nil
-	] ifFalse:[
+] ifFalse:[
-	    buffer := (buffer copyFrom:idx) , (self nextAvailable:(idx - 1))
+buffer := (buffer copyFrom:idx) , (self nextAvailable:(idx - 1))
-	]
+]
 ].
 ^ nil
 "
 |s|
 s := ReadStream on:'12345678901234567890'.
 s skipThroughAll:'901'.
 s upToEnd
 "
 "
 |s|
 s := ReadStream on:'12345678901234567890'.
 s skipThroughAll:'1234'.
 s upToEnd
 "
 "
 |s|
 s := ReadStream on:'12345678901234567890'.
 s skipThroughAll:'999'.
 s atEnd
 "
 "Created: 11.1.1997 / 18:55:13 / cg"
 "Modified: 11.1.1997 / 19:09:06 / cg"
 !
 skipUntil:aBlock
 "skip all elements for which aBlock returns false.
 Return true if more elements can be read, false if eof has been reached."
 [self atEnd] whileFalse:[
 (aBlock value: self peek) ifTrue:[^ true].
 self next
 "Created: / 23-09-2011 / 13:32:40 / cg"
 !
 through:anObject
 "read a collection of all objects up-to anObject and return these
 elements, including anObject.
 The next read operation will return the element after anObject.
 If anObject is not encountered, all elements up to the end are read
 and returned.
 Compare this with #upTo: which also reads up to some object
 and also positions behind it, but does not include it in the returned
 |answerStream element|
 answerStream := WriteStream on:(self contentsSpecies new).
 [self atEnd] whileFalse:[
-	element := self next.
+element := self next.
-	answerStream nextPut:element.
+answerStream nextPut:element.
-	(element = anObject) ifTrue: [
+(element = anObject) ifTrue: [
-	    ^ answerStream contents
+^ answerStream contents
-	]
+]
 ].
 ^ answerStream contents
 "
 |s|
 s := ReadStream on:#(1 2 3 4 5 6 7 8).
 Transcript showCR:(s through:4).
 Transcript showCR:s next
 |s|
 s := ReadStream on:#(1 2 3 4 5 6 7 8).
 Transcript showCR:(s through:9).
 Transcript showCR:s next
 |s|
 s := ReadStream on:'hello world'.
 Transcript showCR:(s through:Character space).
 "Modified: 17.5.1996 / 08:51:40 / cg"
 !
 throughAll:aCollection
 "read & return a collection of all objects up-to and including
 a subcollection given by aCollection.
 (i.e. read until a ``substring'' is encountered.)
 The next read operation will return the element after aCollection.
 If aCollection is not encountered, all elements up to the end are read
 and returned."
 |answerStream element last rslt|
 last := aCollection last.
 answerStream := WriteStream on:(self contentsSpecies new).
 [self atEnd] whileFalse:[
-	element := self next.
+element := self next.
-	answerStream nextPut:element.
+answerStream nextPut:element.
-	element == last ifTrue:[
+element == last ifTrue:[
-	    ((rslt := answerStream contents) endsWith:aCollection) ifTrue:[
+((rslt := answerStream contents) endsWith:aCollection) ifTrue:[
-		^ rslt
+^ rslt
-	    ]
+]
-	].
+].
 ].
 ^ answerStream contents
 "
 |s|
 s := ReadStream on:#(1 2 3 4 5 6 7 8).
 Transcript showCR:(s throughAll:#(4 4 4)).
 Transcript showCR:s next
 |s|
 s := ReadStream on:#(1 2 3 4 5 6 7 8).
 Transcript showCR:(s throughAll:#(4 5 6)).
 Transcript showCR:s next
 |s|
 s := ReadStream on:'hello world, this is some text'.
 Transcript showCR:(s throughAll:'world').
 Transcript showCR:(s throughAll:'some').
 Transcript showCR:s upToEnd.
 "
 "Modified: 15.7.1996 / 09:08:07 / cg"
 !
 throughAny:aCollection
 "read & return a collection of all objects up-to and including
 an element contained in aCollection.
 (i.e. read until any from aCollection is encountered.)
 If no such character is encountered, all elements up to the end are read
 and returned."
 ^ answerStream contents
 "
 |s|
 s := ReadStream on:#(1 2 3 4 5 6 7 8).
 Transcript showCR:(s throughAny:#(3 4 5)).
 Transcript showCR:s next
 |s|
 s := ReadStream on:'hello world, this is some text'.
 Transcript showCR:(s throughAny:'wt').
 Transcript showCR:(s throughAny:'wt').
 Transcript showCR:s upToEnd.
 "
 "Modified: / 11.1.1998 / 15:28:04 / cg"
 !
 "
 !
 upTo:anObject
 "read a collection of all objects up-to anObject and return these
 elements, but excluding anObject.
 The next read operation will return the element after anObject.
 (i.e. anObject is considered a separator, which is skipped)
 Similar to #through:, but the matching object is not included in the
 returned collection.
 If anObject is not encountered, all elements up to the end are read
 ^ answerStream contents
 "
 |s|
 s := ReadStream on:#(1 2 3 4 5 6 7 8).
 Transcript showCR:(s upTo:4).
 Transcript showCR:s next
 compare the above to:
 |s|
 s := ReadStream on:#(1 2 3 4 5 6 7 8).
 Transcript showCR:(s through:4).
 Transcript showCR:s next
 |s|
 s := ReadStream on:#(1 2 3 4 5 6 7 8).
 Transcript showCR:(s upTo:9).
 Transcript showCR:s next
 |s|
 s := ReadStream on:'hello world'.
 Transcript showCR:(s upTo:Character space).
 Transcript showCR:(s upToEnd)
 (ReadStream on:'12345678905') upTo:$5; next
 (ReadStream on:'12345678905') upTo:$5; upTo:$5
 (ReadStream on:'123456') upTo:$7
 (ReadStream on:#(1 2 3 4 5 6)) upTo:4
 (ReadStream on:'line 1
 line 2') upTo:Character cr
 'Makefile' asFilename readStream upTo:Character cr;upTo:Character cr
 "
 "Modified: / 12.1.1998 / 21:58:38 / cg"
 "Modified: / 15.1.1998 / 23:28:47 / stefan"
 !
 "Created: / 15.6.1998 / 19:11:31 / cg"
 !
 upToAny:aCollectionOfObjects
 "read a collection of all objects up-to a element which is contained in
 aCollectionOfObjects and return these elements, but excluding the matching one.
 The next read operation will return the element AFTER anObject.
 If no such element is encountered, all elements up to the end are read
 and returned.
 Compare this with #throughAll: which also reads up to some object
 and also positions behind it, but DOES include it in the returned
 |s|
 s := ReadStream on:'hello world'.
 Transcript showCR:(s upToAny:(Array with:Character space)).
 Transcript showCR:(s upToEnd)
 'Makefile' asFilename readStream upToAny:($A to:$Z)
 "
 "Created: / 30.8.1997 / 03:02:05 / cg"
 "Modified: / 11.1.1998 / 15:19:18 / cg"
 !
 upToBeforeAny:aCollectionOfObjects
 "read a collection of all objects up-to a element which is contained in
 aCollectionOfObjects and return these elements, but excluding the matching one.
 The next read operation will return the matching element.
 If no such element is encountered, all elements up to the end are read
 and returned.
 This returns the exact same as upToAny: would, but leaves the stream's position so that
 the next read returns the matching delimiter instead of skipping it.
 "
 |s|
 s := ReadStream on:'hello world'.
 Transcript showCR:(s upToBeforeAny:(Array with:Character space)).
 Transcript showCR:(s upToEnd)
 'Make.proto' asFilename readStream upToBeforeAny:($A to:$Z)
 "
 "Created: / 30.8.1997 / 03:02:05 / cg"
 "Modified: / 11.1.1998 / 15:19:18 / cg"
 !
 |answerStream|
 answerStream := WriteStream on:(self contentsSpecies new).
 [self atEnd] whileFalse:[
-	answerStream nextPut:(self next)
+answerStream nextPut:(self next)
 ].
 ^ answerStream contents
 "
 (ReadStream on:'1234567890') upToEnd
 ('123456' readStream) next; next; upToEnd
 ('1 23456' readStream) upTo:Character space; upToEnd
 ('12' readStream) next; next; upToEnd
 "
 "Modified: 15.5.1996 / 18:00:39 / cg"
 !
 "/        self next.
 "/    ].
 "/    ^ answerStream contents
 "
 'hello world' readStream upToMatching:[:c | c isSeparator].
 "
 "
 'helloworld' readStream upToMatching:[:c | c isSeparator].
 "
 "
 |s|
 s := 'hello world' readStream.
 upToSeparator
 "Return the next elements up to but not including the next separator.
 The next read will return the separator.
 If no separator is encountered, the contents up to the end is returned.
 The elements are supposed to understand #isSeparator
 (i.e. the receiver is supposed to be a character-stream)."
 ^ self upToElementForWhich:[:ch | ch isSeparator]
 "
 'hello world' readStream upToSeparator
 'helloworld' readStream upToSeparator
 'helloworld' readStream upToSeparator
 '' readStream upToSeparator
 |s|
 s := 'hello world' readStream.
 s upToSeparator.
 s upToEnd
 "
 "Modified: 4.1.1997 / 23:38:05 / cg"
 ! !
 self upTo:Character cr into:answerStream.
 (answerStream size ~~ 0 and:[answerStream last = Character return]) ifTrue:[
 answerStream backStep.
 ].
 ^ answerStream contents
 "Modified: / 19.5.1998 / 17:26:25 / cg"
 ! !
 formatSpec expandPlaceholders:$% with:args on:self
 "
 1 to: 10 do:[:i |
 Transcript
 format:'[%1] Hello %2 World - this is %3%<cr>'
 with:{i . 'my' . 'nice'}
 ].
 "
 !
 "put all elements of the argument, aCollection onto the receiver.
 This is only allowed, if the receiver supports writing."
 (aCollection notNil and:[aCollection isSequenceable]) ifFalse:[
 "/ fallback
 aCollection do:[:eachElement|
 self nextPut:eachElement.
 ].
 ^ self.
 ].
 "
 |s|
 s := WriteStream on:(String new).
 s nextPutAll:($a to:$f).
 s nextPutAll:'one ';
 nextPutAll:'two ';
 nextPutAll:'three'.
 s contents
 "
 nextPutAll:count from:aCollection startingAt:initialIndex
 "append count elements with index starting at initialIndex
 of the argument, aCollection onto the receiver.
 This is only allowed, if the receiver supports writing.
 Answer the number of elements that were appended.
 This is for compatibility with ExternalStream, where less then
 count elements may be written. Dolphin defines this as well."
 self nextPutAll:aCollection startingAt:initialIndex to:initialIndex+count-1.
 ^ count
 "
 |s|
 s := WriteStream on:#().
 s nextPutAll:#('one' 'two' 'three' 'four' 'five') startingAt:2.
 s contents
 "
 "Modified: 11.7.1996 / 10:00:28 / cg"
 !
 "Modified: 11.7.1996 / 10:00:32 / cg"
 !
 nextPutAllLines:aCollectionOfStrings
 "put all elements of the argument, aCollection as individual lines
 onto the receiver, append a cr (carriage return) after each.
 This is only useful with character streams in textMode,
 and only allowed, if the receiver supports writing."
 aCollectionOfStrings do:[:eachLine |
 self nextPutLine:eachLine.
 "Created: / 26-09-2012 / 18:21:06 / cg"
 !
 printf:format
 "C-style printing into a stream"
 format printf:#() on:self.
 "
 Transcript printf:'Hello World\n'
 "
 !
 printf:format with:argument
 "C-style printing into a stream"
 format printf:{argument} on:self.
 "
 Transcript printf:'%05x\n' with:12345
 "
 !
 printf:format with:argument1 with:argument2
 "C-style printing into a stream"
 format printf:{argument1 . argument2} on:self.
 "
 Transcript printf:'%05x %3s\n' with:12345 with:'abc'
 "
 !
 printf:format with:argument1 with:argument2 with:argument3
 "C-style printing into a stream"
 format printf:{argument1 . argument2 . argument3} on:self.
 "
 Transcript printf:'%05x %3s %09s\n' with:12345 with:'abc' with:'abc'
 Transcript printf:'%05x %3s %9s\n' with:12345 with:'abc' with:'abc'
 "
 !
 printf:format with:argument1 with:argument2 with:argument3 with:argument4
 "C-style printing into a stream"
 format printf:{argument1 . argument2 . argument3 . argument4} on:self.
 "
 Transcript printf:'%02x %02x %02x %02x\n' with:1 with:2 with:3 with:4
 Transcript printf:'%2x %2x %2x %2x\n' with:1 with:2 with:3 with:4
 "
 !
 printf:format with:argument1 with:argument2 with:argument3 with:argument4 with:argument5
 "C-style printing into a stream"
 format printf:{argument1 . argument2 . argument3 . argument4 . argument5} on:self.
 "
 Transcript printf:'%02x %02x %02x %02x\n' with:1 with:2 with:3 with:4
 Transcript printf:'%2x %2x %2x %2x\n' with:1 with:2 with:3 with:4
 "
 !
 printf:format withAll:arguments
 "C-style printing into a stream"
 format printf:arguments on:self.
 "
 Transcript printf:'%05x %d %f %o\n' withAll:{ 123. 234*5. 1.234. 8r377 }
 Transcript printf:'%03d %03d %03d\n' withAll:{ 1. 2. 3 }
 !
 show:something
 "append a printed representation of the argument to the stream.
 This makes streams somewhat compatible to TextCollectors and
 allows you to say:
 Smalltalk at:#Transcript put:Stdout
 or to use #show:/#showCR: with internal or external streams."
 something printOn:self
 !
 show:something with:arg
 "append a printed representation of the argument to the stream, expanding
 the placeHolder %1 with the printString of arg.
 This makes streams somewhat compatible to TextCollectors and
 allows you to say:
 Smalltalk at:#Transcript put:Stdout
 or to use #show:/#showCR: with internal or external streams."
 self show:(something bindWith:arg)
 show:something with:arg1 with:arg2
 "append a printed representation of the argument to the stream, expanding
 the placeHolders %1 and %2 with the printStrings of arg1 and arg2.
 This makes streams somewhat compatible to TextCollectors and
 allows you to say:
 Smalltalk at:#Transcript put:Stdout
 or to use #show:/#showCR: with internal or external streams."
 self show:(something bindWith:arg1 with:arg2)
 show:something with:arg1 with:arg2 with:arg3
 "append a printed representation of the argument to the stream, expanding
 the placeHolders %1,%2 and %3 with the printStrings of arg1, arg2 and arg3.
 This makes streams somewhat compatible to TextCollectors and
 allows you to say:
 Smalltalk at:#Transcript put:Stdout
 or to use #show:/#showCR: with internal or external streams."
 self show:(something bindWith:arg1 with:arg2 with:arg3)
 show:something with:arg1 with:arg2 with:arg3 with:arg4
 "append a printed representation of the argument to the stream, expanding
 the placeHolders %1,%2 and %3 with the printStrings of arg1, arg2 and arg3.
 This makes streams somewhat compatible to TextCollectors and
 allows you to say:
 Smalltalk at:#Transcript put:Stdout
 or to use #show:/#showCR: with internal or external streams."
 self show:(something bindWith:arg1 with:arg2 with:arg3 with:arg4)
 show:something with:arg1 with:arg2 with:arg3 with:arg4 with:arg5
 "append a printed representation of the argument to the stream, expanding
 the placeHolders %1,%2 and %3 with the printStrings of arg1, arg2 and arg3.
 This makes streams somewhat compatible to TextCollectors and
 allows you to say:
 Smalltalk at:#Transcript put:Stdout
 or to use #show:/#showCR: with internal or external streams."
 self show:(something bindWith:arg1 with:arg2 with:arg3 with:arg4 with:arg5)
 show:something withArguments:args
 "append a printed representation of the argument to the stream, expanding
 the placeHolders %1,%2 and %3 with the printStrings of argi.
 This makes streams somewhat compatible to TextCollectors and
 allows you to say:
 Smalltalk at:#Transcript put:Stdout
 or to use #show:/#showCR: with internal or external streams."
 self show:(something bindWithArguments:args)
 !
 showCR:aString
 "append a printed representation of the argument to the stream
 and append a newline character.
 This makes streams somewhat compatible to TextCollectors and
 allows you to say:
-	Smalltalk at:#Transcript put:Stdout
+Smalltalk at:#Transcript put:Stdout
 or to use #show:/#showCR: with internal or external streams."
 self show:aString.
 self cr
 showCR:something with:arg
 "append a printed representation of the argument to the stream, expanding
 the placeHolder %1 with the printString of arg.
 This makes streams somewhat compatible to TextCollectors and
 allows you to say:
 Smalltalk at:#Transcript put:Stdout
 or to use #show:/#showCR: with internal or external streams."
 self showCR:(something bindWith:arg)
 showCR:something with:arg1 with:arg2
 "append a printed representation of the argument to the stream, expanding
 the placeHolders %1 and %2 with the printStrings of arg1 and arg2.
 This makes streams somewhat compatible to TextCollectors and
 allows you to say:
 Smalltalk at:#Transcript put:Stdout
 or to use #show:/#showCR: with internal or external streams."
 self showCR:(something bindWith:arg1 with:arg2)
 showCR:something with:arg1 with:arg2 with:arg3
 "append a printed representation of the argument to the stream, expanding
 the placeHolders %1,%2 and %3 with the printStrings of arg1, arg2 and arg3.
 This makes streams somewhat compatible to TextCollectors and
 allows you to say:
 Smalltalk at:#Transcript put:Stdout
 or to use #show:/#showCR: with internal or external streams."
 self showCR:(something bindWith:arg1 with:arg2 with:arg3)
 showCR:something with:arg1 with:arg2 with:arg3 with:arg4
 "append a printed representation of the argument to the stream, expanding
 the placeHolders %1,%2 and %3 with the printStrings of arg1, arg2 and arg3.
 This makes streams somewhat compatible to TextCollectors and
 allows you to say:
 Smalltalk at:#Transcript put:Stdout
 or to use #show:/#showCR: with internal or external streams."
 self showCR:(something bindWith:arg1 with:arg2 with:arg3 with:arg4)
 showCR:something with:arg1 with:arg2 with:arg3 with:arg4 with:arg5
 "append a printed representation of the argument to the stream, expanding
 the placeHolders %1,%2 and %3 with the printStrings of arg1, arg2 and arg3.
 This makes streams somewhat compatible to TextCollectors and
 allows you to say:
 Smalltalk at:#Transcript put:Stdout
 or to use #show:/#showCR: with internal or external streams."
 self showCR:(something bindWith:arg1 with:arg2 with:arg3 with:arg4 with:arg5)
 showCR:something withArguments:args
 "append a printed representation of the argument to the stream, expanding
 the placeHolders %1,%2 and %3 with the printStrings of argi.
 This makes streams somewhat compatible to TextCollectors and
 allows you to say:
 Smalltalk at:#Transcript put:Stdout
 or to use #show:/#showCR: with internal or external streams."
 self showCR:(something bindWithArguments:args)
 !
 !Stream methodsFor:'writing-chunks'!
 nextChunkPut:aString
 "put aString as a chunk onto the receiver;
 double all exclamation marks except within primitives and append a
 single delimiting exclamation mark at the end.
 This modification of the chunk format (not doubling exclas in primitive code)
 was done to have primitive code more readable and easier be edited in the fileBrowser
 or other editors.
 It's no incompatibility, since inline primitives are an ST/X special
 index := 1.
 stop := endIndex + 1.
 [index <= endIndex] whileTrue:[
 "
 find position of next interesting character;
 output stuff up to that one in one piece
 "
 next := aString indexOfAny:stopChars startingAt:index ifAbsent:stop.
 ((index == 1) and:[next == stop]) ifTrue:[

branch	jv
changeset 20244	20922299fd44
parent 20206	51652e7f46dd
parent 20242	92d211a6151f
child 20342	219a5a47e8b1