"

 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.

"

NonPositionableExternalStream subclass:#PipeStream

       classVariableNames:'PipeSignal'

       poolDictionaries:''

       category:'Streams-External'

!

PipeStream comment:'

COPYRIGHT (c) 1989 by Claus Gittinger

              All Rights Reserved

'!

%{

#include <stdio.h>

#include <errno.h>

#ifndef transputer

# include <sys/types.h>

# include <sys/stat.h>

#endif

%}

!PipeStream class methodsFor:'documentation'!

documentation

"

Pipestreams allow reading or writing from/to a unix command.

For example, to get a stream reading the output of an 'ls -l'

command, a PipeStream can be created with:

        PipeStream readingFrom:'ls -l'

the characters of the commands output can be read using the

standard stream messages as next, nextLine etc.

If a writing pipeStream is written to, after the command has finished,

UNIX will generate an error-signal (SIGPIPE), which will raise a

PipeSignal. Thus, to handle this condition correctly, the following

code is suggested:

        p := PipeStream writingTo:' ... '.

        PipeString pipeSignal handle:[:ex |

            ....

            any cleanup action

        ] do:[

            p nextPutLine:' ... '

        ]

"

! !

!PipeStream class methodsFor:'initialization'!

initialize

    "setup the signal"

    PipeSignal := (Signal new) mayProceed:true.

    PipeSignal notifierString:'write on a pipe with no one to read'.

! !

!PipeStream class methodsFor:'signal access'!

pipeSignal

    "return the signal used to handle SIGPIPE unix-signals"

    ^ PipeSignal

! !

!PipeStream class methodsFor:'instance creation'!

writingTo:commandString

    "create and return a new pipeStream which can write to the unix command

     given by command."

    ^ (self basicNew) writingTo:commandString

    "PipeStream writingTo:'sort'"

!

readingFrom:commandString

    "create and return a new pipeStream which can read from the unix command

     given by command."

    ^ (self basicNew) readingFrom:commandString

    "PipeStream readingFrom:'ls -l'"

! !

!PipeStream methodsFor:'instance release'!

closeFile

    "low level close - redefined since we close a pipe here"

%{  /* UNLIMITEDSTACK */

#ifndef transputer

    extern int _immediateInterrupt;

    int savInt;

    if (_INST(filePointer) != nil) {

        savInt = _immediateInterrupt;

        _immediateInterrupt = 1;

        pclose(MKFD(_INST(filePointer)));

        _immediateInterrupt = savInt;

    }

#endif

%}

! !

!PipeStream methodsFor:'private'!

    |retVal|

%{  /* STACK: 32000 */

#ifndef transputer

    {

        FILE *f;

        extern OBJ ErrorNumber;

        extern errno;

        extern int _immediateInterrupt;

            _immediateInterrupt = 1;

#ifdef LINUX

#else

                                  (char *) _stringVal(mode));

#endif

            _immediateInterrupt = savInt;

            if (f == NULL) {

                ErrorNumber = _MKSMALLINT(errno);

            } else {

                _INST(filePointer) = MKOBJ(f);

                retVal = self;

            }

        }

    }

#endif

%}

.

    retVal notNil ifTrue:[

        Lobby register:self

    ].

    ^ retVal

!

readingFrom:command

    "setup the receiver to read from command"

    self readonly.

    ^ self openPipeFor:command withMode:'r'

!

writingTo:command

    "setup the receiver to write to command"

    self writeonly.

    ^ self openPipeFor:command withMode:'w'

! !