streamProcs: REF StreamProcs, -- see below

streamData: REF ANY, -- data private to streamProcs

propList: Atom.PropList ← NIL, -- permits associating arbitrary information with stream. see StoreData, LookupData, and RemoveData below.  

backingStream: STREAM ← NIL -- for use with layered streams.

];

creates a new viewer with indicated name, and returns two streams "connected" to that viewer, one for input and one for output. The input stream is an edited stream. Note that ViewerIO.CreateViewerStreams...

stream gets chars from user's rope. If oldStream is non-NIL, it is reused rather than allocating space for a new stream.

stream puts chars into a rope which can be retrieved via GetOutputStreamRope, described below. Fine point...

stream gets chars from user's REF TEXT. If oldStream is non-NIL, it is reused rather than allocating space for a new stream.

stream puts characters into text. If oldH is non-NIL, it is reused rather than allocating space for a new stream.

creates a layered inputstream on top of in which buffers input characters and allows the user to perform character editing with ^A, ^W, ^Q. Typing a DEL will cause CreateEditedStream to raise IO.Signal[Rubout]. Default is to buffer to carriage return. Input characters are echoed to and erased from echoTo. ChangeDeliverWhen can be used to change buffering condition.

creates a layered stream, s, on top of stream, such that characters read from/printed to s will be read from/printed to stream, and also output to dribbleTo. If flushEveryNChars is > 0, will automatically call Flush on dribbleTo every nChars.

creates an output stream on top of stream such that characters are buffered until (a) the bufferSize is exceeded, or (b) deliverWhen[char] is TRUE, or (c) an explicit Flush is performed, at which point the characters are output to stream using PutBlock.

creates a input stream on top of stream such that any comments are filtered out, i.e. the characters comprising the comments are not returned by GetChar[s]. A comment consists of that sequence of characters beginning with -- and ending with -- or a CR. In the latter case, the CR is not considered to be part of the comment.

modifies `in' so that an attempt to read characters from `in' will cause the characters to be obtained from `from' until `from' runs dry, at which point `in' is returned to its previous state. Note that it is permissible to nest, i.e. concatenate, more than one stream in this fashion.

If appendToSource = TRUE then modification is done to the root stream, i.e. descends through non-NIL backingstreams. For example, if in is an edited stream, then this will cause characters to be inserted into buffer, from which they can be backspaced over, exactly as though they had been typed, rather than delivered to the client immediately. If in is a dribbleStream, then the characters will be dribbled etc.

output stream that simply discards its characters.

The basic output routine, handles any type via Values, defined later. Provides convenient default behaviour for simple output, i.e. outputs integers in decimal, cardinals in octal, time using both date and time, etc. Example: s.Put[int[x+y], rope[" is greater than "], int[x]] would produce '8 is greater than 5', for x = 5 and y = 3. For more control over the output...

Put only takes three value arguments...

produces output according to a collection of values and a format control string which can include embedded format codes. For example: s.PutF["%d is greater than %d", int[x+y], int[x]] is equivalent to the above call on Put. For more discussion, see section "PF Package".

format = NIL is equivalent to "%g%g%g..." which means to print each value the same as would be printed by Put.

Note that PutF is a slow procedure call, i.e. its arguments require more than 11 words on the stack.

PutF may raise signals. RESUME will always work and will either do

nothing or print "#####".

for outputting more than three quantities via a single call to Put.

= INLINE

{stream: STREAM ← CreateOutputStreamToRope[]; stream.PutF[format, v1, v2, v3, v4, v5]; r ← stream.GetOutputStreamRope[]; stream.Close[];

};

= INLINE {self.PutBlock[t]};

much more efficient than self.Put[text[t]];

much more efficient than self.Put[rope[r]];

depth and width control the cutoff for printing of the tv, verbose specifies whether to print additional information, e.g. the octal value for global frames, etc. stream.Put[tv[x]] is equivalent to stream.PutTV[x], and is the proper way to print tvs for most applications..

If verbose is FALSE, just the name of the type is printed. If verbose is TRUE, the undertype is also printed for named types. For example, if x is of type BreakProc, then stream.PutType[x, FALSE] prints: IO.BreakProc, whereas stream.PutType[x, TRUE] prints as: IO.BreakProc = PROC [c: CHAR] RETURNS [IO.BreakAction].

In addition, the range type is printed for undertypes that are refs or pointers. For example, if x is of type STREAM, stream.PutType[x, TRUE] prints as: IO.STREAM = REF IO.STREAMRecord; (and on the next line) IO.STREAMRecord: TYPE = RECORD [...];

stream.Put[type[x]] is equivalent to stream.PutType[type]

Prints the indicated signal on stream. If signalTV = NIL, prints the "current" signal, i.e. for use inside of a catch phrase.

= INLINE {RETURN[[atom[v]]]};

= INLINE {RETURN[[boolean[v]]]};

= INLINE {RETURN[[cardinal[v]]]};

= INLINE {RETURN[[character[v]]]};

= INLINE {RETURN[[integer[v]]]};

= INLINE {RETURN[[real[v]]]};

= INLINE {RETURN[[refAny[v]]]};

= INLINE {RETURN[[rope[v]]]};

= INLINE {RETURN[[string[v]]]};

= INLINE {RETURN[[text[v]]]};

= INLINE {RETURN[[time[v]]]}; -- i.e. time[] is the current time

= INLINE {RETURN[[tv[v]]]};

= INLINE {RETURN[[type[t]]]};

-- calls GetRefAny and narrows result.

returns TRUE if next token (see GetToken) is Y, YES, T, or TRUE (case doesn't matter), false if N, NO, F, or FALSE, otherwise raises Error[SyntaxError].

all effectively call Convert.Parse. For example, GetInt[RS[" -3.2"]] will return -3, GetReal[RS["2"]] will return 2.0, etc.

If the result returned by Convert.Parse is not of the specified type, GetCard, GetInt, GetReal raise Error[SyntaxError]. At some point in the future, GetInt etc. will be converted to use the compilers scanner, at which time it will be possible to notice and handle correctly the fact that - in "1-2" terminates the token, but that neither - in "-3-E27" terminates the token. For now, note that GetInt will do the correct thing for "-2" but not for "1-2", i.e. client must supply "1 -2" instead.

calls GetRefAny, constructing a list of the values returned, until an object is immediately followed by a CR...

-- NOT IMPLEMENTED YET

skips over characters for which break returns StopAndTossChar or StopAndPutBackChar, then reads until it gets a character for which break returns StopAndIncludeChar, StopAndTossChar, or StopAndPutBackChar. However, StopAndIncludeChar is treated the same as StopAndPutBackChar if any KeepGoing characters had been encountered, i.e. GetToken applied to " Foo [" will first return "Foo" and then return "["

uses standard mesa scanner to obtain next token.

Performs SkipOver[h, skipWhile], and then reads characters until break says to Stop or the end of the stream is reached, e.g. if break = skipWhile = IDBreak, skips over leading SP, CR, etc., then reads until it encounters an SP, CR, etc.

Same interpretetation of break and skipWhile as for GetRope. If text is supplied, and is big enough, characters will be stored into it, and it will be returned as the value, otherwise returns a new REF READONLY TEXT.

= INLINE {RETURN[GetRope[stream, CRBreak, NIL]]};

reads to CR and returns characters read as a rope.

skips over characters until it finds one for which skipWhile says to KeepGoing, or until it reaches the end of the stream, e.g. SkipOver[h, IDBreak] will skip until the start of the next id. If skipWhile = NIL, no characters are skipped.

adds an entry to property list, or replaces existing one.

like StoreData, except adds it to front of property list, even if something already there, i.e. so can use property list as a push down list.

returns first occurrence of key

removes first occurrence of key from property list

the general mechanism for implementing streams.

streamProcs is intended to be the result of a call to CreateRefStreamProcs (described below). CreateRefStreamProcs is responsible for inserting the appropriate default procedures for those operations not explicitly implemented by the stream. See discussion of default operations below.

backingStream is used when building a layered stream: those operations not defined in streamProcs will be automatically inherited from (passed down to) the backingStream.

If no backingStream is specified, the minimum required to implement a stream to be used for input is getChar and endOf. The minimum required to implement a stream to be used for output is putChar. Everything else can be defaulted...

getChar: PROC[self: STREAM] RETURNS[CHAR] ← NIL,

endOf: PROC[self: STREAM] RETURNS[BOOL] ← NIL,

charsAvail: PROC[self: STREAM] RETURNS[BOOL] ← NIL,

getBlock: PROC[self: STREAM, block: REF TEXT, startIndex: NAT, stopIndexPlusOne: NAT] RETURNS[nBytesRead: NAT] ← NIL,

unsafeGetBlock: UNSAFE PROC[self: STREAM, block: UnsafeBlock] RETURNS[nBytesRead: INT] ← NIL,

putChar: PROC[self: STREAM, char: CHAR] ← NIL,

putBlock: PROC[self: STREAM, block: REF READONLY TEXT, startIndex: NAT, stopIndexPlusOne: NAT] ← NIL,

unsafePutBlock: PROC[self: STREAM, block: UnsafeBlock] ← NIL,

flush: PROC[self: STREAM] ← NIL,

reset: PROC[self: STREAM] ← NIL,

close: PROC[self: STREAM, abort: BOOL ← FALSE] ← NIL,

getIndex: PROC[self: STREAM] RETURNS [INT] ← NIL,

setIndex: PROC[self: STREAM, index: INT] ← NIL,

getLength: PROC[self: STREAM] RETURNS [length: INT] ← NIL,

setLength: PROC[self: STREAM, length: INT] ← NIL,

backup: PROC[self: STREAM, char: CHAR] ← NIL,

userAbort: PROC[self: STREAM] RETURNS[abort: BOOL] ← NIL,

setUserAbort: PROC[self: STREAM] ← NIL,

resetUserAbort: PROC[self: STREAM] ← NIL,

setEcho: PROC[self: STREAM, echoTo: STREAM] RETURNS [oldEcho: STREAM] ← NIL,

eraseChar: PROC[self: STREAM, char: CHAR] ← NIL,

currentPosition: PROC[self: STREAM] RETURNS[position: INT] ← NIL,

name: Rope.ROPE ← NIL -- used for printing the stream itself as a ref any.

]

RETURNS [REF StreamProcs];

creates a REF streamprocs, supplying appropriate defaults for the NIL procedures Intended to be performed only once for each different stream class and the result saved, i.e. all instances of this stream can share the same streamProcs.

AmbushProcsStream: PRIVATE PROCEDURE[self: STREAM, streamProcs: REF StreamProcs, streamData: REF ANY, reusing: STREAM ← NIL] ;

UnAmbushProcsStream: PRIVATE PROCEDURE[self: STREAM];

used to supply the implementation of an operation other than those specified as arguments to CreateRefStreamProcs. 'operation' is the generic procedure, and Via is the implementing procedure for this stream class. Via is checked (using the RT interfaces) to make sure it is of the correct type. (The names of the arguments as well as the return values must agree.) If it is not, the signal IO.Error[ProcedureHasWrongType] is raised. If the type is correct, Via is saved on the property list of the streamProcs, so that the type checking need be done only once for each stream class. Subsequent calls to Implements for the same stream class are essentially nops.

When the `operation' is invoked, `via' will be called with the same arguments as the generic procedure was called with.

used by implements. Calling directly and specifying procRef and key enables avoiding use of RT interfaces

Used to define a procedure to be called for printing an object of the specified ref type. The procedure will be called with the corresponding ref and a stream. If the class of refType is not ref or list, raises IO.Signal[NotARefType].

More general print proc mechanism for use with any type. The procedure will be called with a tv for the corresponding object and a stream. IF canHandleRemote is TRUE, the printproc will also be invoked on remote tvs, otherwise not.

attempt to do a getChar at end of stream, or attempt to do a setindex beyond end of stream. Separate error for convenience.

NotImplementedForThisStream,

IllegalBackup,

SyntaxError,

StreamClosed,

FileTooLong,

BadIndex

};

NotImplementedForThisStream,

ProcedureHasWrongType,

NotARefType,

EmptyBuffer,

UnmatchedLeftParen, UnmatchedStringDelim,

Rubout,

UnprintableValue, TypeMismatch, UnknownFormat

};

used by text streams, should return a bigger one, with characters copied over, or else can return same text with length reset after having done something with chartacters.

null, atom, boolean, character, cardinal, integer, proc, real, refAny, rope,

string, text, time, tv, type};

null => NULL,

atom => [value: ATOM],

boolean => [value: BOOL],

character => [value: CHAR],

cardinal => [value: LONG CARDINAL],

integer => [value: INT],

real => [value: REAL],

refAny => [value: REF READONLY ANY],

rope => [value: ROPE],

string => [value: LONG STRING],

text => [value: REF READONLY TEXT],

time => [value: GreenwichMeanTime],

tv => [value: RTBasic.TV],

type => [value: RTBasic.Type],

ENDCASE];

base: LONG POINTER, startIndex, stopIndexPlusOne: INT --bytes--];

getChar: PROC[self: STREAM] RETURNS[CHAR] ← NIL,

endOf: PROC[self: STREAM] RETURNS[BOOL] ← NIL,

charsAvail: PROC[self: STREAM] RETURNS[BOOL] ← NIL,

getBlock: PROC[self: STREAM, block: REF TEXT, startIndex: NAT, stopIndexPlusOne: NAT] RETURNS[nBytesRead: NAT] ← NIL,

unsafeGetBlock: UNSAFE PROC[self: STREAM, block: UnsafeBlock] RETURNS[nBytesRead: INT] ← NIL,

putChar: PROC[self: STREAM, char: CHAR] ← NIL,

putBlock: PROC[self: STREAM, block: REF READONLY TEXT, startIndex: NAT, stopIndexPlusOne: NAT] ← NIL,

unsafePutBlock: PROC[self: STREAM, block: UnsafeBlock] ← NIL,

flush: PROC[self: STREAM] ← NIL,

reset: PROC[self: STREAM] ← NIL,

close: PROC[self: STREAM, abort: BOOL ← FALSE] ← NIL,

getIndex: PROC[self: STREAM] RETURNS [INT] ← NIL,

setIndex: PROC[self: STREAM, index: INT] ← NIL,

otherStreamProcs: LIST OF StreamProperty ← NIL, -- used for specifying the implementation of optional, generic procedures. See Implements below.

name: Rope.ROPE

];

interpreters \ conventions, e.g. maps \n to CR, \t to TAB, etc. Raises SyntaxError if \ not followed by acceptable character. IF char is in ['0..9], then stream must be supplied, or else syntaxerror. If stream is supplied, two more characters are read. If these are digits, returns corresponding character, otherwise, raises SyntaxError.