"
 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.
"

UnboundedExternalStream subclass:#NonPositionableExternalStream
	 instanceVariableNames:''
	 classVariableNames:'StdInStream StdOutStream StdErrorStream'
	 poolDictionaries:''
	 category:'Streams-External'
!

!NonPositionableExternalStream primitiveDefinitions!
%{
#include <stdio.h>
#define _STDIO_H_INCLUDED_
%}

! !

!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
    dont 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.
"
!

version
    ^ '$Header: /cvs/stx/stx/libbasic/NonPositionableExternalStream.st,v 1.25 1996-01-11 20:38:26 cg Exp $'
! !

!NonPositionableExternalStream class methodsFor:'instance creation'!

forStderr
    "return a NonPositionableExternalStream object for writing to
     Unixes standard error output file descriptor"

    StdErrorStream isNil ifTrue:[
	StdErrorStream := self basicNew initializeForStderr
    ].
    ^ StdErrorStream
!

forStdin
    "return a NonPositionableExternalStream object for reading from
     Unixes standard input file descriptor"

    StdInStream isNil ifTrue:[
	StdInStream := self basicNew initializeForStdin
    ].
    ^ StdInStream
!

forStdout
    "return a NonPositionableExternalStream object for writing to
     Unixes standard output file descriptor"

    StdOutStream isNil ifTrue:[
	StdOutStream := self basicNew initializeForStdout
    ].
    ^ StdOutStream
! !

!NonPositionableExternalStream methodsFor:'error handling'!

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

    ^ PositionErrorSignal raiseRequestWith:self in:thisContext sender
! !

!NonPositionableExternalStream methodsFor:'positioning'!

position
    "catch position - there is none here"

    ^ self positionError
!

position:aPosition
    "catch position - there is none here"

    ^ self positionError
!

skip:numberToSkip
    "skip count objects, return the receiver"

    "dont know how to unread ..."
    numberToSkip < 0 ifTrue:[
	^ self error:'stream is not positionable'
    ].
    numberToSkip timesRepeat:self next
! !

!NonPositionableExternalStream methodsFor:'printing & storing'!

printOn:aStream
    "append a printed representation of the receiver on aStream"

    self == Stdin ifTrue:[
	aStream nextPutAll:'Stdin'.
	^ self
    ].
    self == Stdout ifTrue:[
	aStream nextPutAll:'Stdout'.
	^ self
    ].
    self == Stderr ifTrue:[
	aStream nextPutAll:'Stderr'.
	^ self
    ].
    super printOn:aStream
!

storeOn:aStream
    "append a printed representation of the receiver on aStream, from
     which the receiver can be reconstructed."

    ((self == Stdin)
    or:[self == Stdout
    or:[self == Stderr]]) ifTrue:[
	^ self printOn:aStream
    ].
    super storeOn:aStream
! !

!NonPositionableExternalStream methodsFor:'private'!

initializeForStderr
    "setup for writing to stderr"

    mode := #readwrite.
    buffered := false.
%{
    OBJ fp;

    _INST(filePointer) = fp = __MKOBJ(stderr); __STORE(self, fp);
%}
!

initializeForStdin
    "setup for reading stdin"

    mode := #readonly.
    buffered := true.
%{
    OBJ fp;

    _INST(filePointer) = fp = __MKOBJ(stdin); __STORE(self, fp);
%}
!

initializeForStdout
    "setup for writing to stdout"

    mode := #readwrite.
    buffered := false.
%{
    OBJ fp;

    _INST(filePointer) = fp = __MKOBJ(stdout); __STORE(self, fp);
%}
!

reOpen
    "reopen the stream after an image restart.
     If I am one of the standard streams, reopen is easy"

    (self == StdInStream) ifTrue:[
	^ self initializeForStdin
    ].
    (self == StdOutStream) ifTrue:[
	^ self initializeForStdout
    ].
    (self == StdErrorStream) ifTrue:[
	^ self initializeForStderr
    ].
    ^ super reOpen
! !

!NonPositionableExternalStream methodsFor:'queries'!

isPositionable
    "return true, if the stream supports positioning (this one is not)"

    ^ false
! !