
DIRECTORY
Atom,
CharOps,
IO,
NodeProps,
PFS,
PFSNames,
RefText,
Rope,
Rosary,
TextEdit,
TextNode,
Tioga,
TiogaFileFormat,
TiogaFileIO,
TiogaIO,
TiogaIOExtras;

TiogaIOImpl: CEDAR PROGRAM
IMPORTS Atom, CharOps, IO, NodeProps, PFS, PFSNames, RefText, Rope, Rosary, TextEdit, TextNode, TiogaFileIO
EXPORTS TiogaIO, TiogaIOExtras
~ BEGIN

STREAM: TYPE ~ IO.STREAM;
ROPE: TYPE ~ Rope.ROPE;
ROSARY: TYPE ~ Rosary.ROSARY;
Node: TYPE ~ Tioga.Node;
Looks: TYPE ~ Tioga.Looks;
noLooks: Looks ~ Tioga.noLooks;
Look: TYPE ~ Tioga.Look;
GetByte: PROC [s: STREAM] RETURNS [BYTE] ~ INLINE { RETURN[IO.GetByte[s]] };

PutByte: PROC [s: STREAM, byte: BYTE] ~ INLINE { IO.PutByte[s, byte] };

GetChar: PROC [s: STREAM] RETURNS [CHAR] ~ INLINE { RETURN[IO.GetChar[s]] };

PutChar: PROC [s: STREAM, char: CHAR] ~ INLINE { IO.PutChar[s, char] };

Op: TYPE ~ TiogaFileFormat.Op;

GetOp: PROC [s: STREAM] RETURNS [Op] ~ INLINE { RETURN[VAL[GetByte[s]]] };

PutOp: PROC [s: STREAM, op: Op] ~ INLINE { PutByte[s, ORD[op]] };

IndexFromOp: PROC [first: Op, op: Op] RETURNS [BYTE] ~ INLINE {
RETURN[ORD[op]-ORD[first]]
};

OpFromIndex: PROC [first: Op, index: BYTE] RETURNS [Op] ~ INLINE {
RETURN[VAL[ORD[first]+index]]
};

GetLen: PROC [s: STREAM] RETURNS [CARD] ~ {
b: BYTE ~ GetByte[s];
RETURN[IF b<(2**7) THEN b ELSE GetLen[s]*(2**7)+(b MOD (2**7))];
};

PutLen: PROC [s: STREAM, len: CARD] ~ {
IF len<(2**7) THEN PutByte[s, len]
ELSE { PutByte[s, (2**7)+(len MOD (2**7))]; PutLen[s, len/(2**7)] };
};

GetLenRope: PROC [s: STREAM] RETURNS [ROPE] ~ {
len: CARD ~ GetLen[s];
RETURN[IO.GetRope[s, len, TRUE]];
};

SkipLenRope: PROC [s: STREAM] ~ {
len: CARD ~ GetLen[s];
IO.SetIndex[s, IO.GetIndex[s]+len];
};

PutLenRope: PROC [s: STREAM, rope: ROPE] ~ {
PutLen[s, Rope.Size[rope]];
IO.PutRope[s, rope];
};

GetLenText: PROC [s: STREAM, buffer: REF TEXT Ź NIL] RETURNS [REF TEXT] ~ {
len: CARD ~ GetLen[s];
RETURN[IO.GetText[s, len]];
};

GetLenAtom: PROC [s: STREAM, buffer: REF TEXT Ź NIL] RETURNS [ATOM] ~ {
RETURN[Atom.MakeAtomFromRefText[GetLenText[s, buffer]]];
};

PutLenAtom: PROC [s: STREAM, atom: ATOM] ~ {
PutLenRope[s, Atom.GetPName[atom]];
};

Get16: PROC [s: STREAM] RETURNS [CARD16] ~ {
b0: BYTE ~ GetByte[s];
b1: BYTE ~ GetByte[s];
RETURN[b0*(2**8)+b1];
};

Put16: PROC [s: STREAM, val: CARD16] ~ {
b0: BYTE ~ val / (2**8);
b1: BYTE ~ val MOD (2**8);
PutByte[s, b0];
PutByte[s, b1];
};

Get32: PROC [s: STREAM] RETURNS [CARD32] ~ {
h0: CARD16 ~ Get16[s];
h1: CARD16 ~ Get16[s];
RETURN[h0*(2**16)+h1];
};

Put32: PROC [s: STREAM, val: CARD32] ~ {
h0: CARD16 ~ val / (2**16);
h1: CARD16 ~ val MOD (2**16);
Put16[s, h0];
Put16[s, h1];
};

GetLooks: PROC [s: STREAM] RETURNS [Looks] ~ INLINE { RETURN[LOOPHOLE[Get32[s]]] };

PutLooks: PROC [s: STREAM, looks: Looks] ~ INLINE { Put32[s, LOOPHOLE[looks]] };

GetLookChars: PROC [s: STREAM, n: NAT] RETURNS [looks: Looks Ź noLooks] ~ {
THROUGH [0..n) DO c: Look ~ GetChar[s]; looks[c] Ź TRUE ENDLOOP;
};

PutLookChars: PROC [s: STREAM, looks: Looks] ~ {
FOR c: Look IN Look DO IF looks[c] THEN PutChar[s, c] ENDLOOP;
};

CountLooks: PROC [looks: Looks] RETURNS [n: NAT Ź 0] ~ {
FOR c: Look IN Look DO IF looks[c] THEN n Ź n+1 ENDLOOP;
};

Error: PUBLIC ERROR ~ CODE;

numFormats: NAT ~ TiogaFileFormat.numFormats;
numProps: NAT ~ TiogaFileFormat.numProps;
numLooks: NAT ~ TiogaFileFormat.numLooks;

PreloadTables: PROC [
reserveFormat: PROC [ATOM, BYTE],
reserveProp: PROC [ATOM, BYTE],
reserveLooks: PROC [Looks, BYTE]
] ~ {
reserveFormat[NIL, 0];
reserveProp[NIL, 0];
reserveProp[$Prefix, 1];
reserveProp[$Postfix, 2];
reserveLooks[noLooks, 0];
};

GetDocRope: PUBLIC PROC [s1, s2, s3: STREAM] RETURNS [rope: ROPE Ź NIL] ~ {
SkipRuns: PROC ~ {
numRuns: INT ~ GetLen[s3];
THROUGH [0..numRuns) DO
looksOp: Op ~ GetOp[s3];
SELECT looksOp FROM
IN [looksFirst..looksLast] => NULL;
look1 => [] Ź GetLookChars[s3, 1];
look2 => [] Ź GetLookChars[s3, 2];
look3 => [] Ź GetLookChars[s3, 3];
looks => [] Ź GetLooks[s3];
ENDCASE => ERROR Error;
[] Ź GetLen[s3];
ENDLOOP;
};
newlineChars: NAT Ź 1;
ReadRope: PROC [comment: BOOL] ~ {
size: INT ~ GetLen[s3];
s: STREAM ~ IF comment THEN s2 ELSE s1;
rope Ź Rope.Concat[rope, IO.GetRope[s, size+newlineChars, TRUE]];
};
DO op: Op ~ GetOp[s3];
SELECT op FROM
startNode, startLeaf => SkipLenRope[s3];
IN [startNodeFirst..startNodeLast] => NULL;
IN [startLeafFirst..startLeafLast] => NULL;
prop => { SkipLenRope[s3]; SkipLenRope[s3] };
propShort => { [] Ź GetByte[s3]; SkipLenRope[s3] };
runs => SkipRuns[];
dataRope => ReadRope[comment: FALSE];
commentRope => ReadRope[comment: TRUE];
endNode => NULL;
endOfFile => EXIT;
ENDCASE => ERROR Error;
ENDLOOP;
};

GetDoc: PUBLIC PROC [s1, s2, s3: STREAM] RETURNS [root: Node] ~ {
tableF: ARRAY [0..numFormats) OF ATOM;
tableP: ARRAY [0..numProps) OF ATOM;
tableL: ARRAY [0..numLooks) OF Looks;
countF, countP, countL: NAT Ź 0;
StoreFormat: PROC [format: ATOM] RETURNS [index: BYTE Ź BYTE.LAST] ~ {
IF countF<numFormats THEN { tableF[index Ź countF] Ź format; countF Ź countF+1 };
};
StoreProp: PROC [prop: ATOM] RETURNS [index: BYTE Ź BYTE.LAST] ~ {
IF countP<numProps THEN { tableP[index Ź countP] Ź prop; countP Ź countP+1 };
};
StoreLooks: PROC [looks: Looks] RETURNS [index: BYTE Ź BYTE.LAST] ~ {
IF countL<numLooks THEN { tableL[index Ź countL] Ź looks; countL Ź countL+1 };
};
FetchFormat: PROC [index: BYTE] RETURNS [ATOM] ~ {
IF NOT index<countF THEN ERROR Error; RETURN [tableF[index]];
};
FetchProp: PROC [index: BYTE] RETURNS [ATOM] ~ {
IF NOT index<countP THEN ERROR Error; RETURN [tableP[index]];
};
FetchLooks: PROC [index: BYTE] RETURNS [Looks] ~ {
IF NOT index<countL THEN ERROR Error; RETURN [tableL[index]];
};
ReserveFormat: PROC [format: ATOM, index: BYTE] ~ {
IF StoreFormat[format]#index THEN ERROR;
};
ReserveProp: PROC [prop: ATOM, index: BYTE] ~ {
IF StoreProp[prop]#index THEN ERROR;
};
ReserveLooks: PROC [looks: Looks, index: BYTE] ~ {
IF StoreLooks[looks]#index THEN ERROR;
};
node, parent, prev: Node Ź NIL;
StartNode: PROC [leaf: BOOL, format: ATOM] ~ {
node Ź NEW[Tioga.NodeRep Ź [parent: parent, format: format]];
IF prev#NIL THEN prev.next Ź node ELSE IF parent#NIL THEN parent.child Ź node;
IF leaf THEN prev Ź node ELSE { parent Ź node; prev Ź NIL };
};
ReadProp: PROC [name: ATOM] = {
specs: ROPE ~ GetLenRope[s3];
value: REF ~ NodeProps.DoSpecs[name, specs];
SELECT name FROM
$CharSets => node.charSets Ź NARROW[value];
$CharProps => node.charProps Ź NARROW[value];
ENDCASE => NodeProps.PutProp[node, name, value];
};
ReadLooks: PROC RETURNS [Looks] ~ {
looksOp: Op ~ GetOp[s3];
IF looksOp IN [looksFirst..looksLast] THEN {
index: BYTE ~ IndexFromOp[looksFirst, looksOp];
RETURN[FetchLooks[index]];
}
ELSE {
looks: Looks ~ SELECT looksOp FROM
look1 => GetLookChars[s3, 1],
look2 => GetLookChars[s3, 2],
look3 => GetLookChars[s3, 3],
looks => GetLooks[s3],
ENDCASE => ERROR Error;
index: BYTE ~ StoreLooks[looks];
RETURN[looks];
};
};
ReadRuns: PROC ~ {
p: PROC [q: PROC [item: REF, repeat: INT]] ~ {
numRuns: INT ~ GetLen[s3];
THROUGH [0..numRuns) DO
looks: Looks ~ ReadLooks[];
repeat: INT ~ GetLen[s3];
q[TextEdit.ItemFromLooks[looks], repeat];
ENDLOOP;
};
node.runs Ź Rosary.FromRuns[p];
};
CheckRosary: PROC [rosary: ROSARY, size: INT] ~ {
IF NOT (rosary=NIL OR Rosary.Size[rosary]=size) THEN ERROR Error;
};
newlineChars: NAT Ź 1;
ReadRope: PROC [comment: BOOL] ~ {
size: INT ~ GetLen[s3];
s: STREAM ~ IF comment THEN s2 ELSE s1;
node.comment Ź comment;
node.rope Ź IF size>0 THEN IO.GetRope[s, size, TRUE] ELSE NIL;
THROUGH [0..newlineChars) DO [] Ź GetChar[s] ENDLOOP; -- discard newline sequence
CheckRosary[node.runs, size]; -- can check these now because the rope comes last
CheckRosary[node.charSets, size];
CheckRosary[node.charProps, size];
};
buffer: REF TEXT ~ RefText.ObtainScratch[100];
PreloadTables[ReserveFormat, ReserveProp, ReserveLooks];
DO op: Op ~ GetOp[s3];
SELECT op FROM
startNode, startLeaf => {
format: ATOM ~ GetLenAtom[s3, buffer];
index: BYTE ~ StoreFormat[format];
StartNode[leaf: (op=startLeaf), format: format];
};
IN [startNodeFirst..startNodeLast] => {
index: BYTE ~ IndexFromOp[startNodeFirst, op];
format: ATOM ~ FetchFormat[index];
StartNode[leaf: FALSE, format: format];
};
IN [startLeafFirst..startLeafLast] => {
index: BYTE ~ IndexFromOp[startLeafFirst, op];
format: ATOM ~ FetchFormat[index];
StartNode[leaf: TRUE, format: format];
};
prop => {
name: ATOM ~ GetLenAtom[s3, buffer];
index: BYTE ~ StoreProp[name];
ReadProp[name];
};
propShort => {
index: BYTE ~ GetByte[s3];
name: ATOM ~ FetchProp[index];
ReadProp[name];
};
runs => ReadRuns[];
dataRope => ReadRope[comment: FALSE];
commentRope => ReadRope[comment: TRUE];
endNode => { prev Ź parent; parent Ź prev.parent };
endOfFile => EXIT;
ENDCASE => ERROR Error;
ENDLOOP;
RefText.ReleaseScratch[buffer];
IF NOT parent=NIL AND prev#NIL THEN ERROR Error;
RETURN[IF prev#NIL THEN prev ELSE node];
};

emptyAtom: ATOM ~ Atom.MakeAtom[NIL];

PutDoc: PUBLIC PROC [s1, s2, s3: STREAM, root: Node] ~ {
tableF: ARRAY [0..numFormats) OF ATOM;
tableP: ARRAY [0..numProps) OF ATOM;
tableL: ARRAY [0..numLooks) OF Looks;
countF, countP, countL: NAT Ź 0;
FindFormat: PROC [format: ATOM] RETURNS [found: BOOL Ź FALSE, index: BYTE Ź 0] ~ {
IF format=emptyAtom THEN format Ź NIL; -- important for compatibility!
FOR i: BYTE IN [0..countF) DO IF tableF[i]=format THEN RETURN[TRUE, i] ENDLOOP;
IF countF<numFormats THEN { tableF[index Ź countF] Ź format; countF Ź countF+1 };
};
FindProp: PROC [prop: ATOM] RETURNS [found: BOOL Ź FALSE, index: BYTE Ź 0] ~ {
FOR i: BYTE IN [0..countP) DO IF tableP[i]=prop THEN RETURN[TRUE, i] ENDLOOP;
IF countP<numProps THEN { tableP[index Ź countP] Ź prop; countP Ź countP+1 };
};
FindLooks: PROC [looks: Looks] RETURNS [found: BOOL Ź FALSE, index: BYTE Ź 0] ~ {
FOR i: BYTE IN [0..countL) DO IF tableL[i]=looks THEN RETURN[TRUE, i] ENDLOOP;
IF countL<numLooks THEN { tableL[index Ź countL] Ź looks; countL Ź countL+1 };
};
ReserveFormat: PROC [format: ATOM, index: BYTE] ~ {
IF FindFormat[format].index#index THEN ERROR;
};
ReserveProp: PROC [prop: ATOM, index: BYTE] ~ {
IF FindProp[prop].index#index THEN ERROR;
};
ReserveLooks: PROC [looks: Looks, index: BYTE] ~ {
IF FindLooks[looks].index#index THEN ERROR;
};
newline: ROPE ~ TextEdit.GetNewlineDelimiter[root];
node: Node Ź root;
PreloadTables[ReserveFormat, ReserveProp, ReserveLooks];
DO
leaf: BOOL ~ (node.child=NIL);
ropeSize: INT ~ Rope.Size[node.rope];
{ -- write start op and format
found: BOOL; index: BYTE;
[found, index] Ź FindFormat[node.format];
IF found THEN { -- old format
PutOp[s3, OpFromIndex[(IF leaf THEN startLeafFirst ELSE startNodeFirst), index]];
}
ELSE { -- new format
PutOp[s3, (IF leaf THEN startLeaf ELSE startNode)];
PutLenAtom[s3, node.format];
};
};
{ -- write properties
WriteProp: PROC [name: ATOM, value: REF] RETURNS [BOOL Ź FALSE] = {
specs: ROPE ~ NodeProps.GetSpecs[name, value];
IF specs#NIL THEN {
found: BOOL; index: BYTE;
[found, index] Ź FindProp[name];
IF found THEN { PutOp[s3, propShort]; PutByte[s3, index] } -- old prop
ELSE { PutOp[s3, prop]; PutLenAtom[s3, name] }; -- new prop
PutLenRope[s3, specs];
};
};
WritePropRosary: PROC [name: ATOM, rosary: ROSARY] ~ {
IF rosary=NIL THEN RETURN;
IF Rosary.Size[rosary]#ropeSize THEN ERROR;
[] Ź WriteProp[name, rosary];
};
WritePropRosary[$CharSets, node.charSets];
WritePropRosary[$CharProps, node.charProps];
[] Ź NodeProps.MapProps[node, WriteProp, FALSE, FALSE];
};
IF node.runs#NIL THEN { -- write looks
numRuns, runsSize: INT Ź 0;
countRuns: Rosary.RunActionType ~ { numRuns Ź numRuns+1 };
writeRuns: Rosary.RunActionType ~ {
looks: Looks ~ TextEdit.LooksFromItem[item]; 
found: BOOL; index: BYTE;
[found, index] Ź FindLooks[looks];
IF found THEN PutOp[s3, OpFromIndex[looksFirst, index]]
ELSE SELECT CountLooks[looks] FROM -- must write out the looks
1 => { PutOp[s3, look1]; PutLookChars[s3, looks] };
2 => { PutOp[s3, look2]; PutLookChars[s3, looks] };
3 => { PutOp[s3, look3]; PutLookChars[s3, looks] };
ENDCASE => { PutOp[s3, looks]; PutLooks[s3, looks] };
PutLen[s3, repeat];
runsSize Ź runsSize+repeat;
};
[] Ź Rosary.MapRuns[[node.runs], countRuns];
PutOp[s3, runs];
PutLen[s3, numRuns];
[] Ź Rosary.MapRuns[[node.runs], writeRuns];
IF runsSize#ropeSize THEN ERROR;
};
{ -- write the rope
s: STREAM ~ IF node.comment THEN s2 ELSE s1;
PutOp[s3, IF node.comment THEN commentRope ELSE dataRope];
PutLen[s3, ropeSize];
IO.PutRope[s, node.rope];
IO.PutRope[s, newline];
};
{ -- move to the next node
IF NOT leaf THEN node Ź node.child -- descend in the tree
ELSE DO -- move to sibling or up* then sibling
IF node=root THEN GOTO Finis;
IF node.next#NIL THEN { node Ź node.next; EXIT }; -- sibling
node Ź node.parent; -- parent
PutOp[s3, endNode];
ENDLOOP;
};
REPEAT Finis => PutOp[s3, endOfFile];
ENDLOOP;
};
InterestingProp: PROC [name: ATOM, value: REF] RETURNS [BOOL] ~ {
RETURN [SELECT name FROM
$Viewer, $LockedViewer, $FromTiogaFile, $DocumentLock, $FileCreateDate, $FileExtension, $NewlineDelimiter => FALSE, 
ENDCASE => TRUE];
};

SimpleNode: PROC [node: Node, comment: BOOL] RETURNS [BOOL] ~ {
RETURN[node.runs=NIL AND node.charSets=NIL AND node.charProps=NIL 
AND (node.format=NIL OR node.format=emptyAtom) AND node.comment=comment 
AND NOT NodeProps.MapProps[node, InterestingProp, FALSE, FALSE]];
};

RopeFromSimpleDoc: PUBLIC PROC [root: Node] RETURNS [ROPE] ~ {
IF root#NIL AND root.rope=NIL AND SimpleNode[root, TRUE] THEN {
child: Node ~ root.child;
IF child#NIL AND child.child=NIL AND child.next=NIL AND SimpleNode[child, FALSE] THEN RETURN[IF child.rope=NIL THEN "" ELSE child.rope];
};
RETURN [NIL];
};
SimpleDocFromRope: PUBLIC PROC [rope: ROPE] RETURNS [Node] ~ {
RETURN [TextEdit.DocFromNode[TextEdit.FromRope[rope]]];
};
LowerCase: PROC [r: ROPE] RETURNS [ROPE] ~ {
RETURN [Rope.Translate[base: r, translator: Rope.Lower]];
};
FileExtensionFromPath: PROC [path: PFS.PATH] RETURNS [ATOM] ~ {
name: ROPE ~ PFSNames.ShortNameRope[path];
pos: INT ~ Rope.FindBackward[name, "."];
ext: ROPE ~ IF pos<0 THEN NIL ELSE Rope.Substr[name, pos+1];
RETURN[IF Rope.IsEmpty[ext] THEN $null ELSE Atom.MakeAtom[LowerCase[ext]]];
};

FileCreateDateFromUniqueID: PROC [uniqueID: PFS.UniqueID] RETURNS [REF] ~ {
RETURN[NEW[PFS.UniqueID Ź uniqueID]];
};

PutFileProps: PROC [root: Node, fullFName: PFS.PATH, uniqueID: PFS.UniqueID] ~ {
NodeProps.PutProp[root, $FileExtension, FileExtensionFromPath[fullFName]];
NodeProps.PutProp[root, $FileCreateDate, FileCreateDateFromUniqueID[uniqueID]];
};


FromRope: PUBLIC PROC [rope: ROPE] RETURNS [Node] ~ {
parts: TiogaFileIO.Parts ~ TiogaFileIO.GetParts[IO.RIS[rope]];
IF parts.isTioga THEN RETURN[GetDoc[
s1: IO.RIS[Rope.Substr[rope, parts.start1, parts.len1]],
s2: IO.RIS[Rope.Substr[rope, parts.start2, parts.len2]],
s3: IO.RIS[Rope.Substr[rope, parts.start3, parts.len3]]
]]
ELSE RETURN[SimpleDocFromRope[rope]];
};

ToStream: PUBLIC PROC [s: STREAM, root: Node] RETURNS [dataLen: INT] ~ {
rope: ROPE ~ RopeFromSimpleDoc[root];
IF rope=NIL THEN {
put: PROC [s1, s2, s3: STREAM] ~ { PutDoc[s1, s2, s3, root] };
dataLen Ź TiogaFileIO.PutParts[s, put];
}
ELSE {
IO.PutRope[s, rope];
dataLen Ź Rope.Size[rope];
};
};

ToRope: PUBLIC PROC [root: Node] RETURNS [ROPE] ~ {
rope: ROPE ~ RopeFromSimpleDoc[root];
IF rope=NIL THEN {
s: STREAM ~ IO.ROS[];
dataLen: INT ~ ToStream[s, root];
RETURN[IO.RopeFromROS[s]];
}
ELSE RETURN[rope];
};


FromPair: PUBLIC PROC [pair: TiogaIO.Pair] RETURNS [Node] ~ {
IF Rope.Size[pair.formatting]>0
THEN RETURN[FromRope[Rope.Concat[pair.contents, pair.formatting]]]
ELSE RETURN[SimpleDocFromRope[pair.contents]];
};

ToPair: PUBLIC PROC [root: Node] RETURNS [TiogaIO.Pair] ~ {
rope: ROPE ~ RopeFromSimpleDoc[root];
IF rope=NIL THEN {
s: STREAM ~ IO.ROS[];
dataLen: INT ~ ToStream[s, root];
rope: ROPE ~ IO.RopeFromROS[s];
RETURN[[
contents: Rope.Substr[base: rope, len: dataLen],
formatting: Rope.Substr[base: rope, start: dataLen]
]];
}
ELSE RETURN[[contents: rope, formatting: NIL]];
};
checkMutabilityInFromFile: BOOL Ź TRUE;
FromFile: PUBLIC PROC [fileName: PFS.PATH, wantedUniqueID: PFS.UniqueID] 
RETURNS [fullFName: PFS.PATH, uniqueID: PFS.UniqueID, root: Node] ~ {
rope: ROPE Ź NIL;
[rope: rope, fullFName: fullFName, uniqueID: uniqueID] Ź PFS.RopeOpen[
fileName: fileName, wantedUniqueID: wantedUniqueID, 
includeFormatting: TRUE, checkMutability: checkMutabilityInFromFile];
root Ź FromRope[rope];
PutFileProps[root, fullFName, uniqueID];
};

ToFile: PUBLIC PROC [fileName: PFS.PATH, root: Node] 
RETURNS [fullFName: PFS.PATH, uniqueID: PFS.UniqueID, dataLen: INT] ~ {
file: PFS.OpenFile ~ PFS.Open[name: fileName, access: create];
RETURN ToOpenFile[file, root];
};

FromOpenFile: PUBLIC PROC [file: PFS.OpenFile] 
RETURNS [fullFName: PFS.PATH, uniqueID: PFS.UniqueID, root: Node] ~ {
[fullFName: fullFName, uniqueID: uniqueID] Ź PFS.GetInfo[file];
PFS.Close[file];
RETURN FromFile[fullFName, uniqueID];
};

ToOpenFile: PUBLIC PROC [file: PFS.OpenFile, root: Node] 
RETURNS [fullFName: PFS.PATH, uniqueID: PFS.UniqueID, dataLen: INT] ~ {
s: STREAM ~ PFS.StreamFromOpenFile[openFile: file, accessOptions: write];
[fullFName: fullFName, uniqueID: uniqueID] Ź PFS.GetInfo[file];
dataLen Ź ToStream[s, root];
IO.Close[s];
PutFileProps[root, fullFName, uniqueID];
};

IsAlreadyACommentLine: PROC [r: ROPE] RETURNS [BOOL] = {
loc: INT Ź 0;
size: INT = Rope.Size[r];
c: CHAR;
WHILE loc < size AND CharOps.Blank[c Ź Rope.Fetch[r, loc]] DO
loc Ź loc+1; ENDLOOP;
IF loc > size-2 OR c # '- OR Rope.Fetch[r, loc+1] # '- THEN RETURN [FALSE];
IF Rope.SkipTo[s: r, skip: "\r\l"] < size THEN {
RETURN [FALSE];
};
IF Rope.Match[pattern: "--*--*", object: r] THEN {
RETURN [FALSE];
};
RETURN [TRUE] 
};

MapDelimitedPieces: PROC [action: PROC [rope: ROPE, start, len: INT], delimiter: ROPE, base: ROPE, start: INT Ź 0, len: INT Ź INT.LAST] = {
t: INT Ź start;
dSize: INT = Rope.Size[delimiter];
end: INT = MIN[start+len, Rope.Size[base]];
DO
i: INT Ź Rope.Index[s1: base, pos1: t, s2: delimiter];
IF i > end-dSize THEN {i Ź end};
IF i >= t THEN action[base, t, i-t];
IF i = end THEN EXIT;
t Ź i+dSize;
ENDLOOP;
};
WritePlain: PUBLIC PROC [s: IO.STREAM, root: Node, 
restoreDashes: BOOL Ź FALSE, indent: ROPE Ź NIL] ~ {
node: Node Ź root;
level: INTEGER Ź 0;
levelDelta: INTEGER;
BeginLine: PROC = {
THROUGH [1..level) DO IO.PutRope[s, indent] ENDLOOP; -- output level-1 tabs
};
EndLine: PROC = {
IO.PutChar[s, '\n];
};
IF indent=NIL THEN indent Ź "\t";
DO
[node, levelDelta] Ź TextNode.Forward[node];
IF node=NIL THEN EXIT;
level Ź level+levelDelta;
IF restoreDashes AND node.comment AND NOT IsAlreadyACommentLine[node.rope]
THEN {
EachLine: PROC [rope: ROPE, start, len: INT] = {
first: BOOL Ź TRUE;
EachPart: PROC [rope: ROPE, start, len: INT] = {
IF NOT first THEN IO.PutRope[s, " - - "];
IO.PutRope[self: s, r: rope, start: start, len: len];
first Ź FALSE;
};
BeginLine[]; IO.PutRope[s, "-- "]; -- restore the leading dashes for Mesa comments
MapDelimitedPieces[EachPart, "--", rope, start, len];
EndLine[];
};
MapDelimitedPieces[EachLine, "\n", node.rope, 0, Rope.Size[node.rope]];
}
ELSE { BeginLine[]; IO.PutRope[s, node.rope]; EndLine[] };
ENDLOOP;
};
WritePlainToStream: PUBLIC PROC [s: IO.STREAM, root: Node, restoreDashes: BOOL] = {
WritePlain[s, root, restoreDashes];
};
WritePlainToRope: PUBLIC PROC [root: Node, restoreDashes: BOOL] RETURNS [ROPE] ~ {
rope: ROPE ~ RopeFromSimpleDoc[root];
IF rope=NIL THEN {
s: STREAM ~ IO.ROS[];
WritePlain[s, root, restoreDashes];
RETURN[IO.RopeFromROS[s]];
}
ELSE RETURN[rope];
};


END.
   
  
TiogaIOImpl.mesa
Copyright Ó 1985, 1986, 1987, 1988, 1991, 1992, 1993 by Xerox Corporation.  All rights reserved.
written by Paxton.  March 1981
Paxton. August 24, 1982 10:39 am
Last Edited by: Maxwell, January 5, 1983 1:07 pm
Russ Atkinson, July 26, 1983 5:41 pm
Last Edited by: Birrell, August 23, 1983 1:29 pm
Bier, January 10, 1989 12:03:31 pm PST
Plass, September 24, 1991 2:11 pm PDT
Willie-s, February 15, 1991 3:17 pm PST
Doug Wyatt, June 7, 1993 1:45 pm PDT
Utilities
Get/Put parts
The following Find* operations just do a dumb linear search; this is much simpler than the old PGSupport, it uses only local storage, and the tables are never very large. -- DKW
Simple documents
When you add a new "system" property that should not go on files, add registration at end of TEditDocuments2Impl to skip copy/write.


Get/Put file


WritePlain
comment has a CR or LF in it, so be careful
comment has some other double dashes in it, so be careful


TiogaSimpleText
GetNewlineDelimiterChar: PUBLIC PROC [root: Node] RETURNS [CHAR] ~ {
IF root # NIL THEN WITH NodeProps.GetProp[root, $NewlineDelimiter] SELECT FROM
rope: ROPE => IF Rope.Size[rope] = 1 THEN RETURN [Rope.Fetch[rope, 0]];
ENDCASE => NULL;
RETURN ['\r];
};

GetNewlineDelimiterRope: PUBLIC PROC [root: Node] RETURNS [ROPE] ~ {
IF root # NIL THEN WITH NodeProps.GetProp[root, $NewlineDelimiter] SELECT FROM
rope: ROPE => RETURN [rope];
ENDCASE => NULL;
RETURN ["\r"];
};

SimpleText: PUBLIC PROC [root: Node] RETURNS [ROPE] ~ {
RETURN [RopeFromSimpleDoc[root]];
};

IsThisStreamATiogaFile: PUBLIC PROC [stream: STREAM] RETURNS [yes: BOOL, len: INT] ~ {
parts: TiogaFileIO.Parts ~ TiogaFileIO.GetParts[stream];
RETURN[yes: parts.isTioga, len: parts.len1];
};

GetTextContents: PUBLIC PROC [root: Node, start: INT Ź 0, length: INT Ź INT.LAST] RETURNS [ROPE] ~ {
simple: ROPE ~ RopeFromSimpleDoc[root];
IF simple # NIL
THEN { RETURN [Rope.Substr[simple, start, length]] }
ELSE {
loc: INT Ź 0; -- offset of rope into document
len: INT Ź 0; -- same as Rope.Size[rope]
rope: ROPE Ź NIL;
node: Node Ź root;
level: INT Ź 0;
nl: ROPE  ~ GetNewlineDelimiterRope[root];
DO
levelDelta: INTEGER;
IF NOT node.comment THEN {
nodeSize: INT Ź Rope.Size[node.rope];
IF rope = NIL AND loc + nodeSize + 1 <= start
THEN {
loc Ź loc + nodeSize + 1;
}
ELSE {
rope Ź Rope.Concat[rope, Rope.Concat[node.rope, nl]];
len Ź len + nodeSize;
};
};
[node, levelDelta] Ź TextNode.Forward[node];
level Ź level + levelDelta;
IF level = 0 OR loc+len-start >= length THEN EXIT;
ENDLOOP;
RETURN [Rope.Substr[rope, start-loc, length]]
};
};

 Ę!   (cedarcode) styleNewlineDelimiter
 codeK
ĎeU`KĎyK  K00K$K00K&K%K'K$K Ďk		KKKK

KK		KKKK		K		KKKKKK KĎnKBkKK KKK
KKKKhead		 LK  GK  LK  GK K  JK 
 AK 
 ?KKK 
 BKKK 
 +KK


@KK  'K"K#DKK 
 
/KK!KK  !KK#KK  
,KKKK  

KKKKK  

GK28K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  SK 
 PK 
 KK"@KK  0K	
>KK  
	8K	
	8K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K		'KAKK((K$+K$+K--K33KK%K!'KKKKKK 
 AK&K$K%K  
	FK8QK 		BK6MK 
	EK7NK
 	2K
=K
 		0K
=K 
	2K
=K 
	3K(K 	/K$K 2K&KK 	
.K3=KNK<K KK",K+K-K)0K 	#K	,K$/KK	"KKKKKK KKK 	
.K	KKK)KKKK 
1K	AKK "KK		'KK>KĎcQKĄ2PK!!K""KK.K88K&K"K00K%'K#.K"K'K%'K#.K"K&K		K$KKKKKKKKK%K!'K33KKKKK0K
(KK %K  8K&K$K%K Ką 

			RK
ĄFKOK8QK 			NKMK6MK 				QKNK7NK 
	3K -K 	/K)K 2K+KK	&3KK88KK
%ĄK	K))ĄKQKĄK3KKKĄ 		CK#.K	K  K.ĄFK,Ą;KKK 
6KK+KKK**K,,K)7KĄ&KK::##K-K	K""K*7Ą>K33K33K33K.5KKKK,,KKK,,K KĄK	,K
:KKKKĄKĄ9Ą&.KK	Ą
<KĄ	KKKK%KK 	AKmtKKKK 
 
?K+ÍKK 
 >?KKKKKK 
 >K17KK 
 	,K39KK  ?K *K (K<K KKK 
 KK%KK 
 PKJJKOOKK K 
 5K0>$K.8K.8K-7KK%KK  HK%K!>K''KKKKKK 
 3K%KK	!KKKKK K  =K7BK#.KK  ;K%KK	!KK00K33KKK/KK 'K  KK9S.ÁKK((KK  }K&>KKK  uK-?KK%KK  
K:IK-?KK
K((KK 

 8KKK'=KKKStartOfExpansion>[s1: ROPE, s2: ROPE, pos1: INT _ 0, case: BOOL _ TRUE](0K+KK*2K9KKKKK  
	K	K"K+K06K K$K	KKKK  

hKKK 	K	ĄKK  KKK!K,KK!J 0K 0K)K35KKKĄ/RK55K
KKGGKK$:KKK  SJ#KK  RK%KK#KKKKK K 
 D,NK	GKKKK 
 D,NKKKKK 
 
7K!KK  
VK8K&,KK  dK'
K'4KĄ-KĄ(KKKK"*KK
%-KKK55KKKK,,KK2KK'-KKK K K     Kę  vü  