"{ Encoding: utf8 }"

"

 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.

"

"{ Package: 'stx:libbasic' }"

"{ NameSpace: Smalltalk }"

ExternalStream subclass:#NonPositionableExternalStream

	instanceVariableNames:''

	classVariableNames:'StdErrorStream StdInStream StdOutStream'

	poolDictionaries:''

	category:'Streams-External'

!

!NonPositionableExternalStream primitiveDefinitions!

%{

#ifndef _STDIO_H_INCLUDED_

# include <stdio.h>

# define _STDIO_H_INCLUDED_

#endif

#ifndef REMOVE_LATER

# define __win32_stdout()        stdout

# define __win32_stderr()        stderr

# define __win32_stdin()         stdin

#else

    extern FILE *__win32_stdin();

    extern FILE *__win32_stderr();

    extern FILE *__win32_stdout();

#endif

%}

! !

!NonPositionableExternalStream 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

"

    This class provides common protocol for all non-positionable,

    external streams. Concrete subclasses are terminal streams, pipe streams,

    PrinterStreams, Sockets etc.

    There are three special instances of this class, representing stdin,

    stdout and stderr of the smalltalk/X process (see Unix manuals, if you

    don't know what those are used for). These special streams are bound to

    to globals Stdin, Stdout and Stderr at early initialization time

    (see Smalltalk>>initializeStandardStreams).

    The name of this class is a historical leftover - it should be called

    'TTYStream' or similar.

    [author:]

        Claus Gittinger

"

! !

!NonPositionableExternalStream class methodsFor:'instance creation'!

forStderr

    "{ Pragma: +optSpace }"

    "return a NonPositionableExternalStream object for writing to

     Unixes standard error output file descriptor"

    StdErrorStream isNil ifTrue:[

	StdErrorStream := self basicNew initializeForStderr

    ].

    ^ StdErrorStream

!

forStdin

    "{ Pragma: +optSpace }"

    "return a NonPositionableExternalStream object for reading from

     Unixes standard input file descriptor"

    StdInStream isNil ifTrue:[

	StdInStream := self basicNew initializeForStdin

    ].

    ^ StdInStream

!

forStdout

    "{ Pragma: +optSpace }"

    "return a NonPositionableExternalStream object for writing to

     Unixes standard output file descriptor"

    StdOutStream isNil ifTrue:[

	StdOutStream := self basicNew initializeForStdout

    ].

    ^ StdOutStream

!

makeBidirectionalPipe

    "return an array with two streams for communication in both directions.

     This is the higher level equivalent of OperatingSystem>>makeBidirectionalPipe

     (which returns an array of file-descriptors)."

    |pipe rs ws|

    "/ must protect from being unwound, otherwise the pipe-FD might not be registered for finalization

    [

        pipe := OperatingSystem makeBidirectionalPipe.

        pipe isNil ifTrue:[

            "/ ok, maybe someone has forgotten to close a stream; enforce finalization and try again

            Logger info:'makePipe: enforcing finalization to close any open streams'.

            ObjectMemory garbageCollect; finalize.

            pipe := OperatingSystem makeBidirectionalPipe.

            pipe isNil ifTrue:[

                |errorNumber errorHolder|

                errorNumber := OperatingSystem lastErrorNumber.

                errorHolder := errorNumber.

                OpenError newException

                    errorCode:errorNumber;

                    osErrorHolder:errorHolder;

                    raise.

            ].

        ].

        rs := PipeStream forFileDescriptor:(pipe at:1) mode:#readWrite buffered:false handleType:#pipeFilePointer.

        ws := PipeStream forFileDescriptor:(pipe at:2) mode:#readWrite buffered:false handleType:#pipeFilePointer.

    ] valueUninterruptably.

    ^ Array with:rs with:ws

    "

     |pipe rs ws|

     pipe := NonPositionableExternalStream makeBidirectionalPipe.

     rs := pipe at:1.

     ws := pipe at:2.

     'read ...'.

     [

         1 to:10 do:[:i |

             Transcript showCR:rs nextLine

         ].

         rs close.

     ] forkAt:7.

     'write ...'.

     [

         1 to:10 do:[:i |

             ws nextPutAll:'hello world '; nextPutAll:i printString; cr

         ].

         ws close.

     ] fork.

    "

    "Modified: / 04-11-2018 / 11:19:35 / Claus Gittinger"

!

makePTYPair

    "return an array with two streams - the first one is the master,

     the second the slave of a ptym/ptys pair.

     (actually, there is a third element, which is the slave-pty's name)

     This is much like a bidirectional pipe, but allows signals &

     control chars to be passed through the connection.

     This is needed to execute a shell in a view.

     This is the higher level equivalent of OperatingSystem>>makePTYPair

     (which returns an array of file-descriptors)."

    |ptyPair master slave ptyName|

    "/ must protect from being unwound, otherwise the pipe-FD might not be registered for finalization

    [

        ptyPair := OperatingSystem makePTY.

        ptyPair notNil ifTrue:[

            master := self 

                        forFileDescriptor:(ptyPair at:1) mode:#readWrite

                        buffered:false handleType:nil.

            slave := self 

                        forFileDescriptor:(ptyPair at:2) mode:#readWrite

                        buffered:false handleType:nil.

            (ptyName := ptyPair at:3 ifAbsent:nil) notNil ifTrue:[

                master setCommandString:ptyName.

                slave setCommandString:ptyName.

            ].

            slave buffered:false.

            ptyPair at:1 put:master.

            ptyPair at:2 put:slave.

        ]

    ] valueUninterruptably.

    ^ ptyPair

    "

     UnixPTYStream makePTYPair.

     PipeStream makePTYPair.

    "

    "Modified: / 29-02-1996 / 18:28:36 / cg"

    "Modified (comment): / 27-02-2019 / 18:49:46 / Claus Gittinger"

!

makePipe

    "return an array with two streams - the first one for reading,

     the second for writing.

     This is the higher level equivalent of OperatingSystem>>makePipe

     (which returns an array of file-descriptors)."

    |pipeArray rs ws|

    "/ must protect from being unwound, otherwise the pipe-FD might not be registered for finalization

    [

        pipeArray := OperatingSystem makePipe.

        pipeArray isNil ifTrue:[

            "/ ok, maybe someone has forgotten to close a stream; enforce finalization and try again

            'makePipe: enforcing finalization to close any open streams' infoPrintCR.

            ObjectMemory garbageCollect; finalize.

            pipeArray := OperatingSystem makePipe.

            pipeArray isNil ifTrue:[

                |errorNumber errorHolder|

                errorNumber := OperatingSystem lastErrorNumber.

                errorHolder := errorNumber.

                OpenError newException

                    errorCode:errorNumber;

                    osErrorHolder:errorHolder;

                    raise.

            ].

        ].

        rs := PipeStream forFileDescriptor:(pipeArray at:1) mode:#readonly buffered:false handleType:#pipeFilePointer.

        ws := PipeStream forFileDescriptor:(pipeArray at:2) mode:#writeonly buffered:false handleType:#pipeFilePointer.

    ] valueUninterruptably.

    ^ Array with:rs with:ws

    "

     |pipe rs ws|

     pipe := NonPositionableExternalStream makePipe.

     rs := pipe at:1.

     ws := pipe at:2.

     'read ...'.

     [

         1 to:10 do:[:i |

             Transcript showCR:rs nextLine

         ].

         rs close.

     ] forkAt:7.

     'write ...'.

     [

         1 to:10 do:[:i |

             ws nextPutAll:'hello world '; nextPutAll:i printString; cr

         ].

         ws close.

     ] fork.

    "

    "Modified: / 29-02-1996 / 18:28:36 / cg"

    "Modified (format): / 04-11-2018 / 11:17:48 / Claus Gittinger"

! !

!NonPositionableExternalStream methodsFor:'accessing'!

buffered:aBoolean

    "do not allow to change to buffered mode - ignore true here"

    aBoolean ifFalse:[

        super buffered:false.

    ].

    ^ false

    "Modified: / 13-03-2019 / 19:33:55 / Stefan Vogel"

!

setCommandString:dummyString

    "dummy for PipeStream compatibility"

    "/ intentionally ignore here

    ^ self

    "Created: / 29-10-2018 / 18:06:44 / Claus Gittinger"

! !

!NonPositionableExternalStream methodsFor:'error handling'!

errorNotOpen

    "report an error, that the stream has not been opened or has been closed.

     Redefined to care for closed stdout and stderr,

     which happens, if the console is closed while I am running.

     In this case, we ignore the error."

    ((self == Stderr) or:[self == Stdout]) ifTrue:[

        ^ self

    ].

    ^ super errorNotOpen

!

positionError

    "{ Pragma: +optSpace }"

    "notify that this stream has no concept of a position"

    ^ PositionError raiseRequestWith:self

    "

     Stderr positionError

    "

!

writeError:errorNumber

    "report an error, that some write error occurred.

     Redefined to care for writeErrors on stdout and stderr,

     which happens under linux, if the console is closed while I am running.

     In this case, we ignore the error."

"/ No!! this causes nextPutAll: to loop forever, since there are always bytes remaining

"/

"/    ((self == Stderr) or:[self == Stdout]) ifTrue:[

"/        ^ self

"/    ].

    super writeError:errorNumber

    "Modified: / 09-02-2018 / 20:33:30 / stefan"

! !

!NonPositionableExternalStream methodsFor:'initialization'!

initialize

    "non-positionable streams do not work well when buffered"

    super initialize.

    position := nil.    "I am not positionable (reading and writing simultaneously)"

    buffered := false.

! !

!NonPositionableExternalStream methodsFor:'non homogenous reading'!

nextBytes:count into:anObject startingAt:start

    "read the next count bytes into an object and return the number of

     bytes read or the number of bytes read, if EOF is encountered before.

     An exception is raised if the connection is broken.

     Redefined here to avoid blocking of ST/X when waiting for io.

     Instead only the calling thread will block"

    |remaining offset nRead|

    count == 0 ifTrue:[ ^ 0 ].

    remaining := count.

    offset := start.

    [

        nRead := self nextAvailableBytes:remaining into:anObject startingAt:offset.

        nRead == 0 ifTrue:[

            "atEnd does a readWait"

            (self atEnd) ifTrue:[^ count - remaining]

        ] ifFalse:[

            remaining := remaining - nRead.

            (remaining == 0) ifTrue:[^ count].

            offset := offset + nRead.

        ]

    ] loop.

    "Modified (format): / 16-05-2017 / 12:10:25 / cg"

!

nextInt16MSB:msbFlag

    "redefined to wait for data on pipes and sockets"

    |bytes nRead|

    bytes := ByteArray uninitializedNew:2.

    nRead := self nextBytes:2 into:bytes startingAt:1.

    nRead ~~ 2 ifTrue:[

        ^ self pastEndRead.

    ].

    ^ bytes signedInt16At:1 MSB:msbFlag.

!

nextInt32MSB:msbFlag

    "redefined to wait for data on pipes and sockets"

    |bytes nRead|

    bytes := ByteArray uninitializedNew:4.

    nRead := self nextBytes:4 into:bytes startingAt:1.

    nRead ~~ 4 ifTrue:[

        ^ self pastEndRead.

    ].

    ^ bytes signedInt32At:1 MSB:msbFlag.

!

nextInt64MSB:msbFlag

    "redefined to wait for data on pipes and sockets"

    |bytes nRead|

    bytes := ByteArray uninitializedNew:8.

    nRead := self nextBytes:8 into:bytes startingAt:1.

    nRead ~~ 8 ifTrue:[

        ^ self pastEndRead.

    ].

    ^ bytes signedInt64At:1 MSB:msbFlag.

!

nextUnsignedInt16MSB:msbFlag

    "redefined to wait for data on pipes and sockets"

    |bytes nRead|

    bytes := ByteArray uninitializedNew:2.

    nRead := self nextBytes:2 into:bytes startingAt:1.

    nRead ~~ 2 ifTrue:[

        ^ self pastEndRead.

    ].

    ^ bytes unsignedInt16At:1 MSB:msbFlag.

!

nextUnsignedInt32MSB:msbFlag

    "redefined to wait for data on pipes and sockets"

    |bytes nRead|

    bytes := ByteArray uninitializedNew:4.

    nRead := self nextBytes:4 into:bytes startingAt:1.

    nRead ~~ 4 ifTrue:[

        ^ self pastEndRead.

    ].

    ^ bytes unsignedInt32At:1 MSB:msbFlag.

!

nextUnsignedInt64MSB:msbFlag

    "redefined to wait for data on pipes and sockets"

    |bytes nRead|

    bytes := ByteArray uninitializedNew:8.

    nRead := self nextBytes:8 into:bytes startingAt:1.

    nRead ~~ 8 ifTrue:[

        ^ self pastEndRead.

    ].

    ^ bytes unsignedInt64At:1 MSB:msbFlag.

! !

!NonPositionableExternalStream methodsFor:'positioning'!

position

    position isNil ifTrue:[

        ^ self positionError.

    ].

    ^ position

!

position:newPosition

    (position isNil or:[newPosition < position]) ifTrue:[

        "there is no turning back"

        ^ self positionError

    ].

    self skip:newPosition - position.

!

setToEnd

    "skip to the end of stream."