DIRECTORY
Ascii USING [Lower], 
Atom USING [MakeAtom, MakeAtomFromRefText], 
BasicTime USING [GMT], 
FileOps USING [comment, endNode, endOfFile, IntBytes, LengthByte, look1, look2, look3, looks, looksFirst, LooksIndex, looksLast, Op, otherNode, otherNodeShort, otherNodeSpecs, otherNodeSpecsShort, prop, PropIndex, propShort, rope, runs, startNode, startNodeFirst, startNodeLast, terminalTextNode, terminalTextNodeFirst, terminalTextNodeLast, ThirdByte, FormatIndex], 
FileReader USING [FromRope, FromStream, InterDoc, Open, OpenC], 
FS USING [ComponentPositions, ExpandName, GetName, OpenFile, Position], 
InterFile USING [FromRope], 
IO USING [STREAM], 
NodeProps USING [DoSpecs, PutProp], 
PGSupport USING [BadIndex, CreatePGF, EnterLooks, EnterProp, EnterFormatName, FreePGF, PGF, RetrieveLooks, RetrieveProp, RetrieveFormatName], 
PutGet USING [], 
Rope USING [MaxLen, ROPE, Substr, Translate], 
RopeEdit USING [MaxLen, Substr], 
RopeReader USING [Backwards, BumpIndex, Get, GetRope, Position, ReadOffEnd, Ref, SetIndex], 
RuntimeError USING [UNCAUGHT],
SafeStorage USING [SetCollectionInterval], 
TextEdit USING [], 
TextLooks USING [BaseRuns, Concat, Looks, LooksBytes, Runs], 
TextLooksSupport USING [NewBase, Short], 
TextNode USING [Body, MaxLen, Ref, RefTextNode];

GetFileImpl: CEDAR MONITOR
IMPORTS Ascii, Atom, FileReader, FS, InterFile, NodeProps, PGSupport, Rope, RopeEdit, RopeReader, RuntimeError, SafeStorage, TextLooks, TextLooksSupport
EXPORTS PutGet
SHARES TextLooks
= BEGIN OPEN FileOps;

ROPE: TYPE = Rope.ROPE;
Byte: TYPE = [0..255];
FromFileError: PUBLIC ERROR = CODE;
FromFile: PUBLIC PROC [fileName: ROPE, start: INT _ 0, len: INT _ TextNode.MaxLen] RETURNS [root: TextNode.Ref] = {
control, comment, stext: RopeReader.Ref;
interdoc: ROPE;
tiogaFile: BOOL;
fh: FS.OpenFile;
createDate: BasicTime.GMT;
StartRead[];
{ ENABLE UNWIND => EndRead[];
[control, comment, stext, tiogaFile, fh, createDate] _
FileReader.Open[fileName, start, len !
FileReader.InterDoc => { interdoc _ doc; RESUME }];
root _ IF interdoc#NIL THEN InterFile.FromRope[interdoc]
ELSE Finish[control, comment, stext, tiogaFile];
};
AddFileExtension[root, fh];
AddCreateDate[root, createDate];
EndRead[];
};

FromFileC: PUBLIC PROC [file: FS.OpenFile, start: INT _ 0, len: INT _ TextNode.MaxLen]
RETURNS [root: TextNode.Ref] = {
control, comment, stext: RopeReader.Ref;
interdoc: ROPE;
tiogaFile: BOOL;
createDate: BasicTime.GMT;
StartRead[];
{ ENABLE UNWIND => EndRead[];
[control, comment, stext, tiogaFile, createDate] _ FileReader.OpenC[file, start, len !
FileReader.InterDoc => { interdoc _ doc; RESUME }];
root _ IF interdoc#NIL THEN InterFile.FromRope[interdoc]
ELSE Finish[control, comment, stext, tiogaFile];
};
AddFileExtension[root, file];
AddCreateDate[root, createDate];
EndRead[];
};

AddFileExtension: PROC [root: TextNode.Ref, file: FS.OpenFile] = {
ForceLower: PROC [r: ROPE] RETURNS [ROPE] = {
ForceCharLower: PROC [old: CHAR] RETURNS [new: CHAR] = {
RETURN [Ascii.Lower[old]];
};
RETURN [Rope.Translate[base: r, translator: ForceCharLower]];
};
name: ROPE; cp: FS.ComponentPositions;
[fullFName: name, cp: cp] _ FS.ExpandName[name: FS.GetName[file].fullFName];
NodeProps.PutProp[root, $FileExtension, IF cp.ext.length=0 THEN $null
ELSE Atom.MakeAtom[ForceLower[name.Substr[cp.ext.start, cp.ext.length]]]];
};

AddCreateDate: PROC [root: TextNode.Ref, createDate: BasicTime.GMT] = {
NodeProps.PutProp[root, $FileCreateDate, 
NEW[BasicTime.GMT _ createDate]];
};

FromRope: PUBLIC PROC
[rope: ROPE, start: INT _ 0, len: INT _ TextNode.MaxLen] RETURNS [root: TextNode.Ref] = {
control, comment, stext: RopeReader.Ref;
interdoc: ROPE;
tiogaFile: BOOL;
StartRead[];
{ ENABLE UNWIND => EndRead[];
[control, comment, stext, tiogaFile] _ FileReader.FromRope[rope, start, len !
FileReader.InterDoc => { interdoc _ doc; RESUME }];
root _ IF interdoc#NIL THEN InterFile.FromRope[interdoc]
ELSE Finish[control, comment, stext, tiogaFile];
};
EndRead[];
};

FromStream: PUBLIC PROC
[stream: IO.STREAM, len: INT _ TextNode.MaxLen] RETURNS [root: TextNode.Ref] = {
control, comment, stext: RopeReader.Ref;
interdoc: ROPE;
tiogaFile: BOOL;
StartRead[];
{ ENABLE UNWIND => EndRead[];
[control, comment, stext, tiogaFile] _ FileReader.FromStream[stream, len !
FileReader.InterDoc => { interdoc _ doc; RESUME }];
root _ IF interdoc#NIL THEN InterFile.FromRope[interdoc]
ELSE Finish[control, comment, stext, tiogaFile];
};
EndRead[];
};

collectionInterval: LONG CARDINAL;
bigCollectionInterval: LONG CARDINAL = 1000000;
startCount: INTEGER _ 0;
StartRead: ENTRY PROC = {
ENABLE UNWIND => NULL;
IF startCount = 0 THEN {
collectionInterval _ SafeStorage.SetCollectionInterval[bigCollectionInterval];
};
startCount _ startCount+1;
};

EndRead: ENTRY PROC = { -- restore initial collectionInterval when all Get's done
ENABLE UNWIND => NULL;
IF (startCount _ startCount-1) = 0 THEN
[] _ SafeStorage.SetCollectionInterval[collectionInterval];
};

Finish: PROC [control, cmmnt, stext: RopeReader.Ref, tiogaFile: BOOL] RETURNS [root: TextNode.Ref] = {

op: Op;
parent, node, prev: TextNode.Ref;
textNode: TextNode.RefTextNode;
terminalNode: BOOL;
textLength, runsLength: INT _ 0;
formatName: ATOM;
propname: ATOM;
charProps: REF _ NIL;
charSets: REF _ NIL;

InsertNode: PROC [node: TextNode.Ref] = {
IF prev#NIL THEN prev.next _ node
ELSE IF parent#NIL THEN parent.child _ node;
prev _ node;
};

ReadByte: PROC RETURNS [Byte] = INLINE {
RETURN [LOOPHOLE[ReadChar[]]];
};

ReadChar: PROC RETURNS [CHAR] = {
RETURN [RopeReader.Get[control]];
};

ReadProp: PROC = {
specs: ROPE _ GetControlRope[];
disaster: BOOL _ FALSE;
value: REF;
value _ NodeProps.DoSpecs[propname, specs !
RuntimeError.UNCAUGHT => {disaster_TRUE}
];
IF disaster THEN ERROR FromFileError; 
IF value # NIL THEN {
IF propname = $CharProps THEN charProps _ value
ELSE IF propname = $CharSets THEN charSets _ value
ELSE NodeProps.PutProp[node, propname, value];
};
};

GetRope: PROC [len: INT, rdr: RopeReader.Ref] RETURNS [ROPE] = {
rope: ROPE;
pos: INT;
[rope, pos] _ RopeReader.Position[rdr];
RopeReader.SetIndex[rdr, pos+len];
RETURN [RopeEdit.Substr[rope, pos, len]];
};

GetControlRope: PROC RETURNS [ROPE] = {
RETURN [GetRope[ReadLength[], control]];
};

GetText: PROC = {
len: NAT;
IF (len _ ReadByte[]) > text.maxLength THEN text _ NEW[TEXT[len]];
FOR i: NAT IN [0..len) DO
text[i] _ RopeReader.Get[control];
ENDLOOP;
text.length _ len;
};

GetAtom: PROC RETURNS [ATOM] = {
GetText[]; -- get the print name
RETURN [IF text.length = 0 THEN NIL ELSE Atom.MakeAtomFromRefText[text]];
};

ReadLength: PROC RETURNS [INT] = {
first, second, fourth: LengthByte;
third: ThirdByte;
card: IntBytes;
first _ LOOPHOLE[ReadByte[]];
card.first _ first.data;
IF ~first.others THEN RETURN [LOOPHOLE[card]];
second _ LOOPHOLE[ReadByte[]];
card.second _ second.data;
IF ~second.others THEN RETURN [LOOPHOLE[card]];
third _ LOOPHOLE[ReadByte[]];
card.thirdBottom _ third.dataBottom;
card.thirdTop _ third.dataTop;
IF ~third.others THEN RETURN [LOOPHOLE[card]];
fourth _ LOOPHOLE[ReadByte[]];
card.fourth _ fourth.data;
RETURN [LOOPHOLE[card]];
};

NextOp: PROC RETURNS [op: Op] = { 

op _ RopeReader.Get[control ! RopeReader.ReadOffEnd => { op _ endOfFile; CONTINUE }];
};

pgf: PGSupport.PGF _ PGSupport.CreatePGF[];
text: REF TEXT _ NEW[TEXT[32]];

terminalNode _ FALSE;
op _ NextOp[];
DO
SELECT op FROM
IN [terminalTextNodeFirst..terminalTextNodeLast] => {
formatName _ PGSupport.RetrieveFormatName[
LOOPHOLE[op-terminalTextNodeFirst, FormatIndex], pgf
! PGSupport.BadIndex => ERROR FromFileError
];
terminalNode _ TRUE;
};
IN [startNodeFirst..startNodeLast] =>
formatName _ PGSupport.RetrieveFormatName[
LOOPHOLE[op-startNodeFirst, FormatIndex], pgf
! PGSupport.BadIndex => ERROR FromFileError
];
endNode => {
IF prev#NIL THEN { prev.last _ TRUE; prev.next _ parent;};
prev _ parent;
IF (parent _ parent.next)=NIL THEN EXIT;
op _ NextOp[]; LOOP;
};
startNode => {
formatName _ GetAtom[];
[] _ PGSupport.EnterFormatName[formatName, pgf];
};
terminalTextNode => {
formatName _ GetAtom[];
[] _ PGSupport.EnterFormatName[formatName, pgf];
terminalNode _ TRUE;
};
rope, comment => {
reader: RopeReader.Ref;
IF op=rope THEN reader _ stext ELSE { reader _ cmmnt; textNode.comment _ TRUE;};
IF textNode=NIL OR textNode#node THEN ERROR FromFileError;
IF (textLength_ReadLength[]) > 0 THEN  -- get the rope
textNode.rope _ GetRope[textLength, reader];
IF charProps#NIL THEN {NodeProps.PutProp[node,$CharProps,charProps]; charProps_NIL};
IF charSets#NIL THEN {NodeProps.PutProp[node, $CharSets, charSets]; charSets _ NIL};
SELECT runsLength FROM
0 => NULL; -- no runs for this rope
textLength => runsLength _ 0; -- correct length
ENDCASE => ERROR FromFileError; -- mismatch
RopeReader.BumpIndex[reader, 1]; -- skip CR at end of rope
op _ NextOp[]; LOOP;
};
runs => { -- runs, if any, come before corresponding rope
lookRuns: TextLooks.Runs;
numRuns: INT;
pos: INT _ 0;
IF textNode=NIL OR textNode#node THEN ERROR FromFileError;
numRuns _ ReadLength[]; -- read number of runs
WHILE numRuns > 0 DO
num: NAT _ TextLooksSupport.Short[MIN[numRuns, LAST[NAT]]];
baseRuns: TextLooks.BaseRuns _ TextLooksSupport.NewBase[num];
len: INT _ pos;
numRuns _ numRuns-num;
FOR i:NAT IN [0..num) DO -- read runs for this baseRuns
looks: TextLooks.Looks;
ReadLookChars: PROC [num: NAT] = {
FOR i:NAT IN [0..num) DO looks[ReadChar[]] _ TRUE; ENDLOOP;
[] _ PGSupport.EnterLooks[looks, pgf];
};
SELECT op _ NextOp[] FROM
IN [looksFirst .. looksLast] => {
looks _ PGSupport.RetrieveLooks[
LOOPHOLE[op-looksFirst, LooksIndex], pgf
! PGSupport.BadIndex => ERROR FromFileError
]
};
look1 => ReadLookChars[1];
look2 => ReadLookChars[2];
look3 => ReadLookChars[3];
FileOps.looks => {
lb: TextLooks.LooksBytes;
lb.byte0 _ ReadByte[]; lb.byte1 _ ReadByte[];
lb.byte2 _ ReadByte[]; lb.byte3 _ ReadByte[];
[] _ PGSupport.EnterLooks[looks _ LOOPHOLE[lb], pgf];
};
ENDCASE => ERROR FromFileError;
baseRuns[i] _ [pos_pos+ReadLength[], looks];
ENDLOOP;
lookRuns _ IF lookRuns=NIL THEN baseRuns ELSE
TextLooks.Concat[lookRuns, baseRuns, len, pos-len];
ENDLOOP;
runsLength _ pos; -- for use in checking rope length
textNode.runs _ lookRuns;
op _ NextOp[]; LOOP;
};
prop => {
[] _ PGSupport.EnterProp[propname _ GetAtom[], pgf];
ReadProp;
op _ NextOp[]; LOOP;
};
propShort => {
propname _ PGSupport.RetrieveProp[
LOOPHOLE[ReadByte[], PropIndex], pgf
! PGSupport.BadIndex => ERROR FromFileError
];
ReadProp;
op _ NextOp[]; LOOP;
};
otherNode, otherNodeShort, otherNodeSpecs, otherNodeSpecsShort => {
ERROR FromFileError;
};
endOfFile => {
IF parent=NIL THEN EXIT; -- have reached the root
[] _ RopeReader.Backwards[control]; -- backup so read endOfFile again
op _ endNode; LOOP;
};
ENDCASE => ERROR FromFileError;
IF charProps # NIL OR charSets # NIL THEN ERROR FromFileError;
InsertNode[node _ textNode _ NEW[TextNode.Body]];
node.formatName _ formatName;
IF terminalNode THEN terminalNode _ FALSE
ELSE { node.next _ parent; parent _ node; prev _ NIL };
op _ NextOp[];
ENDLOOP;
IF (root _ prev)=NIL THEN -- don't have a normal tree
IF node=NIL THEN root _ NEW[TextNode.Body] -- null file
ELSE root _ node; -- single node in file
root.last _ TRUE;
NodeProps.PutProp[root, $FromTiogaFile, IF tiogaFile THEN $Yes ELSE $No];
PGSupport.FreePGF[pgf];
};

END.
rGetFileImpl.mesa
Copyright c 1984, 1985 by Xerox Corporation.  All rights reserved.
written by Paxton.  January 1981
Paxton. December 1, 1982 9:44 am
Russ Atkinson, June 18, 1984 8:29:12 pm PDT
Paul Rovner, August 10, 1983 4:28 pm
Doug Wyatt, March 3, 1985 5:09:00 pm PST
Michael Plass, March 29, 1985 2:10:32 pm PST
Rick Beach, March 28, 1985 9:46:42 am PST
The character properties and character sets are not stored in the node until after the rope is stored, so that NodePropsImpl can do its consistency check.
MAIN PROGRAM
read 4 bytes of looks from control stream
if reach here, then want to start a new text node
Κ
Ϊ˜
codeš
œ™Kšœ
Οm
œ7™BKš
œ ™ Kš
œ ™ Kš
œ+™+Kš
œ$™$Kš
œ(™(Kš
œ,™,K™)—K˜š
Οk	˜	Kšœžœ
˜Kšœžœ"˜,Kšœ
žœžœ˜Kšœžœβ˜οKšœžœ0˜@Kšžœ
žœ@˜HKšœ
žœ
˜Kšžœ
žœžœ˜Kšœ
žœ˜$Kšœ
žœHžœ4˜Ž
Kšœžœ˜Kšœžœ
žœ˜.Kšœ	žœ˜!KšœžœL˜\Kšœ
žœžœ˜Kšœžœ˜+Kšœ	žœ˜Kšœ
žœ.˜=Kšœžœ˜)Kšœ	žœ"˜0—K˜KšΠblœžœ
ž˜Kšžœžœu˜˜
Kšžœ˜Kšžœ
˜šœžœ
žœ	˜K˜Kšžœžœžœ
˜Kšœžœ˜Kšœžœ
žœžœ
˜#šΟnœžœ
žœžœ	žœžœžœ˜sK˜(Kšœ
žœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜K˜šœžœ
žœ˜˜6˜&Kšœ)žœ˜3——šœžœ
žœ
žœ˜8Kšžœ,˜0—K˜—K˜K˜ K˜
K˜—K˜š 	œžœ
žœžœžœžœ˜VKšžœ˜ K˜(Kšœ
žœ
˜Kšœžœ
˜Kšœžœ
˜K˜šœžœ
žœ˜˜VKšœ)žœ˜3—šœžœ
žœ
žœ˜8Kšžœ,˜0—K˜—K˜K˜ K˜
K˜K˜—š œžœžœ˜Bš
 
œžœžœžœžœ˜-š
 œžœžœžœžœ˜8Kšžœ˜K˜—Kšžœ7˜=K˜—Kšœžœžœ˜&Kšœžœžœ˜Lšœ(žœžœ˜EKšžœF˜J—K˜—K˜š 
œžœ,žœ˜Gš
œ)˜)Kšžœžœ˜!—K˜—K˜Kš œžœ
ž˜š	œžœ	žœžœžœ˜YK˜(Kšœ
žœ
˜Kšœžœ
˜K˜šœžœ
žœ˜˜MKšœ)žœ˜3—šœžœ
žœ
žœ˜8Kšžœ,˜0—K˜—K˜
K˜—K˜Kš 
œžœ
ž˜š	œ	žœ
žœžœžœ˜PK˜(Kšœ
žœ
˜Kšœžœ
˜K˜šœžœ
žœ˜˜JKšœ)žœ˜3—šœžœ
žœ
žœ˜8Kšžœ,˜0—K˜—K˜
K˜—K˜Kšœžœ
žœ
˜"Kšœžœ
žœ˜/Kšœžœ˜š 	œžœ
žœ˜Kšžœ
žœžœ
˜šžœžœ˜K˜NK˜—K˜K˜—K˜š œžœ
žœΟc9˜QKšžœ
žœžœ
˜Kšžœ!ž˜'K˜;K˜—K˜š œžœ4žœžœ˜fK˜K˜K˜!K˜Kšœžœ
˜Kšœžœ˜ Kšœžœ
˜Kšœ
žœ
˜Kšœžœžœ
˜Kšœ
žœžœ
˜K˜š 
œžœ˜)šžœžœ
žœ˜!Kšžœ
žœžœ
žœ˜,—K˜K˜—K˜š œžœ
žœ
žœ˜(Kšžœžœ˜K˜—K˜š œžœ
žœžœ˜!Kšžœ˜!K˜—K˜š œžœ˜Kšœžœ˜Kšœ
žœžœ
˜Kšœžœ
˜š
œ+˜+Kšœ
žœžœ
˜(Kš
œ˜—Kšžœ
žœ
žœ˜&šžœ	žœ
žœ˜J™š
Jšžœžœ˜/Jšžœ
žœžœ˜2Jšžœ*˜.Jš
œ˜—K˜—K˜š
 œžœžœžœžœ˜@Kšœžœ
˜Kšœžœ
˜	K˜'K˜"Kšžœ#˜)K˜—K˜š œžœ
žœžœ˜'Kšžœ"˜(K˜—K˜š œžœ˜Kšœžœ
˜	Kšžœ%žœžœ
žœ˜Bšžœžœ
žœ
ž˜Kš
œ"˜"Kšžœ
˜—Kš
œ˜K˜—K˜š œžœ
žœžœ˜ Kšœ‘˜ Kš
žœžœžœ
žœ
žœ!˜IK˜—K˜š 
œžœ
žœžœ˜"K˜"K˜K˜Kšœžœ
˜K˜Kšžœžœ
žœžœ˜.Kšœ	žœ
˜K˜Kšžœžœ
žœžœ˜/Kšœžœ
˜K˜$K˜Kšžœžœ
žœžœ˜.Kšœ	žœ
˜K˜Kšžœžœ˜K˜—K˜š œžœ
žœ˜"K˜KšœIžœ˜UK˜—K˜Kš
œ™Kšœžœ˜+Kš	œžœ
žœžœ
žœ˜K˜Kšœžœ
˜K˜š
ž˜šžœž˜šžœ3˜5š
œ*˜*Kšžœ,˜4Kšœžœ˜+Kš
œ˜—Kšœžœ
˜K˜—Kšžœ#˜%š
œ*˜*Kšžœ%˜-Kšœžœ˜+Kš
œ˜—˜Kšžœžœ
žœžœ˜:K˜Kšžœžœ
žœ
žœ
˜(Kšœžœ
˜K˜—˜K˜K˜0K˜—˜K˜K˜0Kšœžœ
˜K˜—˜K˜Kšžœ	žœžœ&žœ˜PKš
žœ
žœ
žœžœ
žœ˜:šžœžœ‘˜6K˜,—Kšžœžœ
žœ:žœ˜TKšžœ
žœ
žœ;žœ˜Tšžœž˜Kšœžœ‘˜#Kšœ‘˜/Kšžœžœ‘˜+—Kšœ!‘˜:Kšœžœ
˜K˜—šœ
‘/˜9K˜Kšœ	žœ
˜
Kšœžœ˜
Kš
žœ
žœ
žœžœ
žœ˜:Kšœ‘˜.šžœ
ž˜Kš	œžœžœ
žœ
žœ˜;K˜=Kšœžœ˜K˜š	žœžœ
žœ
žœ
‘˜7K˜š 
œžœžœ˜"Kšžœžœ
žœ
žœžœžœ
˜;K˜&K˜—šžœž˜šžœ˜!š
œ ˜ Kšžœ ˜(Kšœžœ˜+Kš
œ
˜
—Kš
œ˜—K˜K˜K˜˜Kš
œ)™)K˜K˜-K˜-Kšœ"žœ˜5K˜—Kšžœžœ˜—K˜,Kšžœ
˜—Kšœžœ
žœ
žœ
ž˜-K˜3Kšžœ
˜—Kšœ‘"˜4K˜Kšœžœ
˜K˜—˜	K˜4K˜	Kšœžœ
˜K˜—˜š
œ"˜"Kšžœ˜$Kšœžœ˜+Kš
œ˜—K˜	Kšœžœ
˜K˜—š
œC˜CKšžœ˜K˜—˜Kš	žœžœ
žœ
žœ‘˜1Kšœ$‘!˜EKšœžœ
˜K˜—Kšžœžœ˜—Kš
œ1™1Kšžœ
žœ
žœžœ
žœ
žœ˜>Kšœžœ˜1K˜Kšžœžœž˜)Kšžœ-žœ˜7K˜Kšžœ
˜—Kšžœžœ
žœ
‘˜5š	žœžœ
žœžœ‘˜7Kšžœ‘˜(—Kšœžœ
˜Kšœ(žœžœžœ˜IK˜K˜—K˜—Kšžœ
˜—…—+τ<@