Make your own free website on
5.5. Persistent and Transient Streams

REXX knows two different types of streams: persistent and
transient. They differ conceptually in the way they can be
operated, which is dictated by the way they are stored.  But there
is no difference in the data you can read from or write to them
(i.e. both can used for character- or line-wise data), and both
are read and written using the same functions.

[Persistent streams]
     (often referred to just as “files”) are conceptually stored
     on permanent storage in the computer (e.g. a disk), as an
     array of characters. Random access to and repeated retrieval
     of any part of the stream are allowed for persistent streams.
     Typical example of persistent streams are normal operating
     system files.

[Transient streams]
     are typically not available for random access or repeated
     retrieval, either because it is not stored permanently, but
     read as a sequence of data that is generated on the fly; or
     because they are available from a sequential storage (e.g.
     magnetic tape) where random access is difficult or
     impossible. Typical examples of transient streams are devices
     like keyboards, printers, communication interfaces,
     pipelines, etc.

REXX does not allow any repositioning on transient streams; such
operations are not conceptually meaningful; a transient stream
must be treated sequentially. It is possible to treat a persistent
stream as a transient stream, but not vice versa. Thus, some
implementations may allow you to open a persistent stream as
transient. This may be useful for files to which you have only
append access, i.e. writes can only be performed at the end of
file. Whether you can open a stream in a particular mode, or
change the mode of a stream already open depends on your

Example: Determining stream type

Unfortunately, there is no standard way to determine whether a
given file is persistent or transient. You may try to reposition
for the file, and you can assume that the file is persistent if
the repositioning succeeded, like in the following code:

     streamtype: procedure
          signal on notready
          call linein arg(1), 1, 0
          return ‘persistent’          /* unless file is empty */
          return ‘transient’

Although the idea in this code is correct, there are unfortunately
a few problems. First, the NOTREADY condition can be raised by
other things than trying to reposition a transient stream; e.g. by
any repositioning of the current read position in an empty file,
if you have write access only, etc. Second, your implementation
may not have NOTREADY, or it may not use it for this situation.

The best method is to use a STREAM() function, if one is
available. Unfortunately, that is not very compatible, since no
standard stream commands are defined.