-- PutFileImpl.Mesa
-- written by Paxton. May 1981
-- last written by Paxton. June 2, 1983 11:06 am
-- last written by McGregor. September 10, 1982 1:16 pm
Last Edited by: Maxwell, January 5, 1983 1:07 pm
DIRECTORY
Atom,
Directory,
File,
FileIO,
FileOps,
FileWriter,
IO,
NameSymbolTable,
NodeProps,
OtherNode,
PGSupport,
Process,
PropertyTypes,
PutFile,
PutGet,
Rope,
RopeEdit,
RopeIO,
RopeReader,
RunReader,
System,
TextLooks,
TextNode;
PutFileImpl: CEDAR PROGRAM
IMPORTS Directory, TextNode, npI:NodeProps, FileWriter, Process, Rope, RopeEdit, RopeIO, PGSupport, RopeReader, RunReader, TextLooks, NameSymbolTable, OtherNode, Atom, IO, FileIO
EXPORTS PutGet, PutFile =
BEGIN OPEN PutGet, TextNode, PutFile;
ToRope: PUBLIC PROC [node: Ref, flatten, textOnly: BOOLEANFALSE]
RETURNS [dataLen, count: Offset, output: ROPE] = {
control,comment,data: FileWriter.Ref;
simple: BOOLEAN;
[output,simple] ← SimpleFile[node];
IF simple THEN { dataLen ← count ← Rope.Size[output]; RETURN };
[control,comment,data] ← FileWriter.ToRope[];
Finish[control,comment,data,node,flatten];
[dataLen,count,output] ← FileWriter.Close[control,comment,data,textOnly] };
ToStream: PUBLIC PROC [stream: IO.Handle, node: Ref, flatten, textOnly: BOOLEANFALSE]
RETURNS [dataLen, count: Offset] = {
control,comment,data: FileWriter.Ref;
rope: ROPE;
simple: BOOLEAN;
[rope,simple] ← SimpleFile[node];
IF simple THEN {
RopeIO.PutRope[stream,rope];
dataLen ← count ← Rope.Size[rope];
RETURN };
[control,comment,data] ← FileWriter.ToStream[stream];
Finish[control,comment,data,node,flatten];
[dataLen,count,] ← FileWriter.Close[control,comment,data,textOnly] };
ToFile: PUBLIC PROC [fileName: ROPE,
node: Ref, start: Offset ← 0, flatten, textOnly: BOOLEANFALSE]
RETURNS [dataLen, count: Offset] = {
stream: IO.Handle ← FileIO.Open[fileName,overwrite];
capability: File.Capability ← FileIO.CapabilityFromStream[stream];
IO.Close[stream]; -- need to close first or get 0 length file!
[dataLen,count] ← ToFileC[capability, node, start, flatten, textOnly] };
ToFileC: PUBLIC PROC [file: File.Capability,
node: Ref, start: Offset ← 0, flatten, textOnly: BOOLEANFALSE]
RETURNS [dataLen, count: Offset] = {
ropeToFile: PROC [rope: ROPE] = { RopeIO.ToFileC[file,rope,start] };
opener: PROC RETURNS [control,comment,data: FileWriter.Ref] = {
[control,comment,data] ← FileWriter.OpenC[file,start] };
[dataLen,count] ← FileIt[ropeToFile, opener, node, flatten, textOnly] ;
UpdateCreateDate[node,file] };
UpdateCreateDate: PROC [root: Ref, file: File.Capability] = TRUSTED {
createDate: System.GreenwichMeanTime;
prop: REF System.GreenwichMeanTime;
Directory.GetProperty[file: file, property: PropertyTypes.tCreateDate,
propertyValue: DESCRIPTOR[@createDate, SIZE[System.GreenwichMeanTime]]];
IF (prop ← NARROW[npI.GetProp[root, $FileCreateDate]]) # NIL THEN prop^ ← createDate
ELSE npI.PutProp[root, $FileCreateDate,
TextNode.pZone.NEW[System.GreenwichMeanTime ← createDate]] };
FileIt: PROC [
ropeToFile: PROC [ROPE],
opener: PROC RETURNS [control,comment,data: FileWriter.Ref],
node: Ref, flatten, textOnly: BOOLEAN]
RETURNS [dataLen, count: Offset] = TRUSTED {
control,comment,data: FileWriter.Ref;
rope: ROPE;
simple: BOOLEAN;
priority: Process.Priority = Process.GetPriority[];
Process.SetPriority[Process.priorityBackground];
[rope,simple] ← SimpleFile[node];
IF simple THEN {
ropeToFile[rope];
dataLen ← count ← Rope.Size[rope];
RETURN };
[control,comment,data] ← opener[];
Finish[control,comment,data,node,flatten];
[dataLen,count,] ← FileWriter.Close[control,comment,data,textOnly];
Process.SetPriority[priority] };
SimpleFile: PROC [root: Ref] RETURNS [rope: ROPE, simple: BOOLEAN] = {
SimpleNode: PROC [node: Ref] RETURNS [ROPE, BOOLEAN] = TRUSTED {
HasInterestingProp: PROC RETURNS [BOOL] = TRUSTED {
Check: PROC [name: ATOM, value: REF] RETURNS [BOOLEAN] = TRUSTED {
RETURN [SELECT name FROM
$Viewer, $FromTiogaFile, $DocumentLock, $FileCreateDate, $FileExtension => FALSE,
When add a new "system" property that should not go on files, add registration at end of TEditDocuments2Impl so will not copy/write the property.
ENDCASE => TRUE] };
RETURN [npI.MapProps[node,Check,FALSE,FALSE]] };
text: RefTextNode = NarrowToTextNode[node];
IF node.typename=nullTypeName AND ~text.comment AND ~HasInterestingProp[] THEN
WITH n:node SELECT FROM
text => IF n.runs=NIL THEN RETURN [n.rope,TRUE]
ELSE WITH r:n.runs SELECT FROM
base => IF r.length=1 AND r[0].looks=TextLooks.noLooks THEN
RETURN [n.rope,TRUE];
ENDCASE;
ENDCASE;
RETURN [NIL,FALSE] };
IF root=NIL THEN RETURN [NIL,TRUE];
[rope,simple] ← SimpleNode[root];
IF ~simple THEN RETURN; -- not a simple root node
IF root.child=NIL THEN RETURN; -- simple root and no child
IF rope # NIL OR -- root has child and text, so not simple
~root.child.last OR root.child.child # NIL THEN RETURN [NIL,FALSE]; -- more than one child, so not simple
[rope,simple] ← SimpleNode[root.child] };
Finish: PROC [control, comment, data: FileWriter.Ref, root: Ref, flatten: BOOLEAN] = {
WriteChar: PROC [c: CHARACTER, writer: FileWriter.Ref] = { FileWriter.WriteChar[c,writer] };
WriteAtom: PROC [atom: ATOM] = INLINE {
WriteControlRope[Atom.GetPName[atom]] };
WriteText: PROC [txt: REF READONLY TEXT] = INLINE {
WriteLen[txt.length]; FileWriter.WriteText[txt,control] };
WriteRope: PROC [r: ROPE, writer: FileWriter.Ref] = INLINE {
WriteLen[Rope.Size[r]];
FileWriter.WriteRope[r,Rope.Size[r],writer,ropeReader];
WriteChar[15C,writer] };
NameText: PROC [name: NameSymbolTable.Name] = INLINE {
OPEN NameSymbolTable;
FromName[name,nameText !
TextOverflow => { nameText ← pZone.NEW[TEXT[nameText.length*2]]; RETRY } ]};
WriteControlRope: PROC [r: ROPE] = {
size: Offset ← Rope.Size[r];
WriteLen[size];
FileWriter.WriteRope[r,size,control,ropeReader] };
WriteLen: PROC [len: Offset] = {
OPEN FileOps;
first, second, fourth: LengthByte;
third: ThirdByte;
lenBytes: IntBytes ← LOOPHOLE[len];
IF lenBytes.fourth # 0 THEN {
fourth.data ← lenBytes.fourth;
first.others ← second.others ← third.others ← TRUE };
IF lenBytes.thirdTop # 0 OR lenBytes.thirdBottom # 0 THEN {
third.dataTop ← lenBytes.thirdTop;
third.dataBottom ← lenBytes.thirdBottom;
first.others ← second.others ← TRUE };
IF lenBytes.second # 0 THEN {
second.data ← lenBytes.second; first.others ← TRUE };
first.data ← lenBytes.first;
WriteChar[LOOPHOLE[first],control];
IF first.others THEN {
WriteChar[LOOPHOLE[second],control];
IF second.others THEN {
WriteChar[LOOPHOLE[third],control];
IF third.others THEN {
WriteChar[LOOPHOLE[fourth],control] }}}};
WriteLooks: PROC [lks: TextLooks.LooksBytes] = INLINE {
WriteChar[LOOPHOLE[lks.byte0],control];
WriteChar[LOOPHOLE[lks.byte1],control];
WriteChar[LOOPHOLE[lks.byte2],control];
WriteChar[LOOPHOLE[lks.byte3],control] };
CountLookBits: PROC [lks: TextLooks.Looks] RETURNS [cnt: NAT] = INLINE {
cnt ← 0;
FOR c: CHARACTER IN TextLooks.Look DO
IF lks[c] THEN cnt ← cnt+1; ENDLOOP };
WriteLookChars: PROC [lks: TextLooks.Looks] = INLINE {
FOR c: CHARACTER IN TextLooks.Look DO
IF lks[c] THEN WriteChar[c,control]; ENDLOOP };
WriteProp: PROC [name: ATOM, value: REF] RETURNS [BOOLEAN] = { -- write specs as a rope
OPEN FileOps;
specs: ROPE ← npI.GetSpecs[name,value];
IF specs=NIL THEN RETURN [FALSE];
[ok,propindex] ← PGSupport.EnterProp[name,pgf];
IF ok THEN { -- can use short form
WriteChar[propShort,control];
WriteChar[LOOPHOLE[propindex],control] }
ELSE { -- must write full prop name
WriteChar[prop,control];
WriteAtom[name] };
WriteControlRope[specs];
RETURN [FALSE] };
typename: TypeName;
propname: ATOM;
ok, textnode, terminal: BOOLEAN;
typeindex: FileOps.TypeIndex;
looksindex: FileOps.LooksIndex;
propindex: FileOps.PropIndex;
node,nodeChild: Ref;
pgf: PGSupport.PGF ← PGSupport.CreatePGF[];
runReader: RunReader.Ref ← RunReader.GetRunReader[];
ropeReader: RopeReader.Ref ← RopeReader.GetRopeReader[];
nameText: REF TEXT ← pZone.NEW[TEXT[32]];
node ← root;
DO-- first write type
textnode ← node.kind=text;
terminal ← (nodeChild𡤏irstChild[node])=NIL;
[ok,typeindex] ← PGSupport.EnterTypeName[typename ← node.typename, pgf];
IF ok THEN
IF ~textnode THEN {
WriteChar[FileOps.otherNodeShort,control];
WriteChar[LOOPHOLE[typeindex],control] }
ELSE WriteChar[typeindex+(IF ~terminal THEN FileOps.startNodeFirst
ELSE FileOps.terminalTextNodeFirst),control]
ELSE { WriteChar[IF ~textnode THEN FileOps.otherNode
ELSE IF ~terminal THEN FileOps.startNode
ELSE FileOps.terminalTextNode,control];
NameText[typename]; WriteText[nameText] };
-- write node props
IF node.props # NIL THEN [] ← npI.MapProps[node,WriteProp,FALSE,FALSE];
-- now write contents
TRUSTED {WITH n:node SELECT FROM
text => { -- first the rope, then the looks
rope: ROPE;
size: Offset;
runs: TextLooks.Runs;
IF flatten THEN { -- flatten rope and runs
n.rope ← RopeEdit.Flatten[n.rope];
n.runs ← TextLooks.Flatten[n.runs] };
rope ← n.rope; size ← Rope.Size[rope];
IF (runs ← n.runs) # NIL THEN {
loc, cnt, numRuns: Offset ← 0;
[numRuns,,] ← TextLooks.CountRuns[runs,0,size];
WriteChar[FileOps.runs,control];
WriteLen[numRuns];
RunReader.SetPosition[runReader,runs,0];
WHILE (cnt𡤌nt+1) <= numRuns DO
looks: TextLooks.Looks;
len: Offset;
[len,looks] ← RunReader.MergedGet[runReader];
[ok,looksindex] ← PGSupport.EnterLooks[looks,pgf];
IF ok THEN
WriteChar[FileOps.looksFirst+looksindex,control]
ELSE { -- must write out the looks
SELECT CountLookBits[looks] FROM
1 => { WriteChar[FileOps.look1,control];
WriteLookChars[looks] };
2 => { WriteChar[FileOps.look2,control];
WriteLookChars[looks] };
3 => { WriteChar[FileOps.look3,control];
WriteLookChars[looks] };
ENDCASE => {
WriteChar[FileOps.looks,control];
WriteLooks[LOOPHOLE[looks]] }};
WriteLen[len];
loc ← loc+len;
ENDLOOP;
IF loc # size THEN ERROR };
IF n.comment THEN { -- put text in comment area of file
WriteChar[FileOps.comment,control];
WriteRope[rope,comment] }
ELSE { -- put text in data area of file
WriteChar[FileOps.rope,control];
WriteRope[rope,data] }};
other => {
propname ← n.variety;
[ok,propindex] ← PGSupport.EnterProp[propname,pgf];
IF ok THEN {
WriteChar[FileOps.otherNodeSpecsShort,control];
WriteChar[LOOPHOLE[propindex],control] }
ELSE {
WriteChar[FileOps.otherNodeSpecs,control];
WriteAtom[propname] };
WriteControlRope[OtherNode.GetSpecs[@n]] };
ENDCASE => ERROR};
-- move to the next node
IF ~terminal THEN node ← nodeChild
ELSE { -- node has no children
IF ~textnode THEN WriteChar[FileOps.endNode,control];
DOIF node=root THEN GOTO Finis;
IF ~IsLastSibling[node] THEN { node ← Next[node]; EXIT };
node ← Parent[node];
WriteChar[FileOps.endNode,control];
ENDLOOP };
REPEAT Finis => {
WriteChar[FileOps.endOfFile,control];
RunReader.FreeRunReader[runReader];
RopeReader.FreeRopeReader[ropeReader];
PGSupport.FreePGF[pgf] };
ENDLOOP };
WriteMesaFilePlain: PUBLIC PROC [fileName: ROPE, root: Ref] = {
h: IO.Handle ← FileIO.Open[fileName: fileName, accessOptions: overwrite];
WritePlain[h, root, TRUE];
IO.Close[h] };
WriteFilePlain: PUBLIC PROC [fileName: ROPE, root: Ref] = {
h: IO.Handle ← FileIO.Open[fileName: fileName, accessOptions: overwrite];
WritePlain[h, root];
IO.Close[h] };
WriteFileCPlain: PUBLIC PROC [file: File.Capability, root: Ref] = {
h: IO.Handle ← FileIO.StreamFromCapability[file];
WritePlain[h, root];
IO.Close[h] };
WriteRopePlain: PUBLIC PROC [root: Ref] RETURNS [output: ROPE] = {
h: IO.Handle ← IO.CreateOutputStreamToRope[];
WritePlain[h, root];
RETURN [IO.GetOutputStreamRope[h]] };
WritePlain: PROC [h: IO.Handle, root: Ref, restoreDashes: BOOLFALSE] = {
HasInitialDashes: PROC [r: ROPE] RETURNS [BOOL] = {
loc: INT ← 0;
size: INT = Rope.Size[r];
c: CHAR;
WHILE loc < size AND RopeEdit.BlankChar[c ← Rope.Fetch[r, loc]] DO
loc ← loc+1; ENDLOOP;
IF loc > size OR c # '- OR Rope.Fetch[r, loc+1] # '- THEN RETURN [FALSE];
RETURN [TRUE] };
node: Ref ← root;
level: INTEGER ← 0;
levelDelta: INTEGER;
first: BOOLTRUE;
DO
text: TextNode.RefTextNode;
[node, levelDelta] ← TextNode.Forward[node];
IF node=NIL THEN EXIT;
IF first THEN first ← FALSE
ELSE IO.PutChar[h, '\n]; -- carriage returns between nodes
level ← level+levelDelta;
IF (text ← TextNode.NarrowToTextNode[node])=NIL THEN LOOP;
THROUGH [1..level) DO IO.PutChar[h, '\t]; ENDLOOP; -- output level-1 tabs
IF restoreDashes AND text.comment AND ~HasInitialDashes[text.rope] THEN
IO.PutRope[h, "-- "]; -- restore the leading dashes for Mesa comments
IO.PutRope[h, text.rope];
ENDLOOP;
{ ENABLE IO.Error => IF ec = NotImplementedForThisStream THEN GOTO Exit;
IO.SetLength[h, IO.GetIndex[h]] }
EXITS Exit => RETURN };
-- ***** Initialization
StartPutFile: PUBLIC PROC = {
};
END.