DIRECTORY
IO,
IOUtils,
RefText,
Rope USING [Concat, Fetch, FromRefText, InlineFetch, InlineLength, Length, ROPE];


IOSimpleStreamsImpl: CEDAR PROGRAM 
IMPORTS IO, IOUtils, RefText, Rope
EXPORTS IO
= BEGIN
STREAM: TYPE = IO.STREAM;
ROPE: TYPE = Rope.ROPE;
StreamProcs: TYPE = IO.StreamProcs;
noWhereStream: PUBLIC STREAM _ IO.CreateStream[IO.CreateStreamProcs[
variety: $output, class: $Null, putChar: NoWherePutChar, close: NoWhereClose], NIL];
NoWherePutChar: PROC [self: STREAM, char: CHAR] = {};
NoWhereClose: PROC [self: STREAM, abort: BOOL] = {};
noInputStream: PUBLIC STREAM _ IO.CreateStream[
streamProcs: IO.CreateStreamProcs[
variety: $input, class: $Null,
getChar: NoInputGetChar,
endOf: NoInputEndOf,
backup: NoInputBackup,
close: NoInputClose],
streamData: NIL];
NoInputGetChar: PROC [self: STREAM] RETURNS [CHAR] = {
ERROR IO.EndOfStream[self] };
NoInputBackup: PROC [self: STREAM, char: CHAR] = {
ERROR IO.Error[$IllegalBackup, self] };
NoInputEndOf: PROC [self: STREAM] RETURNS [BOOL] = {
RETURN[TRUE] };
NoInputClose: PROC [self: STREAM, abort: BOOL] = { };
InputRopeStreamData: TYPE = REF InputRopeStreamRecord; 
InputRopeStreamRecord: TYPE = RECORD [
rope: ROPE,
length: INT,
index: INT
];

InputRopeStreamProcs: REF StreamProcs = IO.CreateStreamProcs[
variety: $input, class: $ROPE,
getChar: InputRopeStreamGetChar,
endOf: InputRopeStreamEndOf,
reset: InputRopeStreamReset,
getIndex: InputRopeStreamGetIndex,
setIndex: InputRopeStreamSetIndex,
getLength: InputRopeStreamGetLength,
backup: InputRopeStreamBackup
];
RIS: PUBLIC PROC [rope: ROPE, oldStream: STREAM]
RETURNS [stream: STREAM] = {
IF oldStream = NIL THEN GOTO newStream;
WITH oldStream.streamData SELECT FROM
data: InputRopeStreamData => {
data^ _ [rope: rope, length: rope.InlineLength[], index: 0];
oldStream.streamProcs _ InputRopeStreamProcs;
RETURN[oldStream] };
ENDCASE => GOTO newStream;
EXITS newStream => RETURN[IO.CreateStream[
InputRopeStreamProcs, NEW[InputRopeStreamRecord _ [
rope: rope, length: rope.Length[], index: 0]]]];
};
InputRopeStreamGetChar: PROC [self: STREAM] RETURNS [char: CHAR] = {
data: InputRopeStreamData = NARROW[self.streamData];
IF data.index >= data.length THEN ERROR IO.EndOfStream[self];
char _ data.rope.InlineFetch[data.index];
data.index _ data.index + 1;
};
InputRopeStreamEndOf: PROC [self: STREAM] RETURNS [BOOL] = {
data: InputRopeStreamData = NARROW[self.streamData];
RETURN[data.index >= data.length];
};
InputRopeStreamBackup: PROC [self: STREAM, char: CHAR] = {
data: InputRopeStreamData = NARROW[self.streamData];
IF data.index = 0 OR data.rope.Fetch[data.index-1] # char THEN
ERROR IO.Error[$IllegalBackup, self];
data.index _ data.index - 1;
};
InputRopeStreamReset: PROC [self: STREAM] = {
data: InputRopeStreamData = NARROW[self.streamData];
data.index _ data.length;
};
InputRopeStreamGetIndex: PROC [self: STREAM] RETURNS [INT] = {
data: InputRopeStreamData = NARROW[self.streamData];
RETURN[data.index];
};
InputRopeStreamSetIndex: PROC [self: STREAM, index: INT] = {
data: InputRopeStreamData = NARROW[self.streamData];
IF index NOT IN [0 .. data.length] THEN ERROR IO.Error[$BadIndex, self];
data.index _ index;
};
InputRopeStreamGetLength: PROC [self: STREAM] RETURNS [length: INT] = {
data: InputRopeStreamData = NARROW[self.streamData];
RETURN[data.length];
};
OutputRopeStreamData: TYPE = REF OutputRopeStreamRecord;
OutputRopeStreamRecord: TYPE = RECORD [
rope: ROPE,
text: REF TEXT
];
OutputRopeStreamProcs: REF StreamProcs = IO.CreateStreamProcs[
variety: $output, class: $ROPE,
putChar: OutputRopeStreamPutChar,
eraseChar: OutputRopeStreamEraseChar,
reset: OutputRopeStreamReset,
getLength: OutputRopeStreamGetLength,
getIndex: OutputRopeStreamGetIndex,
close: OutputRopeStreamClose
];
ROS: PUBLIC PROC [oldStream: STREAM]
RETURNS [stream: STREAM] = {
IF oldStream = NIL THEN GOTO newStream;
WITH oldStream.streamData SELECT FROM
data: OutputRopeStreamData => {
data.rope _ NIL;
IF data.text = NIL THEN data.text _ RefText.ObtainScratch[100]
ELSE data.text.length _ 0;
oldStream.streamProcs _ OutputRopeStreamProcs;
RETURN[oldStream] };
ENDCASE => GOTO newStream;
EXITS newStream => RETURN[IO.CreateStream[
OutputRopeStreamProcs, NEW[OutputRopeStreamRecord _ [
rope: NIL, text: RefText.ObtainScratch[100]]]]];
};
OutputRopeStreamPutChar: PROC [self: STREAM, char: CHAR] = {
data: OutputRopeStreamData = NARROW[self.streamData];
text: REF TEXT = data.text;
IF text.length = text.maxLength THEN {
data.rope _ data.rope.Concat[Rope.FromRefText[text]];
text.length _ 0 };
text[text.length] _ char;
text.length _ text.length + 1;
};
OutputRopeStreamEraseChar: PROC [self: STREAM, char: CHAR] = {
data: OutputRopeStreamData = NARROW[self.streamData];
IF data.text.length # 0 THEN data.text.length _ data.text.length-1;
};
OutputRopeStreamReset: PROC [self: STREAM] = {
data: OutputRopeStreamData = NARROW[self.streamData];
data.rope _ NIL;
data.text.length _ 0;
};
OutputRopeStreamGetLength: PROC [self: STREAM] RETURNS [length: INT] = {
data: OutputRopeStreamData = NARROW[self.streamData];
RETURN[data.text.length + data.rope.Length[]];
};
OutputRopeStreamGetIndex: PROC [self: STREAM] RETURNS [index: INT] = {
RETURN[self.GetLength[]];
};
debugRopeFromROS: BOOL _ TRUE; -- crock until important clients get fixed
RopeFromROS: PUBLIC PROC [self: STREAM, close: BOOL] RETURNS [ROPE] = {
data: OutputRopeStreamData = NARROW[self.streamData];
result: ROPE _ IF data.text.length = 0 AND debugRopeFromROS THEN NIL
ELSE Rope.FromRefText[data.text];
IF close THEN {
RefText.ReleaseScratch[data.text];
data.text _ NIL;
self.streamProcs _ IOUtils.closedStreamProcs;
IF data.rope # NIL THEN { result _ data.rope.Concat[result];  data.rope _ NIL }
}
ELSE {
data.text.length _ 0;
result _ data.rope _ data.rope.Concat[result];
};
RETURN[result];
};
OutputRopeStreamClose: PROC [self: STREAM, abort: BOOL] = {
data: OutputRopeStreamData = NARROW[self.streamData];
data.rope _ NIL;
RefText.ReleaseScratch[data.text];
data.text _ NIL;
self.streamProcs _ IOUtils.closedStreamProcs;
};
InputTextStreamData: TYPE = REF InputTextStreamRecord; 
InputTextStreamRecord: TYPE = RECORD [
text: REF READONLY TEXT,
index: NAT
];

InputTextStreamProcs: REF StreamProcs = IO.CreateStreamProcs[
variety: $input, class: $TEXT,
getChar: InputTextStreamGetChar,
endOf: InputTextStreamEndOf,
reset: InputTextStreamReset,
getIndex: InputTextStreamGetIndex,
setIndex: InputTextStreamSetIndex,
getLength: InputTextStreamGetLength,
backup: InputTextStreamBackup
];

TIS: PUBLIC PROC [text: REF READONLY TEXT, oldStream: STREAM]
RETURNS [STREAM] = {
IF oldStream = NIL THEN GOTO newStream;
WITH oldStream.streamData SELECT FROM
data: InputTextStreamData => {
data^ _ [text: text, index: 0];
oldStream.streamProcs _ InputTextStreamProcs;
RETURN[oldStream] };
ENDCASE => GOTO newStream;
EXITS newStream => RETURN[IO.CreateStream[
InputTextStreamProcs, NEW[InputTextStreamRecord _ [
text: text, index: 0]]]];
};

InputTextStreamGetChar: PROC [self: STREAM] RETURNS [char: CHAR] = {
data: InputTextStreamData = NARROW[self.streamData];
IF data.index >= data.text.length THEN ERROR IO.EndOfStream[self];
char _ data.text[data.index];
data.index _ data.index + 1;
};

InputTextStreamEndOf: PROC [self: STREAM] RETURNS [BOOL] = {
data: InputTextStreamData = NARROW[self.streamData];
RETURN[data.index >= data.text.length];
};
InputTextStreamBackup: PROC [self: STREAM, char: CHAR] = {
data: InputTextStreamData = NARROW[self.streamData];
IF data.index = 0 OR data.text[data.index-1] # char THEN
ERROR IO.Error[$IllegalBackup, self];
data.index _ data.index - 1;
};

InputTextStreamReset: PROC [self: STREAM] = {
data: InputTextStreamData = NARROW[self.streamData];
data.index _ data.text.length;
};

InputTextStreamGetIndex: PROC [self: STREAM] RETURNS [INT] = {
data: InputTextStreamData = NARROW[self.streamData];
RETURN[data.index];
};

InputTextStreamSetIndex: PROC [self: STREAM, index: INT] = {
data: InputTextStreamData = NARROW[self.streamData];
IF index NOT IN [0 .. data.text.length] THEN ERROR IO.Error[$BadIndex, self];
data.index _ index;
};

InputTextStreamGetLength: PROC [self: STREAM] RETURNS [length: INT] = {
data: InputTextStreamData = NARROW[self.streamData];
RETURN[data.text.length];
};

OutputTextStreamProcs: REF StreamProcs = IO.CreateStreamProcs[
variety: $output, class: $TEXT,
putChar: OutputTextStreamPutChar,
eraseChar: OutputTextStreamEraseChar,
reset: OutputTextStreamReset,
getLength: OutputTextStreamGetLength,
getIndex: OutputTextStreamGetIndex,
close: NIL
];

TOS: PUBLIC PROC [text: REF TEXT, oldStream: STREAM]
RETURNS [stream: STREAM] = {
IF oldStream = NIL THEN oldStream _ IO.CreateStream[OutputTextStreamProcs, NIL]
ELSE {
oldStream.streamProcs _ OutputTextStreamProcs;
WITH oldStream.streamData SELECT FROM
oldText: REF TEXT => IF text = NIL THEN text _ oldText;
ENDCASE;
};
IF text = NIL THEN text _ NEW[TEXT[100]];
text.length _ 0;
oldStream.streamData _ text;
RETURN[oldStream];
};
OutputTextStreamPutChar: PROC [self: STREAM, char: CHAR] = {
self.streamData _ RefText.InlineAppendChar[to: NARROW[self.streamData], from: char];
};
OutputTextStreamEraseChar: PROC [self: STREAM, char: CHAR] = {
text: REF TEXT = NARROW[self.streamData];
IF text.length > 0 THEN text.length _ text.length - 1;
};
OutputTextStreamReset: PROC [self: STREAM] = {
NARROW[self.streamData, REF TEXT].length _ 0;
};
OutputTextStreamGetLength: PROC [self: STREAM] RETURNS [length: INT] = {
RETURN[NARROW[self.streamData, REF TEXT].length];
};
OutputTextStreamGetIndex: PROC [self: STREAM] RETURNS [index: INT] = {
RETURN[NARROW[self.streamData, REF TEXT].length];
};

END.
ΨIOSimpleStreamsImpl.mesa
Last Edited by
MBrown on October 25, 1983 1:24 pm

TO DO
Input Rope Stream should use RopeReader package (via overlaid binding of RIS?)
remove "debugRopeFromROS" flag when no longer needed
Nowhere Stream 
NoInput Stream 
Input Stream from ROPE (RIS)
Output Stream to ROPE (ROS)
Input Stream from REF TEXT (TIS)
Output Stream to REF TEXT (TOS)
Change Log
Changed by MBrown on October 25, 1983 1:24 pm
Fixed output rope stream and output text stream to implement EraseChar.  Streams are prepared for Close to replace the stream procs with IOUtils.closedStreamProcs.  RopeFromROS is somewhat more efficient in the normal case.  RopeFromROS returns NIL when possible (work around bug in interpreter).
Κ
a–

"Cedar" style˜Jš
Οc™š
œ™Jšœ™"—J™™J™NJ™4—J˜š
Οk	˜	Jšžœ
˜Jš
œ˜Jš
œ˜JšœžœAžœ˜QJ˜—J˜šΠblœžœ
žœ
˜#Jšžœ
žœ˜"Jšžœ
ž˜
Jšœž˜Jšžœžœžœ
žœ
˜Jšžœžœžœ
˜Jšœ
žœžœ
˜#—
head™š	œžœ
žœžœžœ˜DJšœOžœ˜T—JšΟnœžœžœžœ˜5Jš œžœžœ	žœ˜4—™šœžœ
žœ˜/š
œ"˜"Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜—Jšœžœ˜—š
 œžœžœžœ
žœ˜6Jšžœ
žœ˜—š 
œžœžœžœ˜2Jšžœ
žœ˜'—š
 œžœžœžœ
žœ˜4Jšžœ
žœ˜—Jš œžœžœ	žœ˜5—šœžœ™Jšœžœžœ˜7šœžœžœ
˜&Jšœžœ
˜Jšœžœ
˜Jšœž˜
J˜—J˜šœžœ$˜=Jš
œ˜Jš
œ ˜ J˜J˜J˜"J˜"J˜$Jš
œ˜J˜—
unitš
Πknœžœ
žœžœ
žœ
˜0Jšžœ
žœ˜Jšžœ
žœ
žœ
žœ˜'šžœžœ
ž˜%š
œ˜Jš
œ<˜<Jš
œ-˜-Jšžœ˜—Jšžœžœ˜—šžœžœ
žœ˜*šœžœ˜3Jš
œ0˜0——Jš
œ˜—š
 œžœžœžœžœ˜DJšœžœ˜4Jšžœžœ
žœ˜=J˜)J˜Jš
œ˜—š
 œžœžœžœžœ˜<Jšœžœ˜4Jšžœ˜"Jš
œ˜—š œžœžœžœ˜:Jšœžœ˜4šžœžœ&ž˜>Jšžœ
žœ˜%—J˜Jš
œ˜—š œžœžœ˜-Jšœžœ˜4Jš
œ˜Jš
œ˜—š
 œžœžœžœ
žœ˜>Jšœžœ˜4Jšžœ
˜Jš
œ˜—š œžœžœ	žœ˜<Jšœžœ˜4Jšžœžœ
žœžœ
žœ
žœ˜HJ˜Jš
œ˜—š
 œžœžœžœ	žœ˜GJšœžœ˜4Jšžœ˜Jš
œ˜——šœžœ™Lšœžœžœ˜8šœžœžœ
˜'Jšœžœ
˜Jšœžœ
ž˜Jš
œ˜—šœžœ$˜>Jš
œ˜J˜!J˜%J˜J˜%J˜#Jš
œ˜J˜—š‘œžœ
žœ
žœ
˜$Jšžœ
žœ˜Jšžœ
žœ
žœ
žœ˜'šžœžœ
ž˜%š
œ˜Jšœžœ
˜Jšžœ
žœ
žœ'˜>Jšžœ˜Jš
œ.˜.Jšžœ˜—Jšžœžœ˜—šžœžœ
žœ˜*šœžœ˜5Jšœžœ'˜0——Jš
œ˜—š œžœžœžœ˜<Jšœžœ˜5Jšœžœ
žœ
˜šžœžœ˜&Jš
œ5˜5Jš
œ˜—J˜J˜Jš
œ˜—š œžœžœžœ˜>Jšœžœ˜5Jšžœžœ'˜CJš
œ˜—š œžœžœ˜.Jšœžœ˜5Jšœžœ
˜J˜Jš
œ˜—š
 œžœžœžœ
žœ˜HJšœžœ˜5Jšžœ(˜.Jš
œ˜—š
 œžœžœžœ	žœ˜FJšžœ˜Jš
œ˜—Lšœžœžœ*˜Iš œžœ
žœžœ	žœžœžœ˜GJšœžœ˜5š
œžœžœžœžœ
ž˜DJšžœ˜!—šžœžœ˜Jš
œ"˜"Jšœžœ
˜Jš
œ-˜-Jšžœ
žœ
žœ3žœ˜OJ˜
—šžœ˜Jš
œ˜Jš
œ.˜.J˜—Jšžœ	˜Jš
œ˜—š œžœžœ	žœ˜;Jšœžœ˜5Jšœžœ
˜Jš
œ"˜"Jšœžœ
˜Jš
œ-˜-Jš
œ˜——šœžœ™ Jšœžœžœ˜7šœžœžœ
˜&Jšœžœ
žœ
žœ
˜Jšœž˜
Jš
œ˜—J˜šœžœ$˜=Jš
œ˜J˜ J˜J˜J˜"J˜"J˜$Jš
œ˜Jš
œ˜—J˜š‘œžœ
žœžœ
žœ
žœ
žœ
˜=Jšžœžœ˜Jšžœ
žœ
žœ
žœ˜'šžœžœ
ž˜%š
œ˜Jš
œ˜Jš
œ-˜-Jšžœ˜—Jšžœžœ˜—šžœžœ
žœ˜*šœžœ˜3Jš
œ˜——Jš
œ˜—J˜š
 œžœžœžœžœ˜DJšœžœ˜4Jšžœ žœ
žœ˜BJ˜J˜Jš
œ˜—J˜š
 œžœžœžœžœ˜<Jšœžœ˜4Jšžœ!˜'Jš
œ˜—š œžœžœžœ˜:Jšœžœ˜4šžœžœ ž˜8Jšžœ
žœ˜%—J˜Jš
œ˜—J˜š œžœžœ˜-Jšœžœ˜4Jš
œ˜Jš
œ˜J˜—š
 œžœžœžœ
žœ˜>Jšœžœ˜4Jšžœ
˜Jš
œ˜J˜—š œžœžœ	žœ˜<Jšœžœ˜4Jšžœžœ
žœžœ
žœ
žœ˜MJ˜Jš
œ˜J˜—š
 œžœžœžœ	žœ˜GJšœžœ˜4Jšžœ˜Jš
œ˜—J˜—šœžœ™šœžœ$˜>Jš
œ˜J˜!J˜%J˜J˜%J˜#Jšœž˜
Jš
œ˜—J˜š œžœ
žœžœ
žœ
žœ
˜4Jšžœ
žœ˜Jš
žœ
žœ
žœ
žœ%žœ
˜Ošžœ˜Jš
œ.˜.šžœžœ
ž˜%Jšœ	žœ
žœžœžœ
žœ˜7Jšžœ
˜—J˜—Jš
žœžœ
žœžœ
žœ˜)Jš
œ˜Jš
œ˜Jšžœ˜Jš
œ˜—š œžœžœžœ˜<Jšœ/žœ˜TJš
œ˜—š œžœžœžœ˜>Jšœžœ
žœžœ˜)Jšžœžœ˜6Jš
œ˜—š œžœžœ˜.Jšžœžœ
žœ
˜-Jš
œ˜—š
 œžœžœžœ	žœ˜HJšžœ
žœžœ
žœ
˜1Jš
œ˜—š
 œžœžœžœžœ˜FJšžœ
žœžœ
žœ
˜1Jš
œ˜——J˜Jšžœ
˜
head1š

™

body™-Nš
¨™¨———…—%z5³