DIRECTORY
Atom USING [ MakeAtom ],
Commander USING [ Register, CommandProc ],
CommanderOps USING [ GetProp, NextArgument ],
IO,
LoganBerry USING [ Error, LogInfo, IndexInfo, SchemaInfo, Describe, nullDB, OpenDB, Open ],
Rope USING [ Concat, Equal, Fetch, Find, Length, ROPE, Substr ],
PFS USING [ ErrorGroup, Error, PATH, PathFromRope, FileInfo, RopeFromPath, StreamOpen ],
PFSNames USING [ ComponentRope, Directory, ShortName ],
SymTab USING [ Create, Erase, Fetch, Ref, Store ],
UserProfile USING [ Token ],
WalnutOps USING [ ValidOpsHandle ],
WalnutWindow USING [ WalnutHandle, GetHandleList, Shutdown, StartUp ]
;

WalnutUtilsImpl: CEDAR PROGRAM IMPORTS Atom, Commander, CommanderOps, IO, LoganBerry, Rope, PFS, PFSNames, SymTab, UserProfile, WalnutWindow, WalnutOps ~ {
OPEN IO;

ROPE: TYPE ~ Rope.ROPE;

WalnutFileInfo: TYPE ~ REF WalnutFileInfoBody;
WalnutFileInfoBody: TYPE ~ RECORD [
rootFileName: ROPE,
logFileName: ROPE,
dbName: ROPE,
lbLogFileName: ROPE,
indexNames: LIST OF IndexInfo
];

IndexInfo: TYPE ~ REF IndexInfoBody;
IndexInfoBody: TYPE ~ RECORD [
key: ATOM,
fileName: ROPE
];

wfis: SymTab.Ref;

FileExists: PROC[name: Rope.ROPE] RETURNS [exists: BOOL¬TRUE] ~ {
gotName: BOOL¬FALSE;
[] ¬ PFS.FileInfo[name: PFS.PathFromRope[name]!
PFS.Error => IF error.group=$user AND error.code=$unknownFile THEN {
exists¬FALSE; CONTINUE}];
};

GetTwiddleFile: PROC[name: Rope.ROPE]
RETURNS [baseExists: BOOL¬TRUE, twiddleName: Rope.ROPE] ~ {
IF ~FileExists[name] THEN RETURN[FALSE, NIL];
twiddleName ¬ name;
WHILE TRUE DO
twiddleName ¬ twiddleName.Concat["~"];
IF ~FileExists[twiddleName] THEN RETURN;
ENDLOOP;
};

FindTemp: Commander.CommandProc ~ {
baseExists: BOOL;
res: Rope.ROPE;
base: Rope.ROPE;
[baseExists, res] ¬ GetTwiddleFile[CommanderOps.NextArgument[cmd]];
IF baseExists THEN {
result ¬ res;
IO.PutRope[cmd.out, res];
}
ELSE {
result ¬ $Failure;
msg ¬ "No such file"
}
};

Wait: Commander.CommandProc ~ {
[] ¬ WalnutOps.ValidOpsHandle[NIL];
};

CloseAll: Commander.CommandProc ~ {
hl: LIST OF WalnutWindow.WalnutHandle ¬ WalnutWindow.GetHandleList[];
FOR l: LIST OF WalnutWindow.WalnutHandle ¬ hl, l.rest WHILE l#NIL DO
WalnutWindow.Shutdown[l.first];
ENDLOOP;
};

DirectoryOf: Commander.CommandProc ~ {
fileName: Rope.ROPE ¬ CommanderOps.NextArgument[cmd];
filePath: PFS.PATH ¬ PFS.FileInfo[PFS.PathFromRope[fileName]].fullFName;
IO.PutRope[cmd.out, PFS.RopeFromPath[PFSNames.Directory[filePath]]];
};

DirectoryIfGiven: Commander.CommandProc ~ {
fileName: Rope.ROPE ¬ CommanderOps.NextArgument[cmd];
filePath: PFS.PATH ¬ PFS.PathFromRope[fileName];
fileName ¬ PFS.RopeFromPath[PFSNames.Directory[filePath]];
IF fileName = NIL OR fileName.Length[] = 0 THEN fileName ¬ "./"; 
IO.PutRope[cmd.out, fileName];
};

DefaultDirectory: Commander.CommandProc ~ {
fileName: Rope.ROPE ¬ CommanderOps.NextArgument[cmd];
filePath: PFS.PATH;
defaultDirectory: Rope.ROPE ¬ CommanderOps.NextArgument[cmd];
IF fileName=NIL OR defaultDirectory=NIL THEN
RETURN[$Failure, "Usage: DefaultDirectory <fileName> <defaultDirectory>"];
filePath ¬ PFS.PathFromRope[fileName];
fileName ¬ PFS.RopeFromPath[PFSNames.Directory[filePath]];
IF fileName = NIL OR fileName.Length[] = 0 THEN fileName ¬ defaultDirectory; 
IO.PutRope[cmd.out, fileName];
};

ShortNameOf: Commander.CommandProc ~ {
filePath: PFS.PATH ¬ PFS.PathFromRope[CommanderOps.NextArgument[cmd]];
shortName: Rope.ROPE ¬ PFSNames.ComponentRope[PFSNames.ShortName[filePath]];
IO.PutRope[cmd.out, shortName];
};

DefaultExtension: Commander.CommandProc ~ {
fileName: Rope.ROPE ¬ CommanderOps.NextArgument[cmd];
defaultExtension: Rope.ROPE ¬ CommanderOps.NextArgument[cmd];
index: INT;
IF fileName=NIL OR defaultExtension=NIL THEN
RETURN[$Failure, "Usage: DefaultExtension <fileName> <defaultExtension>"];
index ¬ Rope.Find[fileName, "."];
IF index=-1 THEN fileName ¬ IO.PutFR["%g.%g", rope[fileName], rope[defaultExtension]]
ELSE IF index=fileName.Length[]-1 THEN fileName ¬ fileName.Concat[defaultExtension]; 
IO.PutRope[cmd.out, fileName];
};

BaseName: Commander.CommandProc ~ {
index: INT;
shortName: Rope.ROPE;
filePath: PFS.PATH;
fileName: Rope.ROPE ¬ CommanderOps.NextArgument[cmd];
IF fileName=NIL THEN
RETURN[$Failure, "Usage: BaseName <fileName>"];
filePath ¬ PFS.PathFromRope[fileName];
shortName ¬ PFSNames.ComponentRope[PFSNames.ShortName[filePath]];
index ¬ Rope.Find[shortName, "."];
IF index#-1 THEN shortName ¬ shortName.Substr[len: index];
IO.PutRope[cmd.out, shortName];
};

ScriptDefault: Commander.CommandProc ~ {
default: Rope.ROPE ¬ CommanderOps.NextArgument[cmd];
userSupplied: Rope.ROPE ¬ CommanderOps.NextArgument[cmd];
IF userSupplied=NIL OR userSupplied.Length[]=0 OR userSupplied.Equal["."] OR
userSupplied.Fetch[0] = '$ THEN userSupplied ¬ default;
IO.PutRope[cmd.out, userSupplied];
};

MakeEmptyLBLog: Commander.CommandProc ~ {
fileName: Rope.ROPE ¬ CommanderOps.NextArgument[cmd];
s: IO.STREAM;
IF fileName=NIL THEN
RETURN[$Failure, "Usage: MakeEmptyLBLog <fileName>"];
s ¬ PFS.StreamOpen[PFS.PathFromRope[fileName], $create];
s.PutChar['\377];
s.Close[];
};

WalnutFile: Commander.CommandProc ~ TRUSTED {
spec: Rope.ROPE;
resultFile: Rope.ROPE;
rootRqst: BOOL;
wfi: WalnutFileInfo;
rootFileName: Rope.ROPE ¬ CommanderOps.NextArgument[cmd];
IF rootFileName.Equal["."] OR rootFileName=NIL THEN
rootFileName ¬ UserProfile.Token["Walnut.WalnutRootFile"];
IF rootFileName=NIL THEN { result¬$Failure; msg ¬ "no root file name"; RETURN; };
spec ¬ CommanderOps.NextArgument[cmd];
IF spec=NIL THEN spec ¬ "rootFile";
rootRqst ¬ spec.Equal["rootFile", FALSE];
IF spec.Equal["clear", FALSE] THEN {
IF wfis#NIL THEN SymTab.Erase[wfis]; msg ¬ "Walnut Info Cleared"; RETURN; };
IF ~rootRqst THEN wfi ¬ GetWFI[rootFileName];
IF ~rootRqst AND wfi=NIL THEN {
result ¬ $Failure; msg ¬ "Walnut db file information not available; check root file and ancillary LoganBerry databases."; RETURN; };
SELECT TRUE FROM
rootRqst => resultFile ¬ rootFileName;
spec.Equal["lblog", FALSE]=> resultFile ¬ wfi.lbLogFileName;
spec.Equal["db", FALSE]=> resultFile ¬ wfi.dbName;
spec.Equal["log", FALSE]=> resultFile ¬ wfi.logFileName;
spec.Equal["index", FALSE]=> {
indexKey: ATOM ¬ Atom.MakeAtom[CommanderOps.NextArgument[cmd]];
IF indexKey=NIL THEN { result ¬ $Failure; msg ¬ usage; };
FOR iList: LIST OF IndexInfo ¬ wfi.indexNames, iList.rest WHILE iList#NIL DO
IF iList.first.key#indexKey THEN LOOP;
resultFile ¬ iList.first.fileName;
EXIT;
ENDLOOP;
};
ENDCASE => { result ¬ $Failure; msg ¬ usage; };
IF resultFile=NIL THEN { result ¬ $Failure; RETURN; };
IO.PutRope[cmd.out, resultFile];
};

GetWFI: PROC[rootFileName: ROPE] RETURNS [wfi: WalnutFileInfo] ~ TRUSTED {
s: IO.STREAM;
IF wfis=NIL THEN wfis ¬ SymTab.Create[case: TRUE];
wfi ¬ NARROW[SymTab.Fetch[wfis, rootFileName].val];
IF wfi#NIL THEN RETURN;
wfi ¬ NEW[WalnutFileInfoBody];
wfi.rootFileName ¬ rootFileName;
s ¬ PFS.StreamOpen[PFS.PathFromRope[rootFileName]];
WHILE ~s.EndOf[] DO
lineBuf: REF TEXT;
key: ROPE;
lineBuf ¬ s.GetLine[lineBuf];
key ¬ LOOPHOLE[lineBuf];
SELECT TRUE FROM
key.Equal["Database", FALSE] => {
db: LoganBerry.OpenDB ¬ LoganBerry.nullDB;
si: LoganBerry.SchemaInfo;
wfi.dbName ¬ s.GetLineRope[];
db ¬ LoganBerry.Open[dbName: wfi.dbName!LoganBerry.Error => CONTINUE];
IF db#LoganBerry.nullDB THEN {
si ¬ LoganBerry.Describe[db: db];
wfi.lbLogFileName ¬ si.logs.first.file;
FOR ii: LIST OF LoganBerry.IndexInfo ¬ si.indices, ii.rest WHILE ii#NIL DO
iInfo: IndexInfo ¬ NEW[IndexInfoBody ¬ [ii.first.key, ii.first.file]];
wfi.indexNames ¬ CONS[iInfo, wfi.indexNames];
ENDLOOP;
};
};
key.Equal["LogInfo", FALSE] => {
logFileName: ROPE ¬ s.GetLineRope[];
lineBuf ¬ s.GetLine[lineBuf];
lineBuf ¬ s.GetLine[lineBuf];
key ¬ LOOPHOLE[lineBuf];
IF key.Fetch[0] = '0 THEN wfi.logFileName ¬ logFileName;
};
ENDCASE;
ENDLOOP; 
IF wfi.dbName=NIL OR wfi.logFileName=NIL THEN RETURN[NIL];
[] ¬ wfis.Store[rootFileName, wfi];
};

StartWalnutReadOnly: Commander.CommandProc ~ {
rootFileName: Rope.ROPE ¬ CommanderOps.NextArgument[cmd];
[]¬WalnutWindow.StartUp[rootFileName, TRUE];
};

IFFailed: Commander.CommandProc ~ {
result ¬ CommanderOps.GetProp[cmd, $Result];
IF result = $Failure THEN result ¬ NIL ELSE result ¬ $Failure;
};


usage: Rope.ROPE ¬ "Usage: WalnutFile <spec>
etc. etc. etc.";

Commander.Register["Waitt", Wait, "Wait for scavenge or whatever to finish."];
Commander.Register["CloseAll", CloseAll, "Close all Walnut windows."];
Commander.Register["FindTemp", FindTemp, "Find unused temp file name by appending ~'s to base file name."];
Commander.Register["MakeEmptyLBLog", MakeEmptyLBLog, "Create empty log file (with valid termination character in it)
Usage: MakeEmptyLBLog <filename>"];
Commander.Register["WalnutFile", WalnutFile, "Obtain specified Walnut implementation file
Usage: WalnutFile <spec>
etc. etc. etc."];

Commander.Register["BaseName", BaseName, "/a/b/c/d/e/f.g => f"];
Commander.Register["DefaultExtension", DefaultExtension, "Produce file name given file name and default extension, using default extension if none was supplied."];
Commander.Register["DefaultDirectory", DefaultDirectory, "Produce directory name given file name and default directory, using default directory if none was supplied."];
Commander.Register["DirectoryOf", DirectoryOf, "Produce prefix given path name"];
Commander.Register["DirectoryIfGiven", DirectoryIfGiven, "Produce prefix, if any, given path name"];
Commander.Register["ShortNameOf", ShortNameOf, "Produce short file name given path name"];
Commander.Register["ScriptDefault", ScriptDefault, "ScriptDefault <default> <supplied>; provide the <default> value if the user-<supplied> value is in one way or another null"];
Commander.Register["IFFailed", IFFailed, "Fail iff previous command did not."];
}.

Τ
WalnutUtilsImpl.mesa
Copyright Σ 1991, 1992 by Xerox Corporation.  All rights reserved.
Swinehar, November 10, 1991 2:51 pm PST
resultFile _ PFS.RopeFromPath[PFS.FileInfo[PFS.PathFromRope[resultFile]].fullFName];
Doesn't work at the moment because the TRUE argument to StartUp is ignored!
Commander.Register["WalnutRO", StartWalnutReadOnly, "Start Walnut Read Only."];
Generic functions.  Should not be part of Walnut.

Null values: NIL, "", ".", "$anything".
Κ
ˆ–
(cedarcode) style•NewlineDelimiter

™™Jšœ
Οe
œ7™BJ™'—Icode˜š
Οk	˜	Kšœžœ˜Kšœ
žœ˜*Kšœ
žœ˜-Kšžœ
˜KšœžœK˜[Kšœžœ'žœ˜@Kšžœ
žœžœ5˜XKšœ	žœ)˜7Kšœžœ&˜2Kšœžœ˜Kšœ
žœ˜#Kšœ
žœ3˜EK˜
K˜—šΟnœžœ
žœ
žœ žœžœ<˜›
Kšžœ
žœ
˜K˜Kšžœžœžœ
˜K˜Kšœžœžœ˜.šœžœžœ˜#Kšœžœ
˜Kšœ
žœ
˜Kšœžœ
˜
Kšœžœ
˜Kšœžœ
žœ
˜K˜—K˜Kšœžœžœ˜$šœžœžœ˜Kšœžœ
˜
Kšœ
ž˜K˜K˜—K˜K˜šŸ
œžœžœžœ
žœ
žœ˜AKšœ	žœ
žœ
˜šœžœžœ˜/š	žœ
žœžœžœ
ž
˜DKšœžœ
ž	œ˜——K˜K˜—šŸœžœžœ
˜%Kšžœžœ
žœžœ˜;Kš
žœžœ
žœ
žœžœ˜-K˜šžœ
žœ
ž˜
K˜&Kšžœžœ
žœ
˜(Kšžœ
˜—K˜K˜—šŸœ˜#Kšœžœ
˜Kšœ
ž˜Kšœžœ
˜K˜Cšžœžœ˜K˜
Kšžœ˜K˜
—šžœ˜K˜K˜K˜
—K˜K˜—šŸœ˜Kšœžœ˜#K˜K˜—šŸœ˜#Kšœžœ
žœ:˜Ešžœžœ
žœ(žœžœ
ž˜DK˜Kšžœ
˜—K˜K˜—šŸœ˜&Kšœžœ"˜5Kš	œ
žœ
žœžœ
žœ#˜HKšžœžœ-˜DK˜K˜—šŸœ˜+Kšœžœ"˜5Kšœ
žœ
žœžœ˜0Kšœžœ,˜:Kšžœžœ
žœžœ˜AKšžœ˜K˜K˜—šŸœ˜+Kšœžœ"˜5Kšœ
žœ
žœ
˜Kšœžœ
ž
œ˜=š	žœ
žœ
žœžœ
ž˜,KšžœD˜J—Kšœžœ˜&Kšœžœ,˜:Kšžœžœ
žœžœ˜MKšžœ˜K˜K˜—šŸœ˜&Kšœ
žœ
žœžœ.˜FKšœžœ8˜LKšžœ˜K˜K˜—šŸœ˜+Kšœžœ"˜5Kšœžœ"˜=Kšœžœ
˜š	žœ
žœ
žœžœ
ž˜,KšžœD˜J—K˜!Kšžœ
žœžœ7˜UKšžœ
žœžœ/˜UKšžœ˜K˜K˜—šŸœ˜#Kšœžœ
˜Kšœžœ
˜Kšœ
žœ
žœ
˜Kšœžœ"˜5šžœ
žœ
ž˜Kšžœ)˜/—Kšœžœ˜&K˜AK˜"Kšžœ
žœ*˜:Kšžœ˜K˜K˜—šŸ
œ˜(Kšœžœ"˜4Kšœžœ"˜9˜LK˜7—Kšžœ ˜"K˜K˜—šŸœ˜)Kšœžœ"˜5Kšœžœ
žœ
˜
šžœ
žœ
ž˜Kšžœ/˜5—Kšœžœžœ"˜8K˜K˜
K˜K˜—šŸ
œžœ˜-Kšœžœ
˜Kšœžœ
˜Kšœ
žœ
˜K˜Kšœžœ"˜9šžœžœžœ
ž˜3K˜:—Kšžœžœ
žœ/žœ˜QK˜&Kšžœžœ
žœ˜#Kšœ"žœ˜)šžœžœžœ˜$Kšžœžœ
žœ2žœ˜L—Kšžœžœ˜-šžœžœžœ
žœ˜Kšœzžœ˜„
—šžœ
žœ
ž˜K˜&Kšœžœ#˜<Kšœžœ˜2Kšœžœ!˜8šœžœ˜Kšœ
žœ1˜?Kšžœ
žœ
žœ%˜9šžœžœ
žœ(žœžœ
ž˜LKšžœžœ
žœ
˜&K˜"Kšžœ
˜Kšžœ
˜—K˜—Kšžœ(˜/—Kšžœžœ
žœžœ˜6Jšœ
žœžœ
žœ&™TKšžœ˜ K˜K˜—š
Ÿœžœžœžœžœ˜JKšœžœ
žœ
˜
Kšžœžœ
žœžœ˜2Kšœžœ'˜3Kšžœžœ
žœ
žœ
˜Kšœžœ˜K˜ Kšœžœžœ˜3šžœž˜Kšœ	žœ
žœ
˜Kšœžœ
˜
Kšœ
ž
œ˜Kšœžœ
˜šžœ
žœ
ž˜šœžœ˜!K˜*K˜K˜Kšœ<žœ˜Fšžœžœ˜K˜!K˜'šžœžœ
žœ,žœžœ
ž˜JKšœžœ0˜FKšœžœ˜-Kšžœ
˜—K˜—K˜—šœžœ˜ Kšœ
žœ˜$K˜K˜Kšœžœ
˜Kšžœžœ˜8K˜—Kšžœ
˜—Kšžœ˜	—Kšžœžœ
žœžœ
žœ
žœ
žœ˜:K˜#K˜K˜—šŸœ˜.J™KKšœžœ"˜9Kšœ&žœ˜,K˜K˜—šŸœ˜#K˜,Kšžœžœ
žœ
žœ˜>K˜K˜—K˜Kšœžœ-˜=K˜K˜NK˜FJš
œO™OK˜kKš
œ˜
˜˜
Kš
œ„
˜„
K˜J™1J™K˜@K˜£
K˜¨
K˜QK˜dK˜ZK˜±
J™'Kš
œO˜O—K˜—…—%β2>