"

 COPYRIGHT (c) 1989 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

Object subclass:#Stream

	instanceVariableNames:'signalAtEnd'

	classVariableNames:'StreamErrorSignal PositionErrorSignal ReadErrorSignal

		WriteErrorSignal EndOfStreamSignal'

	poolDictionaries:''

	category:'Streams'

!

!Stream class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1989 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    An abstract class defining common behavior for all stream-like objects.

    See concrete subclasses for more detail.

    The protocol as implemented here is often only provided as a fallBack

    for very uncommon cases. Much of it is redefined for performance.

    (In streams which know more about their internal representation ...)

    Subclasses should (at least) implement:

        #next           (if readable)

        #nextPut:       (if writable)

        #contents

        #atEnd

        #isReadable

        #isWritable

    Peekable & Positionable streams should (at least) implement:

        #peek

        #position

        #position:

    [Class variables:]

        StreamErrorSignal       <Signal>        parent of all stream errors

        PositionErrorSignal     <Signal>        position attemted on a stream

                                                which does not support positioning

        ReadErrorSignal         <Signal>        raised on read errors

        WriteErrorSignal        <Signal>        raised on write errors

        EndOfStreamSignal       <Signal>        raised at end of stream

    [author:]

        Claus Gittinger

"

! !

!Stream class methodsFor:'initialization'!

initialize

    StreamErrorSignal isNil ifTrue:[

	StreamErrorSignal := ErrorSignal newSignalMayProceed:false.

	StreamErrorSignal nameClass:self message:#streamErrorSignal.

	StreamErrorSignal notifierString:'Stream error'.

	PositionErrorSignal := StreamErrorSignal newSignalMayProceed:true.

	PositionErrorSignal nameClass:self message:#positionErrorSignal.

	PositionErrorSignal notifierString:'stream as no concept of a position'.

	ReadErrorSignal := StreamErrorSignal newSignalMayProceed:false.

	ReadErrorSignal nameClass:self message:#readErrorSignal.

	ReadErrorSignal notifierString:'read error'.

	WriteErrorSignal := StreamErrorSignal newSignalMayProceed:false.

	WriteErrorSignal nameClass:self message:#writeErrorSignal.

	WriteErrorSignal notifierString:'write error'.

	EndOfStreamSignal := StreamErrorSignal newSignalMayProceed:false.

	EndOfStreamSignal nameClass:self message:#endOfStreamSignal.

	EndOfStreamSignal notifierString:'end of stream'.

    ]

! !

!Stream class methodsFor:'instance creation'!

new

    "{ Pragma: +optSpace }"

    "report an error - Streams are created using on:-messages"

    ^ self error:'Streams cannot be created with new'

! !

!Stream class methodsFor:'Signal constants'!

endOfStreamSignal

    "return the signal raised if read past end of stream is attemted"

    ^ EndOfStreamSignal

!

positionErrorSignal

    "return the signal raised if positioning is requested for

     a stream which does not support that kind of operation"

    ^ PositionErrorSignal

!

readErrorSignal

    "return the signal raised on read errors"

    ^ ReadErrorSignal

!

streamErrorSignal

    "return the parent of all stream errors;

     handling this one also handles all other errors.

     Also, this one may be raised for errors not related to read/write

     operations, such as failed ioctls in externalStream etc."

    ^ StreamErrorSignal

!

writeErrorSignal

    "return the signal raised on write errors"

    ^ WriteErrorSignal

! !

!Stream methodsFor:'accessing'!

contents

    "return the entire contents of the stream

     - we do not know here how to do it, it must be redefined in subclasses."

    ^ self subclassResponsibility

    "Modified: 15.5.1996 / 17:36:29 / cg"

!

signalAtEnd

    "return the signalAtEnd flag setting. If true, reading past the end

     will raise an EndOfStream exception. If false, no exception is

     raised and nil is returned from all reading messages.

     The default is (currently) to NOT raise a signal."

    ^ signalAtEnd

    "Created: 5.2.1996 / 18:24:53 / stefan"

    "Modified: 15.5.1996 / 17:35:55 / cg"

!

signalAtEnd:aBoolean

    "set the signalAtEnd flag setting. If true, reading past the end

     will raise an EndOfStream exception. If false, no exception is

     raised and nil is returned from all reading messages.

     The default is (currently) to NOT raise a signal."

    signalAtEnd := aBoolean.

    "Created: 5.2.1996 / 18:24:53 / stefan"

    "Modified: 15.5.1996 / 17:36:12 / cg"

! !

!Stream methodsFor:'closing'!

close

    "close the stream - nothing done here.

     Added for compatibility with external streams."

    ^ self

! !

!Stream methodsFor:'emphasis'!

bold

    "ignored here.

     this allows Streams to be used interchangeable with printStreams"

    ^ self

    "Created: 14.5.1996 / 17:37:37 / cg"

!

boldItalic

    "ignored here.

     this allows Streams to be used interchangeable with printStreams"

    ^ self

    "Created: 14.5.1996 / 17:37:47 / cg"

!

emphasis

    "ignored here - allows Streams to be used interchangable with

     text streams"

    ^ nil

    "Created: 14.5.1996 / 17:39:45 / cg"

!

emphasis:anEmphasis

    "ignored here.

     this allows Streams to be used interchangeable with printStreams"

    ^ self

    "Created: 14.5.1996 / 17:38:07 / cg"

!

italic 

    "ignored here.

     this allows Streams to be used interchangeable with printStreams"

    ^ self

    "Created: 14.5.1996 / 17:37:55 / cg"

!

normal

    "ignored here.

     this allows Streams to be used interchangeable with printStreams"

    ^ self

    "Created: 14.5.1996 / 17:37:59 / cg"

! !

!Stream methodsFor:'enumerating'!

do:aBlock

    "evaluate the argument, aBlock for all remaining elements,

     up to the end of the stream"

    [self atEnd] whileFalse:[

	aBlock value:(self next)

    ]

    "

     |s|

     s := ReadStream on:#(1 2 3 4 5 6 7 8 9).

     s next.

     s next.

     s do:[:element | Transcript showCr:element]

    "

! !

!Stream methodsFor:'error handling'!

pastEnd

    "someone tried to read after the end of the stream.

     if signalAtEnd == true, raise a signal.

     Otherwise return nil."

    signalAtEnd == true ifTrue:[

        ^ EndOfStreamSignal raiseIn:thisContext sender

    ].

    ^ nil

    "Created: 5.2.1996 / 21:56:08 / stefan"

! !

!Stream methodsFor:'misc'!

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"

! !

!Stream methodsFor:'non homogenous reading'!

nextAlphaNumericWord

    "read the next word (i.e. up to non letter-or-digit).

     Return a string containing those characters.

     Any leading whitespace is skipped.

     This method does not advance over any non-alphanumeric characters;

     i.e. it will stick and continue to continue to return nil in this case. 

     Only call for it in a loop, AFTER you have checked for

     the next character to really be alphanumeric (using #peek)"

    |s c|

    [self atEnd not

     and:[(c := self peek) isSeparator]] whileTrue:[

        self next 

    ].

    self atEnd ifTrue:[^ nil].

    s := ''.

    [self atEnd not

     and:[(c := self peek) isLetterOrDigit]] whileTrue:[ 

        s := s copyWith:c. 

        self next 

    ].

    s size == 0 ifTrue:[^ nil].

    ^ s.

    "

     |s|

     s := 'hello world 1234 foo1 foo2' readStream.

     [s atEnd] whileFalse:[

        Transcript showCr:(s nextAlphaNumericWord).

     ].

   notice: streams end never reached this way (sticking at the '+'-character:

     |s|

     s := 'hello world 1234 foo1+foo2' readStream.

     10 timesRepeat:[

        Transcript showCr:(s nextAlphaNumericWord).

     ].

    "

    "Modified: 15.5.1996 / 17:51:42 / cg"

!

nextLine

    "return the characters upTo (but excluding) the next cr character.

     Added for protocol compatibility with externalStreams."

    ^ self upTo:Character cr.

    "Modified: 11.5.1996 / 11:17:01 / cg"

!

nextLongMSB:msbFlag

    "return a signed long (4 bytes) from the stream.

     The receiver must support reading of binary bytes."

    |high uval "{ Class: SmallInteger }"|

    msbFlag ifTrue:[

	"most significant first"

	high := self next.

	uval := self next bitShift:16.

	uval := uval bitOr:(self next bitShift:8).

	uval := uval bitOr:(self next).

	uval := uval bitOr:(high bitShift:24).

    ] ifFalse:[

	"least significant first"

	uval := self next.

	uval := uval bitOr:(self next bitShift:8).

	uval := uval bitOr:(self next bitShift:16).

	uval := uval bitOr:(self next bitShift:24).

    ].

    "change from unsigned 0..FFFFFFFF to signed -80000000..7FFFFFFF"

"/ sorry- for now (2.7), stc cannot compile LargeInteger constants 

"/    uval >= 16r80000000 ifTrue:[

"/	^ uval - 16r100000000 

"/    ].

"/ the following kludges around this

"/ well, new (2.8) can ...

    (uval bitShift:-16) >= 16r8000 ifTrue:[

	^ uval - (16r10000000 bitShift:8)

    ].

    ^ uval

!

nextLongNet

    "return a signed long (4 bytes) in network byte order from the stream.

     The receiver must support reading of binary bytes."

    ^ self nextLongMSB:(Socket networkLongOrderIsMSB)

    "Created: 10.1.1996 / 19:49:28 / cg"

!

nextNumber:n 

    "Return the next n bytes as a positive Integer; bytes are taken msb-first."

    |s 

     val "{ Class: SmallInteger }"

     rep "{ Class: SmallInteger }"|

    "claus: this method is central in binaryStorage -

     therefore it has been tuned a bit (and needs even more tuning)"

    n == 1 ifTrue:[

	^ self next

    ].

    n == 2 ifTrue:[

	val := self next.

	val := (val bitShift:8) + self next.

	^ val

    ].

    n == 3 ifTrue:[

	val := self next.

	val := (val bitShift:8) + self next.

	val := (val bitShift:8) + self next.

	^ val

    ].

    n == 4 ifTrue:[

	val := self next.

	val <= 16r3F ifTrue:[

	    val := (val bitShift:8) + self next.

	    val := (val bitShift:8) + self next.

	    val := (val bitShift:8) + self next.

	    ^ val

	].

	"sorry, but need a largeInteger"

	s := (val bitShift:8) + self next.

	s := (s bitShift:8) + self next.

	s := (s * 256) + self next.

	^ s

    ].

    "

     arbitrary long

    "

    s := 0.

    rep := n.

    rep timesRepeat:[ 

	s := s * 256 + self next

    ].

    ^ s truncated

!

nextShortMSB:msbFlag

    "return a signed short (2 bytes) from the stream.

     The receiver must support reading of binary bytes."

    |uval "{ Class: SmallInteger }"|

    msbFlag ifTrue:[

	"most significant first"

	uval := self next bitShift:8.

	uval := uval bitOr:(self next).

    ] ifFalse:[

	"least significant first"

	uval := self next.

	uval := uval bitOr:(self next bitShift:8).

    ].

    "change from unsigned 0..FFFF to signed -8000..7FFF"

    uval >= 16r8000 ifTrue:[

	^ uval - 16r10000 

    ].

    ^ uval

!

nextShortNet

    "return a signed short (2 bytes) in network byte order from the stream.

     The receiver must support reading of binary bytes."

    ^ self nextShortMSB:(Socket networkShortOrderIsMSB)

    "Modified: 10.1.1996 / 19:48:50 / cg"

    "Created: 10.1.1996 / 19:49:41 / cg"

!

nextUnsignedLongMSB:msbFlag

    "return an unsigned long (4 bytes) from the stream.

     The receiver must support reading of binary bytes."

    |val|

    msbFlag ifTrue:[

	val := self next.

	val := (val bitShift:8) bitOr:(self next).

	val := (val bitShift:8) bitOr:(self next).