DIRECTORY
Arpa,
Ascii,
Basics,
Basics16,
BasicTime USING [GetClockPulses, GMT, Now, nullGMT, Pack, Period, TimeNotKnown, Update],
Convert,
CStrings USING [CString],
HostTime,
IO,
PFS,
PFSBackdoor,
PFSClass,
PFSNames,
RefText USING [ObtainScratch, ReleaseScratch],
Rope USING [Compare, Cat, Concat, Equal, Fetch, Find, FindBackward, Flatten, FromChar, FromRefText, Index, IsEmpty, IsPrefix, Length, Match, ROPE, Substr],
UnixErrno,
UnixFSPrivate USING [ReportFailure, TranslateErrno],
UnixSysCalls,
UnixSysCallExtensions USING [SetGetBlocking, SetPutBlocking],
UXStrings,
UnixTypes USING [AccModTimes, FD, FileFlags, Fmt, Mode, RES, Stat, Time, TimeVal],
VUXFiles
;

VUXFileImpl: CEDAR MONITOR LOCKS lock.lock USING lock: REF VUXData
IMPORTS Arpa, Ascii, Basics, Basics16, BasicTime, Convert, HostTime, IO, PFS, PFSBackdoor, PFSClass, PFSNames, RefText, Rope, UnixErrno, UnixFSPrivate, UnixSysCalls, UnixSysCallExtensions, UXStrings, VUXFiles
EXPORTS PFS, VUXFiles
~ {
OpenFileObject: PUBLIC TYPE ~ PFSClass.OpenFileObject; -- necessary to establish a type identity for the compiler

FHandle: TYPE ~ VUXFiles.FHandle;
GMT: TYPE ~ BasicTime.GMT;
DirHandle: TYPE ~ VUXFiles.DirHandle;
ROPE: TYPE ~ Rope.ROPE;
Mode: TYPE ~ UnixTypes.Mode;
Version: TYPE ~ PFSNames.Version;
Component: TYPE ~ PFSNames.Component;
PATH: TYPE ~ PFSNames.PATH;
FileType: TYPE ~ PFS.FileType;
UniqueID: TYPE ~ PFS.UniqueID;
MTime: TYPE ~ INT;
RES: TYPE ~ UnixTypes.RES;
FSHandle: TYPE ~ PFSClass.FSHandle;
CString: TYPE ~ CStrings.CString;
unixEpoch: GMT ฌ BasicTime.Pack[
[year~1970, month~January, day~1, hour~0, minute~0, second~0, zone~0, dst~no]
];
defaultCreateMode: Mode ฌ [fmt~reg, owner~[true, true, false]];
defaultCaseFileMode: Mode ฌ [fmt~reg, owner~[true, false, false], group~[true, false, false], others~[true, false, false]];
lockRetries: CARDINAL ฌ 10;
bufferBytes: CARDINAL ฌ 8192;
vuxFlavor: ATOM ~ $VUX;
LookupSimple: PROC [dH: DirHandle, nameOnServer: ROPE]
RETURNS [fH: FHandle, fmt: UnixTypes.Fmt, bytes: INT, mTime: MTime, attachedTo: PATH ฌ NIL]
~ {

reply: VUXFiles.DirOpRes; 
[reply, attachedTo] ฌ VUXFiles.Lookup[dH, nameOnServer];
SELECT reply.status FROM
ok => {
fH ฌ reply.file;
fmt ฌ reply.attributes.mode.fmt;
bytes ฌ LOOPHOLE[reply.attributes.size];
mTime ฌ reply.attributes.mtime;
};
ENOENT => {
fH ฌ NIL;
fmt ฌ reg;
bytes ฌ 0;
mTime ฌ 0;
};
ENDCASE => PFSBackdoor.ProduceError[UnixFSPrivate.TranslateErrno[reply.status], IO.PutFR1["Unix error in VUXFileImpl.LookupSimple for %g", [rope[nameOnServer]] ], NEW[UnixErrno.Errno ฌ reply.status]];
};

ux0Component: Component ~ PFSNames.Fetch[PFS.PathFromRope["-ux:/"], 0];
ResolveAttachment: PROC [attachment: PATH, attachedTo: PATH] RETURNS [PATH] ~ {
{
absolute: PATH ~ IF PFSNames.IsAbsolute[attachedTo] THEN attachedTo ELSE PFSNames.Cat[PFSNames.Directory[attachment], attachedTo];
RETURN[ PFSNames.ReplaceComponent[absolute, 0, ux0Component] ];
};
};

LookupVersionByMTime: PROC [dH: DirHandle, base: ROPE, wantedMTime: MTime]
RETURNS [fH: FHandle, nameOnServer: ROPE, version: Version, fmt: UnixTypes.Fmt ฌ reg, bytes: INT ฌ 0, attachedTo: PATH]
~ {

found: BOOL ฌ FALSE;
EachDirEntry: VUXFiles.EachDirEntryProc -- [entry: DirEntry] RETURNS [continue: BOOL ฌ TRUE] -- ~ {
version ฌ entry.version;
SELECT Rope.Compare[entry.nameWithoutVersion, base, FALSE] FROM
less => RETURN[TRUE]; -- must be the case file
equal => IF (entry.version # [none]) THEN {
mTime: MTime;
nameOnServer ฌ EncodeVersionInName[entry.nameWithoutVersion, entry.version.version];
[fH~fH, fmt~fmt, bytes~bytes, mTime~mTime, attachedTo~attachedTo] ฌ
LookupSimple[dH, nameOnServer];
IF (fH # NIL) AND (mTime = wantedMTime) THEN {
found ฌ TRUE;
RETURN[FALSE];
};
};
greater => {
RETURN[FALSE];
};
ENDCASE => ERROR; -- implementation error; invariants violated
};
VUXFiles.EnumerateDirectory[dH, EachDirEntry, base, FALSE];
IF NOT found THEN RETURN [NIL, base, [none], reg, 0, NIL];
};

FindHighestVersion: PROC [dH:DirHandle, base: ROPE, staleOK: BOOL]
RETURNS [highestVersion: Version ฌ [none], nameOnServer: ROPE, found: BOOL ฌ FALSE] ~ {
highestVersionNo: INT ฌ 0;
foundCased: BOOL ฌ FALSE;
foundUncased: BOOL ฌ FALSE;
EachDirEntry: VUXFiles.EachDirEntryProc -- [entry: DirEntry] RETURNS [continue: BOOL ฌ TRUE] -- ~ {
SELECT Rope.Compare[entry.nameWithoutVersion, base, FALSE] FROM
less => RETURN[TRUE]; -- must be the case file
equal => IF (entry.version # [none]) THEN {
temp: INT ~ entry.version.version; -- for coercion between Version and INT
IF temp > highestVersionNo THEN {
foundCased ฌ TRUE;
highestVersionNo ฌ temp;
}
}
ELSE 
foundUncased ฌ TRUE;
greater => RETURN[FALSE];
ENDCASE ; 
};
VUXFiles.EnumerateDirectory[dH, EachDirEntry, base, staleOK];
IF foundCased THEN {
nameOnServer ฌ EncodeVersionInName[base, highestVersionNo];
highestVersion ฌ [numeric, highestVersionNo];
found ฌ TRUE;
}
ELSE IF foundUncased THEN {
nameOnServer ฌ base;
found ฌ TRUE;
};
};

FindLowestVersion: PROC [dH: DirHandle, base: ROPE, staleOK: BOOL]
RETURNS [lowestVersion: Version ฌ [none], nameOnServer: ROPE, found: BOOL ฌ FALSE] ~ {
lowestVersionNo: INT ฌ INT.LAST;
foundCased: BOOL ฌ FALSE;
foundUncased: BOOL ฌ FALSE;
EachDirEntry: VUXFiles.EachDirEntryProc -- [entry: DirEntry] RETURNS [continue: BOOL ฌ TRUE] -- ~ {
SELECT Rope.Compare[entry.nameWithoutVersion, base, FALSE] FROM
less => RETURN[TRUE]; -- must be the case file
equal => IF (entry.version # [none]) THEN {
temp: INT ~ entry.version.version; -- for coercion between Version and INT
IF( temp > 0) AND (temp < lowestVersionNo) THEN {
foundCased ฌ TRUE;
lowestVersionNo ฌ temp;
}
}
ELSE 
foundUncased ฌ TRUE;
greater => RETURN[FALSE];
ENDCASE; 
};
VUXFiles.EnumerateDirectory[dH, EachDirEntry, base, staleOK];
IF foundCased THEN {
nameOnServer ฌ EncodeVersionInName[base, lowestVersionNo];
lowestVersion ฌ [numeric, lowestVersionNo];
found ฌ TRUE;
}
ELSE IF foundUncased THEN {
nameOnServer ฌ base;
found ฌ TRUE;
};
};

FindExistingFile: PROC [name: PATH, wantedUniqueID: UniqueID] RETURNS [dH: DirHandle, fH: FHandle, nameOnServer: ROPE, version: Version, fmt: UnixTypes.Fmt, bytes: INT, uniqueID: UniqueID, attachedTo: PATH] ~ {
base: ROPE;
{
ENABLE UNWIND => {
IF dH # NIL THEN VUXFiles.UnPinDirPath[dH];
};
isPattern: BOOL;
found: BOOL;
mTime: MTime;

dH ฌ VUXFiles.FollowDirPath[path~PFSNames.Parent[name], case~FALSE, create~FALSE];
[base~base, version~version, isPattern~isPattern] ฌ ReadBaseComponent[path~name, case~FALSE];
IF isPattern THEN PFSBackdoor.ProduceError[patternNotAllowed, IO.PutFR1["Pattern (%g) not allowed in VUXFileImpl.FindExistingFile", [rope[PFS.RopeFromPath[name]]] ], name];
SELECT version.versionKind FROM
none, highest => {
[version, nameOnServer, found] ฌ FindHighestVersion[dH, base, FALSE];
IF NOT found THEN GOTO Out;
};
lowest => {
[version, nameOnServer, found] ฌ FindLowestVersion[dH, base, FALSE];
IF NOT found THEN GOTO Out;
};
all => {
IF (wantedUniqueID = PFS.nullUniqueID) THEN ProduceError[patternNotAllowed,
"Version * not allowed in VUXFileImpl.FindExistingFile", name]; 
found ฌ FALSE;
};
numeric => {
nameOnServer ฌ EncodeVersionInName[base, version.version];
found ฌ TRUE;
};
ENDCASE => ERROR -- can't happen -- ;
IF found THEN [fH, fmt, bytes, mTime, attachedTo] ฌ LookupSimple[dH, nameOnServer];
uniqueID ฌ [egmt~[gmt~GMTFromMTime[mTime], usecs~0]];
IF (wantedUniqueID = PFS.nullUniqueID) THEN GOTO Out;
IF (fH = NIL) OR ((wantedUniqueID # PFS.nullUniqueID) AND (wantedUniqueID # uniqueID)) 
THEN [fH, nameOnServer, version, fmt, bytes, attachedTo] ฌ LookupVersionByMTime[dH, base, MTimeFromGMT[wantedUniqueID.egmt.gmt]];
IF attachedTo # NIL THEN attachedTo ฌ ResolveAttachment[name, attachedTo];
uniqueID ฌ wantedUniqueID; -- okay even if lookup failed
EXITS
Out => NULL;
};
VUXFiles.UnPinDirPath[dH];
IF fH = NIL THEN {
PFSBackdoor.ProduceError[unknownFile,
IO.PutFR1["%g not found in VUXFileImpl.FindExistingFile", [rope[PFS.RopeFromPath[name]]] ],
name];
};
};

AtomicallyRename: PROC [dHFrom: DirHandle, fHFrom: FHandle, dHTo: DirHandle, baseTo: ROPE, desiredVersion: Version, deleteIfError: BOOL, attach: BOOL ฌ FALSE]
RETURNS [version: Version] ~ {
toNameOnServer: ROPE;
toNameRefText: REF TEXT;
{
ENABLE UNWIND => {
IF deleteIfError THEN SilentlyRemove[dHFrom, fHFrom];
};
SELECT desiredVersion.versionKind FROM
lowest => PFSBackdoor.ProduceError[versionSpecified, IO.PutFR1["Lowest is not a valid version number for a new file (%g)", [rope[baseTo]] ], baseTo];
next, highest, none => {
found: BOOL;
vTemp: CARDINAL;
res: RES;
[highestVersion~version, found~found] ฌ FindHighestVersion[dH~dHTo, base~baseTo, staleOK~TRUE];
FOR try: CARDINAL ฌ 0, try+1 DO
IF try > lockRetries THEN ERROR; -- ??? PFSBackdoor.ReportFSError[lockConflict, sH, baseTo, "Too many retries on create."];
IF (vTemp ฌ version.version) >= (CARDINAL.LAST - 1) THEN ProduceError[noMoreVersions, "No more versions", baseTo];
version ฌ [numeric, vTemp+1];
toNameOnServer ฌ Rope.Cat[dHTo.fHandle, "/", EncodeVersionInName[baseTo, version.version]];
{
from: CString ~ UXO[fHFrom];
to: CString ~ UXO[toNameOnServer];
IF attach 
THEN res ฌ UnixSysCalls.SymLink[from, to] 
ELSE res ฌ UnixSysCalls.Link[from, to];
UXR[from]; UXR[to];
};
IF res # success THEN {
errno: UnixErrno.Errno ฌ UnixErrno.GetErrno[];
IF errno= EEXIST THEN LOOP ELSE ReportFailure["AtomicallyRename", "Couldn't link next version", toNameOnServer, errno];
};
dHTo.contentKnownStale ฌ TRUE;
EXIT;
ENDLOOP;
IF NOT attach THEN {
from: CString ~ UXO[fHFrom];
res ฌ UnixSysCalls.Unlink[from];
UXR[from];
};
IF res # success THEN {
errno: UnixErrno.Errno ~ UnixErrno.GetErrno[]; 
ReportFailure["AtomicallyRename", "Couldn't unlink file from temporary name", fHFrom, errno];
};
dHFrom.contentKnownStale ฌ TRUE;
};
numeric => {
err: UnixErrno.Errno ฌ ok;
res: RES;
version ฌ desiredVersion;
toNameOnServer ฌ Rope.Cat[dHTo.fHandle, "/", EncodeVersionInName[baseTo, version.version]];
{
from: CString ~ UXO[fHFrom];
to: CString ~ UXO[toNameOnServer];
IF attach 
THEN res ฌ UnixSysCalls.SymLink[from, to] 
ELSE res ฌ UnixSysCalls.Link[from, to];
UXR[from]; UXR[to];
};
IF res#success THEN {
err ฌ UnixErrno.GetErrno[];
IF err= EEXIST THEN ReportFailure["AtomicallyRename", "Couldn't create requested version of file", toNameOnServer, err];
};
IF NOT attach THEN {
from: CString ~ UXO[fHFrom];
res ฌ UnixSysCalls.Unlink[from];
UXR[from];
};
dHFrom.contentKnownStale ฌ dHTo.contentKnownStale ฌ TRUE;
};
ENDCASE => ERROR; -- Can't happen
};
};

SilentlyRemove: PROC [dH: DirHandle, base: ROPE] ~ {
from: CString ~ UXO[Rope.Cat[dH.fHandle, "/", base]];
[] ฌ UnixSysCalls.Unlink[from];
UXR[from];
dH.contentKnownStale ฌ TRUE;
};

tempNamePrefix: ROPE ฌ NIL;

CreateTempName: PROC [base: ROPE] RETURNS [tempName: ROPE] ~ {
u1, u2: CARD;
IF tempNamePrefix = NIL THEN {
a: Arpa.Address ~ Arpa.MyAddress[];
tempNamePrefix ฌ IO.PutFLR["fs.%g.%g.%g.%g", LIST[[cardinal[a.a]], [cardinal[a.b]], [cardinal[a.c]], [cardinal[a.d]]]];
};
u1 ฌ u2 ฌ BasicTime.GetClockPulses[];
u1 ฌ LOOPHOLE[BasicTime.Now[! BasicTime.TimeNotKnown => CONTINUE]];
tempName ฌ IO.PutFR["%g.%g.%g", [rope[tempNamePrefix]], [cardinal[u1]], [cardinal[u2]] ];
};

caseFileNamePrefix: PUBLIC ROPE ฌ ".~case~";
caseFileNamePrefixLen: PUBLIC INT ฌ Rope.Length[caseFileNamePrefix];

CreateCaseFile: PUBLIC PROC [dh: DirHandle, name: ROPE] ~ {
caseFileName: ROPE ฌ Rope.Concat[caseFileNamePrefix, name];
file: CString ~ UXO[Rope.Cat[dh.fHandle, "/", caseFileName]];
fd: UnixTypes.FD ~ UnixSysCalls.Open[file, magicFlags[create], defaultCaseFileMode];
UXR[file];
IF fd#error THEN [] ฌ UnixSysCalls.Close[fd];
dh.contentKnownStale ฌ TRUE;
};

CheckCaseFile: PROC [dH: DirHandle, base: ROPE] RETURNS [caseFileName: ROPE ฌ NIL] ~ {
EachDirEntry: VUXFiles.EachDirEntryProc -- [entry: DirEntry] RETURNS [continue: BOOL ฌ TRUE] -- ~ {
SELECT Rope.Compare[entry.nameWithoutVersion, base, FALSE] FROM
less => ERROR; -- invariants violated
equal => 
IF (entry.version = [numeric, 0]) THEN {
caseFileName ฌ entry.nameWithoutVersion;
RETURN[FALSE];
}
ELSE RETURN[TRUE];
greater => RETURN[FALSE];
ENDCASE;  
};
VUXFiles.EnumerateDirectory[dH, EachDirEntry, base, FALSE];
};

CollectCaseFile: PUBLIC PROC [dH: DirHandle, base: ROPE] ~ {
versionFound: BOOL ฌ FALSE;
caseFileNames: LIST OF ROPE ฌ NIL;
EachDirEntry: VUXFiles.EachDirEntryProc -- [entry: DirEntry] RETURNS [continue: BOOL ฌ TRUE] -- ~ {
SELECT Rope.Compare[entry.nameWithoutVersion, base, FALSE] FROM
less => RETURN[TRUE]; -- the case file
equal => IF (entry.version # [none]) AND (entry.version # [numeric, 0])THEN {
versionFound ฌ TRUE;
RETURN[FALSE];
};
greater => {
RETURN[FALSE];
};
ENDCASE; -- invariants violated
};
EachCaseFileEntry: VUXFiles.EachDirEntryProc -- [entry: DirEntry] RETURNS [continue: BOOL ฌ TRUE] -- ~ {
IF Rope.Equal[entry.nameWithoutVersion, base, FALSE] THEN {
IF entry.version = [numeric, 0] THEN
caseFileNames ฌ CONS[Rope.Concat[caseFileNamePrefix, entry.nameWithoutVersion], caseFileNames];
RETURN[TRUE];
};
RETURN[FALSE];
};
VUXFiles.EnumerateDirectory[dH, EachDirEntry, base, FALSE];
IF NOT versionFound THEN {
VUXFiles.EnumerateDirectory[dH, EachCaseFileEntry, base, FALSE];
FOR each: LIST OF ROPE ฌ caseFileNames, each.rest WHILE each # NIL DO
SilentlyRemove[dH, each.first];
ENDLOOP;
};
};
FSData: TYPE ~ REF FSDataObject;
FSDataObject: TYPE ~ RECORD [
fs: ROPE
];

vuxMaintenanceProcs: PFSClass.MaintenanceProcs ฌ NEW[PFSClass.MaintenanceProcsObject ฌ [
sweep: VUXSweep,
validate: VUXValidate
]];

VUXSweep: PFSClass.SweepProc ~ {
dH: DirHandle ฌ VUXFiles.GetDirRoot[];
VUXFiles.SweepDirCache[dH, seconds];
[] ฌ VUXFiles.UnPinDir[dH];
};

VUXGetHandle: PFSClass.GetHandleProc -- [fs: ROPE, flavorSpecified: BOOL] RETURNS [h: FSHandle, downMsg: ROPE] -- ~ {
IF flavorSpecified 
THEN [h, downMsg] ฌ GetHandleInner[fs, FALSE]
ELSE { h ฌ NIL; downMsg ฌ NIL };
};

VUXGetROHandle: PFSClass.GetHandleProc -- [fs: FS, flavorSpecified: BOOL] RETURNS [h: FSHandle, downMsg: ROPE ฌ NIL] -- ~ {
IF flavorSpecified 
THEN [h, downMsg] ฌ GetHandleInner[fs, TRUE]
ELSE { h ฌ NIL; downMsg ฌ NIL };
};

GetHandleInner: PROC [fs: ROPE, readOnly: BOOL] RETURNS [h: PFSClass.FSHandle, downMsg: ROPE ฌ NIL] ~ {
data: FSData ฌ NEW[FSDataObject ฌ [fs]];
IF NOT Rope.IsEmpty[fs] THEN RETURN[NIL, NIL];
h ฌ NEW[PFSClass.FSObject ฌ [flavor: vuxFlavor, name: fs, maintenanceProcs: vuxMaintenanceProcs, procs: vuxProcs, data: data]];
};

VUXValidate: PFSClass.ValidateProc -- [h: FSHandle] RETURNS [obsolete: BOOL, downMsg: ROPE] -- ~ {
data: FSData ฌ NARROW[h.data]; -- sanity check;
RETURN[ FALSE, NIL ]; -- always available
};
moduleName: ROPE ~ "VUXFileImpl.";
ReportFailure: PROC [procName: ROPE, msg: ROPE, what: REF, errno: UnixErrno.Errno] ~ {
procPrefix: ROPE ~ Rope.Cat[moduleName, procName, ": "];
filename: ROPE ฌ WITH what SELECT FROM
file: PFSClass.OpenFile => PFS.RopeFromPath[file.fullFName],
path: PATH => PFS.RopeFromPath[path],
rope: ROPE => rope,
ENDCASE => "???";
message: ROPE ~ Rope.Cat[procPrefix, msg, " for ", filename];
UnixFSPrivate.ReportFailure[errno, message];
};

ProduceError: PROC [code: PFSBackdoor.ErrorCode, explanation: Rope.ROPE, info: REF] ~ {
filename: ROPE ฌ WITH info SELECT FROM
file: PFSClass.OpenFile => PFS.RopeFromPath[file.fullFName],
path: PATH => PFS.RopeFromPath[path],
rope: ROPE => rope,
ENDCASE => "???";
message: ROPE ~ Rope.Cat[explanation, " for ", filename];
PFSBackdoor.ProduceError[code, message, info];
};

vuxProcs: PFSClass.FileManipulationProcs ฌ NEW[PFSClass.FileManipulationProcsObject ฌ [
delete: VUXDelete,
enumerateForInfo: VUXEnumerateForInfo,
enumerateForNames: VUXEnumerateForNames,
fileInfo: VUXFileInfo,
lookupName: VUXLookupName,
rename: VUXRename,
copy: VUXCopy,
setAttributes: VUXSetAttributes,
setByteCountAndUniqueID: VUXSetByteCountAndUniqueID,
setClientProperty: VUXSetClientProperty,
getClientProperty: VUXGetClientProperty,
enumerateClientProperties: VUXEnumerateClientProperties,
read: VUXRead,
write: VUXWrite,
open: VUXOpen,
close: VUXClose,
store: VUXStore,
retrieve: VUXRetrieve,
attach: VUXAttach,
getInfo: VUXGetInfo,
pfsNameToUnixName: VUXPFSNameToUnixName,
caseSensitive: VUXCaseSensitive
]];

VUXDelete: PUBLIC PFSClass.DeleteProc -- [h: FSHandle, file: NAME, wantedUniqueID: UniqueID, proc: PFS.NameConfirmProc] -- ~ {
dH: DirHandle;
version: Version;
nameOnServer: ROPE;
uniqueID: UniqueID;
[dH~dH, nameOnServer~nameOnServer, version~version, uniqueID~uniqueID] ฌ FindExistingFile[file, wantedUniqueID];
IF (proc = NIL) OR proc[PFSNames.SetVersionNumber[file, version], uniqueID] THEN {
ENABLE UNWIND => {
VUXFiles.UnPinDirPath[dH];
};
unixFile: ROPE ~ Rope.Cat[dH.fHandle, "/", nameOnServer];
fileString: CString ~ UXO[unixFile];
res: RES ~ UnixSysCalls.Unlink[fileString];
UXR[fileString];
IF res#success THEN {
errno: UnixErrno.Errno ~ UnixErrno.GetErrno[];
ReportFailure["VUXDelete", "Delete Failed", unixFile, errno];
};
dH.contentKnownStale ฌ TRUE;
CollectCaseFile[dH, DecodeVersionFromName[nameOnServer].nameWithoutVersion];
};
};

VUXFileInfo: PUBLIC PFSClass.FileInfoProc -- [h: FSHandle, file: PATH, wantedUniqueID: UniqueID] RETURNS [version: Version, attachedTo: PATH, bytes: INT, uniqueID: UniqueID, mutability: PFS.Mutability, fileType: PFS.FileType] -- ~ {
dH: DirHandle;
fH: ROPE;
fmt: UnixTypes.Fmt;
shortNameComp: PFSNames.Component;
[dH~dH, fH~fH, version~version, bytes~bytes, uniqueID~uniqueID, fmt~fmt, attachedTo~attachedTo] ฌ
FindExistingFile[file, wantedUniqueID];
mutability ฌ mutable;
fileType ฌ PFSFileTypeFromUnixFmt[fmt];
VUXFiles.UnPinDirPath[dH];
};

VUXGetInfo: PFSClass.GetInfoProc -- [h: FSHandle, file: OpenFile] RETURNS [fullFName, attachedTo: PATH, uniqueID: UniqueID, bytes: INT, mutability: PFS.Mutability, fileType: PFS.FileType] -- ~ TRUSTED {
data: REF VUXData ~ NARROW[file.data];
fd: UnixTypes.FD ฌ data.fd; 
buf: UnixTypes.Stat;
res: RES ~ UnixSysCalls.FStat[fd, @buf];
IF res # success THEN {
errno: UnixErrno.Errno ~ UnixErrno.GetErrno[];
ReportFailure["VUXGetInfo", "Stat failed", file, errno];
};
RETURN[file.fullFName, file.attachedTo, file.uniqueID, buf.size, file.mutability, file.fileType];
};

VUXRename: PUBLIC PFSClass.RenameProc -- [h: FSHandle, fromFile: NAME, wantedUniqueID: UniqueID, toFile: NAME, keep: CARDINAL, proc: PFS.NameConfirmProc] RETURNS [done: BOOL ฌ FALSE] -- ~ {
dHFrom, dHTo: DirHandle;
{
ENABLE UNWIND => {
IF dHFrom # NIL THEN VUXFiles.UnPinDirPath[dHFrom];
IF dHTo # NIL THEN VUXFiles.UnPinDirPath[dHTo];
};
fromNameOnServer, fromNameWithoutVersion, baseTo: ROPE;
isPattern, createCaseFile: BOOL;
fHFrom: FHandle;
uniqueID: UniqueID;
version, specifiedVersion, createdVersion: Version;
[dH~dHFrom, nameOnServer~fromNameOnServer, fH~fHFrom, version~version, uniqueID~uniqueID] ฌ FindExistingFile[fromFile, wantedUniqueID];
IF (proc = NIL) OR proc[PFSNames.SetVersionNumber[fromFile, version], uniqueID] THEN {
dHTo ฌ VUXFiles.FollowDirPath[path~toFile, case~FALSE, create~TRUE];
[base~baseTo, version~specifiedVersion, isPattern~isPattern] ฌ ReadBaseComponent[path~toFile, case~FALSE];
IF isPattern THEN ProduceError[patternNotAllowed, "Pattern not allowed in VUXFileImpl.VUXRename", toFile];
SELECT version.versionKind FROM
highest, none => specifiedVersion ฌ [next];
next, numeric => NULL; 
ENDCASE => ProduceError[versionSpecified, "Illegal version specified in Rename", toFile];
createdVersion ฌ AtomicallyRename[dHFrom, fHFrom, dHTo, baseTo, specifiedVersion, FALSE ! PFS.Error => GOTO failed];
fromNameWithoutVersion ฌ DecodeVersionFromName[fromNameOnServer].nameWithoutVersion;
CollectCaseFile[dHFrom, fromNameWithoutVersion];
SELECT version.versionKind FROM
numeric => createCaseFile ฌ (CheckCaseFile[dHTo, baseTo] = NIL);
ENDCASE => createCaseFile ฌ (createdVersion = [numeric, 1]);
IF createCaseFile THEN {
[base~baseTo] ฌ ReadBaseComponent[path~toFile, case~TRUE];
CreateCaseFile[dHTo, baseTo ! PFS.Error => CONTINUE ];
};
VUXFiles.UnPinDirPath[dHTo]; dHTo ฌ NIL;
};
VUXFiles.UnPinDirPath[dHFrom]; dHFrom ฌ NIL;
RETURN[TRUE];
EXITS
failed => { VUXFiles.UnPinDirPath[dHTo]; VUXFiles.UnPinDirPath[dHFrom] }
};
};

VUXRetrieve: PUBLIC PFSClass.RetrieveProc -- [h: FSHandle, file: NAME, wantedUniqueID: UniqueID, proc: PFS.RetrieveConfirmProc, checkFileType: BOOL ฌ FALSE] -- ~ {
fH: FHandle;
bytesExpected: CARD;
str: IO.STREAM;
uniqueID: UniqueID;
fd: UnixTypes.FD;
openedVersion: Version;
buffer: REF TEXT;
attachedTo: PATH;
offset: CARD ฌ 0;

[fH~fH, version~openedVersion, bytes~bytesExpected, uniqueID~uniqueID, attachedTo~attachedTo] ฌ
FindExistingFile[file, wantedUniqueID];
str ฌ proc[PFSNames.SetVersionNumber[file, openedVersion], bytesExpected, uniqueID];
IF str = NIL THEN RETURN;
buffer ฌ RefText.ObtainScratch[MIN[bytesExpected, bufferBytes]];
{
name: CString ~ UXO[fH];
fd ฌ OpenSetBlocking[name, magicFlags[read], []];
UXR[name];
};
IF fd = error THEN {
errno: UnixErrno.Errno ~ UnixErrno.GetErrno[];
ReportFailure["Retrieve", "Open failed", fH, errno];
};
TRUSTED {
ENABLE UNWIND => {
RefText.ReleaseScratch[buffer];
};
DO
bytesRead: INT;
ptr: CString ~ LOOPHOLE[LOOPHOLE[buffer, CString] +SIZE[TEXT[0]]];
bytesRead ฌ UnixSysCalls.Read[fd, ptr, buffer.maxLength];
IF bytesRead < 0 THEN {
errno: UnixErrno.Errno ~ UnixErrno.GetErrno[];
ReportFailure["Retrieve", "Read failed", fH, errno];
};
buffer.length ฌ bytesRead;
IO.PutBlock[str, buffer];
IF buffer.length < buffer.maxLength THEN EXIT;
ENDLOOP;
};
RefText.ReleaseScratch[buffer];
};

OpenSetBlocking: PROC [path: CString, flags: UnixTypes.FileFlags, mode: UnixTypes.Mode] RETURNS [fd: UnixTypes.FD] ~ {
fd ฌ UnixSysCalls.Open[path, flags, mode];
IF fd = error THEN RETURN;
{
res: RES ~ IF flags.access = RDONLY THEN UnixSysCallExtensions.SetGetBlocking[fd, allData]
ELSE UnixSysCallExtensions.SetPutBlocking[fd, allData];
IF res # success THEN fdฌerror ;
};
};

AtomicallyCreate: PROC [file: PATH, checkFileType: BOOL ฌ FALSE, fileType: PFS.FileType ฌ PFS.tUnspecified, createOptions: PFS.CreateOptions, openFlags:  UnixTypes.FileFlags, action: PROC[UnixTypes.FD, CStrings.CString]] RETURNS [fd: UnixTypes.FD ฌ error, version: Version] ~ {
tempNameOnServer, realBase: ROPE;
tempNameString: CString;
specifiedVersion: Version;
BeginCreate: PROC  ~ {
isPattern: BOOL;
dH ฌ VUXFiles.FollowDirPath[path~file, case~FALSE, create~TRUE];
[base~realBase, version~specifiedVersion, isPattern~isPattern] ฌ ReadBaseComponent[path~file, case~FALSE];
IF isPattern THEN ProduceError[patternNotAllowed, "Pattern not allowed in VUXFileImpl.VUXStore", file];
SELECT specifiedVersion.versionKind FROM
none, highest => specifiedVersion ฌ [next];
next, numeric => NULL;
ENDCASE => ProduceError[versionSpecified, "Illegal version specified in Store", file]; 
tempNameOnServer ฌ Rope.Cat[dH.fHandle, "/", CreateTempName[realBase]];
tempNameString ฌ UXO[tempNameOnServer];
fd ฌ OpenSetBlocking[tempNameString, magicFlags[create], []];
IF fd = error THEN {
errno: UnixErrno.Errno ~ UnixErrno.GetErrno[];
ReportFailure["AtomicallyCreate", "Open failed", tempNameOnServer, errno];
};
{
desiredMode: Mode ~ VUXFiles.GetCreateMode[dH~dH, forDirectory~FALSE];
IF UnixSysCalls.FChMod[fd, desiredMode] # success THEN { 
errno: UnixErrno.Errno ~ UnixErrno.GetErrno[];
ReportFailure["AtomicallyCreate", "ChMod failed", tempNameOnServer, errno];
};
};
dH.contentKnownStale ฌ TRUE;
};

EndCreate: PROC  ~ TRUSTED {
createCaseFile: BOOL;
res: RES ฌ UnixSysCalls.FSync[fd];
errno: UnixErrno.Errno;
IF res#success AND (errno ฌ UnixErrno.GetErrno[]) # EBADF THEN {
ReportFailure["AtomicallyCreate.EndCreate", "Server full? FSync failed", file, errno];
};
version ฌ AtomicallyRename[dH, tempNameOnServer, dH, realBase, specifiedVersion, TRUE];
SELECT version.versionKind FROM
numeric => createCaseFile ฌ (CheckCaseFile[dH, realBase] = NIL);
ENDCASE => createCaseFile ฌ (version = [numeric, 1]); -- ???
IF createCaseFile THEN {
[base~realBase] ฌ ReadBaseComponent[path~file, case~TRUE];
CreateCaseFile[dH, realBase];
};
VUXFiles.UnPinDirPath[dH]; dH ฌ NIL;
};

dH: DirHandle;

TRUSTED {
ENABLE UNWIND => {
IF dH # NIL THEN VUXFiles.UnPinDirPath[dH];
};
BeginCreate[];
IF action#NIL THEN action[fd, tempNameString];
EndCreate[];
UXR[tempNameString];
};

};

VUXStore: PUBLIC PFSClass.StoreProc -- [h: FSHandle, file: NAME, wantedUniqueID: UniqueID, str: IO.STREAM, proc: PFS.StoreConfirmProc, checkFileType: BOOL ฌ FALSE, fileType: PFS.FileType ฌ PFS.tUnspecified, createOptions: PFS.CreateOptions] -- ~ {
dH: DirHandle;

DoStore: PROC [fd: UnixTypes.FD, stringName: CString] ~ TRUSTED {
buffer: REF TEXT;
TRUSTED {
ENABLE UNWIND => {
IF buffer # NIL THEN RefText.ReleaseScratch[buffer];
};
buffer ฌ RefText.ObtainScratch[bufferBytes];
DO
bytesWritten: INT;
ptr: CString ~ LOOPHOLE[LOOPHOLE[buffer, CString] +SIZE[TEXT[0]]];
buffer.length ฌ IO.GetBlock[str, buffer, 0, buffer.maxLength];
IF buffer.length = 0 THEN EXIT;
bytesWritten ฌ UnixSysCalls.Write[fd, ptr, buffer.length];
IF bytesWritten # buffer.length THEN {
IF bytesWritten < 0 THEN { 
errno: UnixErrno.Errno ~ UnixErrno.GetErrno[]; 
ReportFailure["Store", "Write failed", file, errno];
}
ELSE ProduceError[inconsistent, "Invalid assumption about UnixSysCalls.Write in VUXFileImpl.Store", file];
};
ENDLOOP;
{
ENABLE PFS.Error => CONTINUE;
oldMode: ROPE ฌ PFS.GetClientProperty[PFS.OpenFileFromStream[str], "UnixMode"];
buf: UnixTypes.Stat;
res: RES ~ UnixSysCalls.FStat[fd, @buf];
newModeBits: CARD16 ฌ LOOPHOLE[buf.mode];
IF res#success THEN { 
errno: UnixErrno.Errno ~ UnixErrno.GetErrno[];
ReportFailure["DoStore", "Stat failed", file, errno];
};
IF oldMode # NIL THEN {
oldModeBits: CARD16 ~ Convert.CardFromRope[oldMode];
newerModeBits: CARD16 ~ Basics16.BITOR[newModeBits, Basics16.BITAND[oldModeBits, 111B]];
[] ฌ UnixSysCalls.FChMod[fd, LOOPHOLE[newerModeBits]];
};
};
FixUID[stringName, wantedUniqueID];
RefText.ReleaseScratch[buffer]; buffer ฌ NIL;
};
};

fd: UnixTypes.FD;
version: Version;
[fd, version] ฌ AtomicallyCreate[file~file, createOptions~createOptions, openFlags~[access: WRONLY], action~DoStore];
[] ฌ UnixSysCalls.Close[fd];
IF proc # NIL THEN [] ฌ proc[PFSNames.SetVersionNumber[file, version]];
};

PFSFileTypeFromUnixFmt: PROC [ ufs: UnixTypes.Fmt ]
RETURNS [ pfs: PFS.FileType ฌ PFS.tUnspecified ] ~ {
pfs ฌ SELECT ufs FROM
dir	=> PFS.tDirectory,
ENDCASE	=> PFS.tUnspecified;
};

VUXEnumerateForInfo: PFSClass.EnumerateForInfoProc -- [h: FSHandle, pattern: NAME, proc: InfoProc, lbound: NAME, hbound: NAME] -- ~ {
data: FSData ~ NARROW[h.data]; -- sanity check;
Enumerate[h, pattern, NIL, proc];
};

VUXEnumerateForNames: PFSClass.EnumerateForNamesProc -- [h: FSHandle, pattern: NAME, proc: PFS.NameProc, lbound: NAME, hbound: NAME] -- ~ {
data: FSData ฌ NARROW[h.data]; -- sanity check;
Enumerate[h, pattern, proc, NIL];
};

VUXLookupName: PFSClass.LookupNameProc -- [h: FSHandle, file: NAME] RETURNS[NAME] -- ~ {
data: FSData ฌ NARROW[h.data]; -- sanity check;
dH: DirHandle;
fH: FHandle;
version: Version;
[dH~dH, fH~fH, version~version] ฌ
FindExistingFile[file, PFS.nullUniqueID ! PFS.Error => IF error.code = $unknownFile THEN CONTINUE ELSE REJECT];
VUXFiles.UnPinDirPath[dH];
IF fH # NIL THEN RETURN[PFSNames.SetVersionNumber[file, version]]
ELSE RETURN [NIL]; 
};

VUXCopy: PFSClass.CopyProc -- [h: FSHandle, fromFile: NAME, wantedUniqueID: UniqueID, toFile: NAME, keep: CARDINAL, proc: PFS.NameConfirmProc] RETURNS [done: BOOL ฌ FALSE] -- ~ {
data: FSData ฌ NARROW[h.data]; -- sanity check;
};

VUXSetAttributes: PFSClass.SetAttributesProc -- [h: FSHandle, file: OpenFile, attributes: PFS.CreateOptions] -- ~ {
data: FSData ฌ NARROW[h.data]; -- sanity check;
NotYetImpl;
};

VUXSetByteCountAndUniqueID: PFSClass.SetByteCountAndUniqueIDProc -- [h: FSHandle, file: OpenFile, bytes: INT, uniqueID: PFS.UniqueID] -- ~ {
data: FSData ฌ NARROW[h.data]; -- sanity check;
fd: UnixTypes.FD ฌ NARROW[file.data, REF VUXData].fd;
IF bytes>=0 THEN {
res: RES ~ UnixSysCalls.FTruncate[fd, bytes];
IF res#success THEN {
errno: UnixErrno.Errno ~ UnixErrno.GetErrno[];
ReportFailure["VUXSetByteCountAndUniqueID", "FTruncate failed to change byteCount", file, errno];
};
};
};

VUXGetClientProperty: PFSClass.GetClientPropertyProc -- [h: FSHandle, file: OpenFile, propertyName: ROPE] RETURNS [propertyValue: ROPE] -- ~ TRUSTED {
data: FSData ฌ NARROW[h.data]; -- sanity check;
fd: UnixTypes.FD ฌ NARROW[file.data, REF VUXData].fd;
buf: UnixTypes.Stat;
res: RES ~ UnixSysCalls.FStat[fd, @buf];
IF res#success THEN {
errno: UnixErrno.Errno ~ UnixErrno.GetErrno[];
ReportFailure["VUXGetClientProperty", "Stat failed", file, errno];
};
SELECT TRUE FROM 
Rope.Equal[propertyName, "UnixMode"] => {
RETURN[Convert.RopeFromCard[LOOPHOLE[buf.mode, CARD16], 8]];
};
Rope.Equal[propertyName, "UnixOwner"] => {
RETURN[Convert.RopeFromCard[buf.uid]];
};
Rope.Equal[propertyName, "UnixGroup"] => {
RETURN[Convert.RopeFromCard[buf.gid]];
};
ENDCASE => RETURN[NIL];
};

VUXEnumerateClientProperties: PFSClass.EnumerateClientPropertiesProc -- [h: FSHandle, file: OpenFile, proc: PFS.PropProc] -- ~ TRUSTED {
data: FSData ฌ NARROW[h.data]; -- sanity check;
fd: UnixTypes.FD ฌ NARROW[file.data, REF VUXData].fd;
buf: UnixTypes.Stat;
res: RES ~ UnixSysCalls.FStat[fd, @buf];
IF NOT proc["UnixGroup", Convert.RopeFromCard[buf.gid]] THEN RETURN;
IF NOT proc["UnixMode", Convert.RopeFromCard[LOOPHOLE[buf.mode, CARD16], 8]] THEN RETURN;
[] ฌ proc["UnixOwner", Convert.RopeFromCard[buf.uid]];
};

VUXRead: UNSAFE PROC [h: FSHandle, file: PFSClass.OpenFile, filePosition, nBytes: CARD, toPtr: LONG POINTER, toStart: CARD] RETURNS [bytesRead: INT]  ~ UNCHECKED {
fs: FSData ~ NARROW[h.data]; -- sanity check
data: REF VUXData ~ NARROW[file.data];
fd: UnixTypes.FD ฌ data.fd; 
failure: ROPE;
errno: UnixErrno.Errno ฌ ok;
DoRead: ENTRY PROC [lock: REF VUXData] RETURNS [failure: ROPE ฌ NIL] ~ TRUSTED {
ENABLE UNWIND => NULL;
fdIndex: PFSBackdoor.FDIndex ~ data.fdIndex;
data.fdIndex ฌ PFSBackdoor.unreliableIndex;
IF filePosition # fdIndex THEN {
res: INT ~ UnixSysCalls.LSeek[fd, filePosition, set];
IF res < 0 THEN {
errno ฌ UnixErrno.GetErrno[];
RETURN["LSeek failed"];
};
};
bytesRead ฌ UnixSysCalls.Read[d~fd, buf~LOOPHOLE[toPtr+toStart], nBytes~nBytes];
IF bytesRead < 0 THEN {
errno ฌ UnixErrno.GetErrno[];
RETURN["Read failed"];
};
IF fdIndex # PFSBackdoor.unreliableIndex THEN data.fdIndex ฌ filePosition+bytesRead;
};
bytesRead ฌ 0;
IF (failure ฌ DoRead[data]) # NIL THEN ReportFailure["VUXRead", failure, file, errno];
};

VUXData: TYPE ~ PFSBackdoor.VUXData;


VUXWrite: PROC [h: FSHandle, file: PFSClass.OpenFile, filePosition, nBytes: CARD, fromPtr: LONG POINTER, fromStart: CARD] RETURNS [bytesWritten: INT] ~ {
fs: FSData ฌ NARROW[h.data]; -- sanity check
data: REF VUXData ~ NARROW[file.data];
fd: UnixTypes.FD ฌ data.fd; 
failure: ROPE;
errno: UnixErrno.Errno ฌ ok;
DoWrite: ENTRY PROC [lock: REF VUXData] RETURNS [failure: ROPE ฌ NIL] ~ {
ENABLE UNWIND => NULL;
fdIndex: PFSBackdoor.FDIndex ~ data.fdIndex;
data.fdIndex ฌ PFSBackdoor.unreliableIndex;
IF filePosition # fdIndex THEN {
res: INT ~ UnixSysCalls.LSeek[fd, filePosition, set];
IF res < 0 THEN {
errno ฌ UnixErrno.GetErrno[];
RETURN["LSeek failed"];
};
};
bytesWritten ฌ UnixSysCalls.Write[d~fd, buf~LOOPHOLE[fromPtr+fromStart], nBytes~nBytes];
IF bytesWritten < 0 THEN {
errno ฌ UnixErrno.GetErrno[];
RETURN["Write failed"];
};
IF fdIndex # PFSBackdoor.unreliableIndex THEN data.fdIndex ฌ filePosition+bytesWritten;
};
bytesWritten ฌ 0;
IF (failure ฌ DoWrite[data]) # NIL THEN ReportFailure["VUXWrite", failure, file, errno];
};

VUXOpen: PFSClass.OpenProc -- [h: FSHandle, file: NAME, wantedUniqueID: UniqueID, access: PFS.AccessOptions, checkFileType: BOOL, fileType: PFS.FileType, createOptions: PFS.CreateOptions] RETURNS [OpenFile] -- ~ {
data: FSData ฌ NARROW[h.data]; -- sanity check;
openFile: PFSClass.OpenFile ฌ NEW[PFSClass.OpenFileObject ฌ 
[fs: h, uniqueID: PFS.nullUniqueID, state: open, bytes: 0, mutability: mutable, fileType: PFS.tUnspecified, access: access]];
fd: UnixTypes.FD;
version: Version;
fullUName: ROPE;
attachedTo: PATH;
SELECT access FROM
read => {
fmt: UnixTypes.Fmt;
[fH~fullUName, uniqueID~openFile.uniqueID, bytes~openFile.bytes, version~version, fmt~fmt, attachedTo~attachedTo] ฌ FindExistingFile[file, wantedUniqueID];
{
fileString: CString ~ UXO[fullUName];
fd ฌ OpenSetBlocking[path: fileString, 
flags: [access: RDONLY],
mode: [] 
];
UXR[fileString];
};
openFile.fileType ฌ PFSFileTypeFromUnixFmt[fmt];
openFile.fullFName ฌ file.SetVersionNumber[version];
openFile.attachedTo ฌ attachedTo;
openFile.data ฌ NEW[VUXData ฌ [fd]];
RETURN [openFile];
};
create => {
[fd, version] ฌ AtomicallyCreate[file, checkFileType, fileType, createOptions, [access: WRONLY], NIL];
openFile.fullFName ฌ file.SetVersionNumber[version];
[fH~fullUName, uniqueID~openFile.uniqueID] ฌ FindExistingFile[openFile.fullFName, PFS.nullUniqueID ! PFS.Error => {fullUName ฌ NIL; CONTINUE}];
IF wantedUniqueID#PFS.nullUniqueID THEN openFile.uniqueID ฌ wantedUniqueID;
openFile.data ฌ NEW[VUXData ฌ [fd, UXS[fullUName]]];
RETURN [openFile];
};
write => {
version ฌ PFSNames.ShortName[file].version;
IF version.versionKind=next OR version.versionKind=none THEN {
[fd, version] ฌ AtomicallyCreate[file, checkFileType, fileType, createOptions, [access: RDWR], NIL];
openFile.fullFName ฌ file.SetVersionNumber[version];
[fH~fullUName, uniqueID~openFile.uniqueID] ฌ FindExistingFile[openFile.fullFName, PFS.nullUniqueID ! PFS.Error => {fullUName ฌ NIL; CONTINUE}];
IF wantedUniqueID#PFS.nullUniqueID THEN openFile.uniqueID ฌ wantedUniqueID;
openFile.data ฌ NEW[VUXData ฌ [fd, UXS[fullUName]]];
}
ELSE {
[fH~fullUName, uniqueID~openFile.uniqueID, bytes~openFile.bytes, version~version, attachedTo~attachedTo] ฌ FindExistingFile[file, wantedUniqueID ! PFS.Error => {fullUName ฌ NIL; CONTINUE}];
IF attachedTo#NIL THEN {
PFSBackdoor.ProduceError[accessDenied, Rope.Concat[fullUName, " is an attachment and cannot be opened for writing"]]; 
};
{
fileString: CString ~ UXO[fullUName];
fd ฌ OpenSetBlocking[path: fileString, 
flags: [access: RDWR],
mode: [] 
];
UXR[fileString];
};
openFile.fullFName ฌ file.SetVersionNumber[version];
openFile.data ฌ NEW[VUXData ฌ [fd]];
};
openFile.fullFName ฌ file.SetVersionNumber[version];
RETURN [openFile];
};
append => {
[fH~fullUName, uniqueID~openFile.uniqueID, bytes~openFile.bytes, version~version, attachedTo~attachedTo] ฌ FindExistingFile[file, wantedUniqueID];
IF attachedTo#NIL THEN {
PFSBackdoor.ProduceError[accessDenied, Rope.Concat[fullUName, " is an attachment and cannot be opened for appending"]]; 
};
{
fileString: CString ~ UXO[fullUName];
fd ฌ OpenSetBlocking[path: fileString, 
flags: [trunc: false, creat: false, access: RDWR],
mode: [] 
];
UXR[fileString];
};
openFile.fullFName ฌ file.SetVersionNumber[version];
openFile.data ฌ NEW[VUXData ฌ [fd]];
RETURN [openFile];
};
ENDCASE => ERROR;
};

VUXAttach: PFSClass.AttachProc -- [h: FSHandle, file: NAME, to: NAME, keep: CARDINAL, wantedUniqueID: UniqueID, remoteCheck: BOOL ฌ TRUE] RETURNS [toFName: NAME] -- ~ {
dH: DirHandle;

realBase: ROPE;
specifiedVersion: Version;
version: Version;
BeginCreate: PROC  ~ {
isPattern: BOOL;
dH ฌ VUXFiles.FollowDirPath[path~file, case~FALSE, create~TRUE];
[base~realBase, version~specifiedVersion, isPattern~isPattern] ฌ ReadBaseComponent[path~file, case~FALSE];
IF isPattern THEN ProduceError[patternNotAllowed, "Pattern not allowed in VUXFileImpl.VUXStore", file];
SELECT specifiedVersion.versionKind FROM
none, highest => specifiedVersion ฌ [next];
next, numeric => NULL;
ENDCASE => ProduceError[versionSpecified, "Illegal version specified in Attach", file]; 

{
toFileName: ROPE ~ PFS.PFSNameToUnixName[to];
IF toFileName=NIL THEN PFSBackdoor.ProduceError[unknownFile, Rope.Cat["Couldn't deduce a unix name for ", PFS.RopeFromPath[to], " in UXAttach."]];
version ฌ AtomicallyRename[dH, toFileName, dH, realBase, specifiedVersion, FALSE, TRUE]; -- the proceure is misnamed; it is only atomically making a link.
};
dH.contentKnownStale ฌ TRUE;
};

EndCreate: PROC ~ TRUSTED {
createCaseFile: BOOL;
SELECT version.versionKind FROM
numeric => createCaseFile ฌ (CheckCaseFile[dH, realBase] = NIL);
ENDCASE => createCaseFile ฌ (version = [numeric, 1]); -- ???
IF createCaseFile THEN {
[base~realBase] ฌ ReadBaseComponent[path~file, case~TRUE];
CreateCaseFile[dH, realBase];
};
VUXFiles.UnPinDirPath[dH]; dH ฌ NIL;
};


TRUSTED {
ENABLE UNWIND => {
IF dH # NIL THEN VUXFiles.UnPinDirPath[dH];
};
BeginCreate[];
EndCreate[];
toFName ฌ PFSNames.SetVersionNumber[file, version];
};

};

VUXClose: PFSClass.CloseProc -- [h: FSHandle, file: OpenFile, abort: BOOL] -- ~ {
fsData: FSData ~ NARROW[h.data]; -- sanity check;
data: REF VUXData ~ NARROW[file.data, REF VUXData];
fd: UnixTypes.FD ~ data.fd;
failure: ROPE;
errno: UnixErrno.Errno ฌ ok;
DoClose: ENTRY PROC [lock: REF VUXData] RETURNS [failure: ROPE ฌ NIL] ~ {
ENABLE UNWIND => NULL;
res: RES;
data.fdIndex ฌ PFSBackdoor.unreliableIndex;
IF file.access#read THEN {
res ฌ UnixSysCalls.FSync[fd];
IF res#success AND UnixErrno.GetErrno[] # EBADF THEN {
errno ฌ UnixErrno.GetErrno[];
RETURN["Server full?  FSync failed"];
};
};
IF data.setUniqueIDAtClose#NIL THEN FixUID[data.setUniqueIDAtClose, file.uniqueID];
res ฌ UnixSysCalls.Close[fd];
IF res#success THEN {
errno ฌ UnixErrno.GetErrno[];
RETURN["Close failed"];
};
};
IF (failure ฌ DoClose[data]) # NIL THEN ReportFailure["VUXClose", failure, file, errno];
};

FixUID: PROC [stringName: CString, wantedUniqueID: UniqueID] ~ TRUSTED {
mTime: MTime ~ MTimeFromGMT[wantedUniqueID.egmt.gmt];
modTimeVal: UnixTypes.AccModTimes ฌ
[accessTime: [sec: mTime, usec: 0], modTime: [sec: mTime, usec: 0]];
IF wantedUniqueID.egmt.gmt # BasicTime.nullGMT THEN IF UnixSysCalls.UTimes[stringName, @modTimeVal] # success THEN { 
errno: UnixErrno.Errno ~ UnixErrno.GetErrno[];
ReportFailure["FixUID", "UTimes failed", UXStrings.ToRope[stringName], errno];
};
};

VUXSetClientProperty: PUBLIC PFSClass.SetClientPropertyProc -- [h: FSHandle, file: OpenFile, propertyName: ROPE, propertyValue: ROPE] -- = {
data: FSData ฌ NARROW[h.data]; -- sanity check;
fd: UnixTypes.FD ฌ NARROW[file.data, REF VUXData].fd;
SELECT TRUE FROM 
Rope.Equal[propertyName, "UnixMode"] => {
cardMode: CARD16 ~ Convert.CardFromRope[propertyValue, 8];
res: RES ~ UnixSysCalls.FChMod[fd, LOOPHOLE[cardMode]];
};
Rope.Equal[propertyName, "UnixOwner"] => {
ProduceError[notImplemented, "The UnixOwner cannot be changed in the VUX view", file];
};
Rope.Equal[propertyName, "UnixGroup"] => {
ProduceError[notImplemented, "The UnixGroup cannot be changed in the VUX view", file];
};
ENDCASE => ProduceError[notImplemented, Rope.Concat[propertyName, " is not an implemented property in the VUX view"], file];
};

VUXCaseSensitive: PUBLIC PFSClass.CaseSensitiveProc -- [h: FSHandle, file: PATH] RETURNS [ BOOL ] -- = {
RETURN[FALSE];
};

VUXPFSNameToUnixName: PUBLIC PFSClass.PFSNameToUnixNameProc -- [h: FSHandle, file: PATH] RETURNS [ ROPE ] -- = {
lastComponent: Component ฌ PFSNames.ShortName[file];
IF lastComponent.version.versionKind#numeric THEN {
RETURN[FindExistingFile[file, PFS.nullUniqueID].fH]
}
ELSE {
lastRope: ROPE ฌ PFSNames.ComponentRope[lastComponent];
newLastRope: ROPE ฌ EncodeVersionInName[lastRope, lastComponent.version.version];
newName: PATH ฌ PFSNames.ReplaceShortName[file, MakeComponent[newLastRope, [none]]];
resultExceptCase: ROPE ฌ PFS.RopeFromPath[newName, slashes];
RETURN[LowerCase[resultExceptCase]];
};
};

NotYetImpl: ERROR ~ CODE;

oneEltPath: PATH ฌ PFSNames.ConstructName[components~LIST[ MakeComponent["*", [none]] ] ];
oneEltDirPath: PATH ฌ PFSNames.ConstructName[components~LIST[ MakeComponent["*", [none]] ], directory~TRUE ];

MakeComponent: PROC [r: ROPE, v: Version] RETURNS [Component] ~ {
RETURN[[name:[r, 0, Rope.Length[r]], version: v]];
};

magicFlags: ARRAY {read, create, append, write} OF UnixTypes.FileFlags ~ [
read: [access: RDONLY], -- read only
create: [trunc: true, creat: true, access: WRONLY], -- truncate, create, write only
append: [creat: true, append: true, access: WRONLY], -- create, append, write only
write: [trunc: true, creat: true, access: WRONLY] -- truncate, create, write only
];

ReadBaseComponent: PROC [path: PATH, case: BOOL] RETURNS [base: ROPE, version: Version, isPattern: BOOL ฌ FALSE] ~ {
shortName: Component ~ PFSNames.ShortName[path];
base ฌ PFSNames.ComponentRope[shortName];
version ฌ shortName.version;
IF NOT case THEN {
base ฌ LowerCase[base];
};
};

LowerCase: PROC [r: ROPE] RETURNS[ROPE] ~ {
len: INT ฌ r.Length[];
buf: REF TEXT ฌ RefText.ObtainScratch[len];
FOR i: INT IN [0..len) DO
buf[i] ฌ Ascii.Lower[r.Fetch[i]];
ENDLOOP;
buf.length ฌ len;
RETURN[Rope.FromRefText[buf]];
};
GMTFromMTime: PUBLIC PROC [unixTime: UnixTypes.Time] RETURNS [gmt: GMT] ~ {
RETURN [BasicTime.Update[unixEpoch, INT[unixTime]]];
};

MTimeFromGMT: PUBLIC PROC [gmt: GMT] RETURNS [unixTime: UnixTypes.Time] ~ {
RETURN [BasicTime.Period[from~unixEpoch, to~gmt]];
};

CompareSunTimes: PUBLIC PROC [t1, t2: UnixTypes.TimeVal] RETURNS [Basics.Comparison] ~ {
RETURN [SELECT t1.sec FROM
< t2.sec => less,
> t2.sec => greater,
ENDCASE => Basics.CompareCard[t1.usec, t2.usec]];
};

EncodeVersionInName: PROC [name: ROPE, version: CARD] RETURNS [nameWithVersion: ROPE] ~ {
versionNumber: CARDINAL ฌ version;
nameWithVersion ฌ Rope.Cat[ name, ".~", Convert.RopeFromCard[versionNumber, 10, FALSE], "~" ];
};

versionPartLeftBracket: ROPE ฌ ".~";
versionPartRightBracket: CHAR ฌ '~;
versionPartLeftBracketLen: INT ฌ Rope.Length[versionPartLeftBracket];
versionPartRightBracketLen: INT ฌ 1;
versionPartBracketsLen: INT ฌ versionPartLeftBracketLen + versionPartRightBracketLen;

DecodeVersionFromName: PROC [name: ROPE] RETURNS [dirEntry: VUXFiles.DirEntry] ~ {
nameLen, bangPos: INT;
versionNumber: CARD;
versionNumberRope: ROPE;
dirEntry ฌ [name, [none], FALSE];
nameLen ฌ Rope.Length[name];
IF Rope.IsPrefix[caseFileNamePrefix, name, FALSE] THEN RETURN; -- accelerator
bangPos ฌ Rope.FindBackward[name, versionPartLeftBracket];
IF bangPos < 0 THEN bangPos ฌ nameLen;
dirEntry.nameWithoutVersion ฌ Rope.Flatten[name, 0, bangPos];
IF bangPos > (nameLen-versionPartBracketsLen) THEN RETURN;
IF Rope.Fetch[name, nameLen-1] = versionPartRightBracket
THEN versionNumberRope ฌ Rope.Substr[name, bangPos+versionPartLeftBracketLen, nameLen-bangPos-versionPartBracketsLen]
ELSE versionNumberRope ฌ Rope.Substr[name, bangPos+versionPartLeftBracketLen];
versionNumber ฌ Convert.CardFromRope[versionNumberRope, 10
! Convert.Error => {versionNumber ฌ 0; CONTINUE }];
IF versionNumber # 0 THEN dirEntry.version ฌ [numeric, versionNumber];
};


UXS: PROC[r: REF] RETURNS [CString] ~ INLINE{
RETURN[UXStrings.Create[r]];
};

UXO: PROC[r: REF] RETURNS [CString] ~ INLINE{
RETURN[UXStrings.CreateScratch[r]];
};
UXR: PROC[s: CString] ~ INLINE{
UXStrings.ReleaseScratch[s];
};
initialInfoSetSize: CARDINAL ฌ 16;
InfoSet: TYPE ~ REF InfoSetObject;
InfoSetObject: TYPE ~ RECORD [
size: CARDINAL,
info: SEQUENCE maxSize: CARDINAL OF Info
];
infoSetSize: CARDINAL ฌ SIZE[InfoSetObject[0]]; -- avoid compiler bug 
maxMaxSize: CARDINAL ฌ (CARDINAL.LAST - infoSetSize - 10) / SIZE[Info]; -- the '10' is just for luck

InfoKind: TYPE ~ { caseHint, file, subdirectory };
Info: TYPE ~ RECORD [
name: ROPE, -- not including version part
kind: InfoKind,
version: Version
];

AddInfoToSet: PROC [set: InfoSet, info: Info] RETURNS [newSet: InfoSet] ~ {
IF set = NIL THEN { set ฌ NEW[InfoSetObject[initialInfoSetSize]]; set.size ฌ 0 };
IF set.size < set.maxSize
THEN { newSet ฌ set }
ELSE {
newSize: CARDINAL ~ MIN[2*set.maxSize, maxMaxSize];
newSet ฌ NEW[InfoSetObject[newSize]];
FOR i: CARDINAL IN [0 .. set.size) DO
newSet.info[i] ฌ set.info[i];
ENDLOOP;
newSet.size ฌ set.size;
};
newSet.info[newSet.size] ฌ info;
newSet.size ฌ newSet.size + 1;
};


lastCharRope: ROPE ~ Rope.FromChar[CHAR.LAST];

Enumerate: PROC [h: FSHandle, pattern: PATH, nameProc: PFS.NameProc, infoProc: PFS.InfoProc] ~ {
casedDirPath: PATH;
dH: VUXFiles.DirHandle;
match: PATH;
matchCount: INT;
version: PFSNames.Version ฌ PFSNames.ShortName[pattern].version;
Matched: PROC[dH: VUXFiles.DirHandle, nameSoFar: PATH, casedName: ROPE, uncasedName: ROPE, version: PFSNames.Version, isDir: BOOL] RETURNS [continue: BOOL ฌ TRUE] ~ {
name: PATH ฌ PFSNames.ReplaceShortName[PFSNames.Cat[nameSoFar, IF isDir THEN oneEltDirPath ELSE oneEltPath], MakeComponent[casedName, version]];
IF nameProc # NIL THEN
continue ฌ nameProc[name]
ELSE {
bytes: INT;
fileType: PFS.FileType;
fmt: UnixTypes.Fmt;
attachedTo: PATH ฌ NIL;
mTime: MTime;
uniqueID: PFS.UniqueID;
mutability: PFS.Mutability ฌ mutable;
lowName: ROPE ฌ uncasedName;
fH: FHandle;
IF version.versionKind = numeric THEN
lowName ฌ EncodeVersionInName[uncasedName, version.version];
[fH~fH, fmt~fmt, bytes~bytes, mTime~mTime, attachedTo~attachedTo] ฌ LookupSimple[dH, lowName];
uniqueID ฌ [egmt~[gmt~GMTFromMTime[mTime], usecs~0]];
fileType ฌ PFSFileTypeFromUnixFmt[fmt];
IF attachedTo#NIL THEN attachedTo ฌ ResolveAttachment[name, attachedTo];
continue ฌ infoProc[name, attachedTo, uniqueID, LOOPHOLE[bytes], mutability, fileType];
};
};

NameInfo: TYPE ~ RECORD[ name: ROPE, version: Version, casedName: ROPE];
noName: NameInfo ~ [NIL, [none], NIL];

EnumerateInner: PROC[level: INT, dH: VUXFiles.DirHandle, nameSoFar: PATH] RETURNS [continue: BOOL ฌ TRUE] ~ {
component: ROPE ฌ VUXFiles.GetDirComponent[path~pattern, pos~level, smashCase~FALSE];
starPos: INT ~ Rope.Index[component, 0, "*"];
lowestPossible: ROPE ฌ Rope.Substr[VUXFiles.GetDirComponent[path~pattern, pos~level, smashCase~TRUE], 0, starPos];
highestPossible: ROPE ฌ Rope.Concat[lowestPossible, lastCharRope];
set: InfoSet ฌ NIL;
latestCaseHint, thisName, casedName: ROPE ฌ NIL;
lag: NameInfo ฌ noName;

EachName: VUXFiles.EachDirEntryProc ~ {
thisName ฌ entry.nameWithoutVersion;
casedName ฌ thisName;
IF Rope.Compare[thisName, highestPossible] = greater THEN RETURN[FALSE];
SELECT TRUE FROM
entry.version.versionKind = numeric AND entry.version.version=0 => {
latestCaseHint ฌ thisName;
};
entry.version.versionKind = none => {
IF Rope.Equal[thisName, "."] OR Rope.Equal[thisName, ".."] THEN
RETURN[TRUE];
IF latestCaseHint # NIL THEN
SELECT Rope.Compare[latestCaseHint, thisName, FALSE] FROM
less => latestCaseHint ฌ NIL;
equal => casedName ฌ latestCaseHint;
ENDCASE;
IF Rope.Match[component, thisName, FALSE] THEN {
IF level = PFSNames.ComponentCount[pattern] - 1 THEN {
RETURN Matched[dH, nameSoFar, casedName, thisName, [none], TRUE];
}
ELSE {
continue: BOOL ฌ TRUE;
subDH: VUXFiles.DirHandle ฌ NIL;
[dHChild~subDH] ฌ VUXFiles.GetDirChild[dH, thisName, FALSE ! PFS.Error => IF error.code = $unknownFile THEN {subDH ฌ NIL; CONTINUE}];
IF subDH # NIL THEN {
continue ฌ EnumerateInner[level + 1, subDH, PFSNames.ReplaceShortName[PFSNames.Cat[nameSoFar, oneEltPath], MakeComponent[casedName, [none]]]];
[] ฌ VUXFiles.UnPinDir[subDH];
};
RETURN [continue];
};
};
};
entry.version.versionKind = numeric => {
IF level # PFSNames.ComponentCount[pattern] - 1 THEN
RETURN[TRUE];
IF latestCaseHint # NIL THEN
SELECT Rope.Compare[latestCaseHint, thisName, FALSE] FROM
less => latestCaseHint ฌ NIL;
equal => casedName ฌ latestCaseHint;
ENDCASE;
IF Rope.Match[component, thisName, FALSE] THEN {
it: NameInfo ฌ noName;
SELECT version.versionKind FROM
all, none => {
it ฌ [thisName, entry.version, casedName];
};
numeric => {
IF entry.version = version THEN
it ฌ [thisName, entry.version, casedName];
};
lowest => {
IF NOT Rope.Equal[lag.name, thisName, TRUE] THEN {
it ฌ [thisName, entry.version, casedName];
};
lag ฌ [thisName, entry.version, casedName];
};
highest => {
IF NOT Rope.Equal[lag.name, thisName, TRUE] THEN {
it ฌ lag;
};
lag ฌ [thisName, entry.version, casedName];
};
ENDCASE => ERROR;
IF it.name # NIL THEN {
RETURN[ Matched[dH, nameSoFar, it.casedName, it.name, it.version, FALSE] ]	;
};
};
};
ENDCASE => ERROR;
};
IF level >= PFSNames.ComponentCount[pattern] THEN
RETURN;
IF starPos >= 0 THEN lowestPossible ฌ lowestPossible.Substr[0, starPos];
VUXFiles.EnumerateDirectory[dH, EachName, lowestPossible, FALSE];
IF lag.name#NIL AND version.versionKind=highest 
THEN  RETURN[ Matched[dH, nameSoFar, lag.casedName, lag.name, lag.version, FALSE] ];
};

{
ENABLE {
UNWIND => {
IF dH # NIL THEN VUXFiles.UnPinDirPath[dH]; dH ฌ NIL;
};
};
IF PFSNames.IsADirectory[pattern] THEN	-- Perhaps dubious
pattern ฌ PFSNames.Cat[pattern, oneEltPath];
[dH, match, matchCount] ฌ FollowDirPathForEnumeration[PFSNames.StripVersionNumber[pattern]];
IF dH # NIL THEN
[] ฌ EnumerateInner[matchCount, dH, match];
};
IF dH # NIL THEN VUXFiles.UnPinDirPath[dH];
};

FollowDirPathForEnumeration: PROC [pattern: PATH] RETURNS [dH: DirHandle, match: PATH, matchCount: INT ฌ 0] ~ {
ENABLE UNWIND => {
IF dH # NIL THEN VUXFiles.UnPinDirPath[dH];
};
dir: PATH ฌ PFSNames.Directory[pattern];
dirPath: PATH;
caseFileName: ROPE;
component, casedComponent: ROPE;
i: INT ฌ 0;
EachDirEntry: VUXFiles.EachDirEntryProc -- [entry: VUXFiles.DirEntry] RETURNS [continue: BOOL ฌ TRUE] -- ~ {
SELECT TRUE FROM
Rope.Compare[entry.nameWithoutVersion, component, FALSE] = greater => {
continue ฌ FALSE;
};
entry.version.versionKind = numeric AND entry.version.version=0 => {
casedComponent ฌ entry.nameWithoutVersion;
continue ฌ FALSE;
};
ENDCASE => NULL; 
};
dH ฌ VUXFiles.GetDirRoot[];
dirPath ฌ PFSNames.SubName[name~dir, start~0, count~1, absolute~TRUE, directory~TRUE];
FOR i ฌ 1, i + 1 WHILE i < PFSNames.ComponentCount[pattern] - 1 DO
component ฌ casedComponent ฌ VUXFiles.GetDirComponent[path~pattern, pos~i, smashCase~TRUE];
IF Rope.Find[component, "*"] >= 0 THEN
EXIT;
caseFileName ฌ Rope.Concat[caseFileNamePrefix, component];
VUXFiles.EnumerateDirectory[dH, EachDirEntry, component, FALSE];
dirPath ฌ PFSNames.ReplaceShortName[PFSNames.Cat[dirPath, oneEltPath], MakeComponent[casedComponent, [none]] ];
dH ฌ VUXFiles.GetDirChild[dH~dH, childName~component, create~FALSE ! PFS.Error => { IF error.code = $unknownFile THEN {VUXFiles.UnPinDirPath[dH]; dH ฌ NIL; CONTINUE }}].dHChild;
IF dH = NIL THEN RETURN;
ENDLOOP;
match ฌ dirPath;
matchCount ฌ i;
};

UIDFromMTime: PROC [mTime: MTime] RETURNS [UniqueID] ~ {
RETURN[[egmt: [gmt: HostTime.ExtendedGMTFromHostTime[[a~LOOPHOLE[mTime]]].gmt, usecs: 0], host: [0, 0]]]
};
PFSClass.ClearCachedServer["-vux"];
PFSClass.Register[vuxFlavor, VUXGetHandle];
}...
  
8
VUXFileImpl.mesa
Copyright ำ 1987, 1988, 1989, 1990, 1991, 1992 by Xerox Corporation.  All rights reserved.
Demers, February 19, 1988 4:54:19 pm PST
Xerox3, January 15, 1988 12:37:12 pm PST
JKF November 16, 1988 4:51:21 pm PST
Tim Diebert: May 18, 1988 8:46:48 am PDT
Carl Hauser, September 21, 1989 10:05:55 am PDT
Doug Wyatt, February 2, 1990 3:56:14 pm PST
Nichols, March 29, 1990 3:38 pm PST
Willie-s, July 9, 1992 4:56 pm PDT
Chauser, February 3, 1993 3:11 pm PST
Michael Plass, January 27, 1992 5:34 pm PST
Wade, May 3, 1991 5:27 pm PDT

TODO: The EachDirProcs need to terminate enumeration (sorted assumption).
TODO: Ensure that the FileInfoProc does the right thing about attachedTo [DKW].
Copied Types
Parameters
File lookup and creation
Return info for named file if it's present and we can stat it successfully.
Return fH=NIL if named file is nonexistent.
Raise PFS.Error otherwise.
All attachments supported in this view must be -ux file names and should be identified as such to clients.
Return info for file if it's present and we can stat it successfully.
Return fH=NIL if no file exists with given name and created time.
Raise PFS.Error for other errors.
Determine a version number for to file; rename the from file to that version.
If "deleteIfError" is TRUE, the "from" file will disappear even if the rename operation fails.
ignore failures
Registered As a PFS Class
Returns [NIL, NIL] if fs can't be located.
at the moment, we only support the local Unix name space. 
Error reporting
Procs to provide versioned view
fullFName ฌ PFSNames.SetVersionNumber[file, version];
chmod done separately from open to override umask.
Sync the file, because otherwise writes to full NFS servers all appear to work, but the bits don't appear there.
Preserve "Execute" bits in Unix-based views
This is not pleasant...
IF wantedUniqueID.egmt.time # BasicTime.nullGMT THEN TRUSTED {
bah! there's no string name available for the UTimes.
mTime: MTime ~ MTimeFromGMT[wantedUniqueID.egmt.time];
modTimeVal: UnixTypes.AccModTimes _
[accessTime: [sec: mTime, usec: 0], modTime: [sec: mTime, usec: 0]];
res: RES ~ UnixSysCalls.UTimes[stringName, @modTimeVal];
};
Sync the file, because otherwise writes to full NFS servers all appear to work, but the bits don't appear there.
have to find it; may raise PFS.Error[FileNotFound]
produce the unix name by syntactic transformation
Utility
Time Conversion
Version Encoding


Enumerations
Parameters
Sets of Info
Not used right now.
EnumerationAborted: PRIVATE ERROR ~ CODE;
Enumerate all the files that match the pattern, calling either nameProc or infoProc (whichever is non-NIL) on each.
Called on each file name matched, it constructs the final name and calls either the name proc or the info proc.
The recursive tree walk.  I suppose all the continue flag stuff could be done with exceptions.
Pass to VUXFiles.EnumerateDirectory to fill "set" with a directory's file entries.
See if we have a case hint for this guy.
Check for match.
Match if we're processing the last component, else recur.
Don't match files until the last pattern component.
See if we have a case hint for this guy.
Now try for match.
If versions match, we're in.
Match everything.
Versions must agree.

Main for EnumerateInner.
We enumerate the directory and build a set that has all the files, dirs, and case hints in it.  The enumeratioin should place each case hint immediately before the files it pertains to.
Main code for Emuerate.
Match the non-wildcard part of the pattern.  We could let EnumerateInner do this, but we don't, for both historical and speed reasons.
Follows a pattern down the file tree through all components with no '* characters.  The case information for each directory traversed is remembered.  When done, we return a directory handle for the matched part, its name, and the length of the name.
assert: Rope.Equal [entry.nameWithoutVersion, component] 
Component 0 is empty by convention, and we don't process the last one.
At this point, i has either the index of the component with the first *, or the index of the last component.
the LOOPHOLE is to guard again bogus unix file times
Initialization
ส7•NewlineDelimiter

–
(cedarcode) style•NewLineDelimiter

™
codeš
œ™Kšœ
ฯe
œO™ZK™(K™(K™$K™(K™/K™+K™#K™"K™%K™+K™K™K™I™OK˜——š
ฯk	˜	K˜K˜K˜K˜	Kšœ
žœžœ4˜XK˜Kšœ	žœ˜K˜	Kšžœ
˜Kšžœ
˜K˜K˜	K˜	Kšœžœ!˜.Kšœžœƒ
žœ
˜›
K˜
Kšœžœ!˜4K˜
Kšœžœ"˜=K˜
Kšœ
žœžœžœ˜RK˜Kš
œ
˜
K˜—šฯnœžœ
žœ
žœžœžœ˜BKšžœ>žœžœ„
˜ะ
Kšžœ
žœ
˜K˜
head™Kšœžœ
žœฯc:˜qK˜Kšœ	žœ˜!Kšžœžœ
žœ
˜Kšœžœ˜%Kšžœžœžœ
˜Kšœžœ˜Kšœ	žœ˜!Kšœžœ˜%Kšžœžœžœ
˜Kšœ
žœžœ
˜Kšœ
žœžœ
˜Kšœžœžœ
˜Kšžœžœ
žœ
˜Kšœ
žœ˜#Kšœ	žœ˜!—™
šœžœ˜ K˜MK˜—Kš
œ?˜?Kš
œ{˜{Kšœ
žœ˜Kšœ
žœ˜Kšœžœ˜—™šŸœžœžœ
˜6Kšžœ*žœžœžœ
˜[Kš
œ˜K™KK™+K™K˜Kš
œ˜Kš
œ8˜8šžœž˜˜K˜Kš
œ ˜ Kšœžœ˜(Kš
œ˜K˜—šžœ˜Kšœžœ
˜	Kš
œ
˜
K˜
Kš
œ
˜
K˜—KšžœIžœQžœ"˜ศ
—K˜K˜—Kšœ)žœ˜GK™jšŸœžœžœžœžœžœ˜Oš
œ
˜
Kš	œ
žœžœ!žœžœ:˜‚
Kšžœ9˜?Kš
œ˜—K˜K˜—šŸœžœžœ˜JKšžœžœ5žœžœ
˜wK˜K™EK™AK™!K˜Kšœžœžœ
˜šŸœ 7œ˜cK˜šžœ.žœž˜?Kšœžœ
žœ ˜.šœ	žœžœ˜+K˜
Kš
œT˜TKš
œc˜cšžœžœžœžœ˜.Kšœžœ
˜
Kšžœ
žœ˜K˜—K˜—˜Kšžœ
žœ˜K˜—Kšžœžœ ,˜>—K˜—Kšœ4žœ˜;Kšžœ
žœžœ
žœžœžœ˜:K˜K˜—šŸœžœžœžœ
˜BKšžœ2žœ	žœžœ˜WKšœžœ˜Kšœžœžœ
˜Kšœžœžœ
˜šŸœ 7œ˜cšžœ.žœž˜?Kšœžœ
žœ ˜.šœ	žœžœ˜+Kšœžœ '˜Jšžœžœ˜!Kšœ
žœ
˜Kš
œ˜K˜
—K˜
šžœ
˜Kšœžœ
˜——Kšœžœ
žœ˜Kšžœ˜
—K˜—Kš
œ=˜=šžœžœ˜Kš
œ;˜;Kš
œ-˜-Kšœžœ
˜
K˜
—šžœ
žœžœ˜Kš
œ˜Kšœžœ
˜
Kš
œ˜—K˜K˜—šŸœžœžœžœ
˜BKšžœ1žœ	žœžœ˜VKšœžœžœ
žœ
˜ Kšœžœžœ
˜Kšœžœžœ
˜šŸœ 7œ˜cšžœ.žœž˜?Kšœžœ
žœ ˜.šœ	žœžœ˜+Kšœžœ '˜Jšžœžœžœ˜1Kšœ
žœ
˜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šœ=žœ	žœ˜RKšœVžœ˜]Kšžœžœ-žœJžœ˜ฌ
šžœž˜˜Kšœ>žœ˜EKšžœ
žœžœ
žœ˜K˜—˜Kšœ=žœ˜DKšžœ
žœžœ
žœ˜K˜—˜Kšžœžœžœa˜Œ
Kšœžœ
˜K˜—˜Kš
œ:˜:Kšœžœ
˜
K˜—Kšžœžœ
 œ˜%—KšžœžœF˜SKš
œ5˜5Kšžœžœžœ
žœ˜5š
žœžœžœžœžœ˜WKšžœ}˜
—Kšžœžœ
žœ2˜JKšœ ˜8š
ž˜Kšœžœ
˜—K˜—Kš
œ˜šžœžœ
žœ˜Kšœ&žœ>žœ˜ˆ
K˜—K˜K˜—šŸœžœ?žœ*žœ
žœžœ
˜ž
Kšžœ˜K™MK™^Kšœžœ
˜Kšœžœ
žœ
˜˜
šžœ
žœ˜Kšžœžœ ˜5K˜—šžœž˜&Kšœ5žœ^˜•
š
œ˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜	KšœYžœ˜_šžœžœž˜Kšžœžœ
žœ Z˜{Kšžœžœ
žœžœ:˜rK˜Kš
œ[˜[š
œ
˜
Kšœžœ	˜Kšœžœ˜"šžœ˜
Kšžœ&˜*Kšžœ#˜'—Kšžœžœ˜Kš
œ˜—šžœžœ˜Kš
œ.˜.Kš
žœžœ
žœ
žœ
žœX˜wKš
œ˜—Kšœžœ
˜Kšžœ
˜Kšžœ
˜—šžœ
žœžœ˜Kšœžœ	˜Kš
œ ˜ Kšžœ˜
Kš
œ˜—šžœžœ˜Kšœ.ฯi
˜/K˜]Kš
œ˜—Kšœžœ
˜ K˜—š
œ˜K˜Kšœžœ
˜	Kš
œ˜Kš
œ[˜[š
œ
˜
Kšœžœ	˜Kšœžœ˜"šžœ˜
Kšžœ&˜*Kšžœ#˜'—Kšžœžœ˜Kš
œ˜—šžœ
žœ˜Kš
œ˜Kšžœžœ
žœe˜xKš
œ˜—šžœ
žœžœ˜Kšœžœ	˜Kš
œ ˜ Kšžœ˜
Kš
œ˜—Kšœ4žœ
˜9K˜—Kšžœžœ ˜!—K˜—K˜K˜—šŸœžœžœ˜4Kšœžœ"˜5Kš
œ˜Kšžœ˜
Kšœžœ
˜K˜K˜—Kšœžœžœ
˜K˜š
Ÿœžœžœžœžœ˜>Kšœžœ
˜
šžœžœ
žœ˜K˜#KšœžœžœF˜wK˜—Kš
œ%˜%Kšœžœ+žœ˜CKšœžœL˜YK˜K˜—Kšœžœ
žœ
˜,Kšœžœ
žœ#˜DK˜šŸœžœ
žœžœ˜;Kšœžœ)˜;Kšœžœ*˜=KšœžœD˜TKšžœ˜
K™Kšžœ
žœ˜-Kšœžœ
˜K˜K˜—šŸ
œžœžœžœžœžœ˜VšŸœ 7œ˜cšžœ.žœž˜?Kšœžœ ˜%š
œ	˜	šžœ žœ˜(Kš
œ(˜(Kšžœ
žœ˜K˜
—Kšžœ
žœ
žœ˜—Kšœžœ
žœ˜Kšžœ˜
—K˜—Kšœ4žœ˜;K˜K˜—šŸœžœ
žœžœ˜<Kšœžœžœ
˜Kš	œžœ
žœ
žœžœ
˜"šŸœ 7œ˜cšžœ.žœž˜?Kšœžœ
žœ ˜&šœ	žœžœžœ˜MKšœžœ
˜Kšžœ
žœ˜K˜—˜Kšžœ
žœ˜K˜—Kšžœ ˜—K˜—šŸœ 7œ˜hšžœ,žœžœ˜;šžœž˜$KšœžœK˜_—Kšžœ
žœ˜
K˜—Kšžœ
žœ˜K˜—Kšœ4žœ˜;šžœ
žœžœ˜Kšœ9žœ˜@š
žœžœ
žœ
žœžœžœ
ž˜EKš
œ˜Kšžœ
˜—K˜—K˜——™Icode1šœžœžœ˜ šœžœžœ˜Mšœž˜M˜M˜—šœ1žœ$˜XMš
œ˜Mš
œ˜Mš
œ˜M˜—šŸœ˜ Kš
œ&˜&Kš
œ$˜$Kš
œ˜Kš
œ˜—K˜šŸœ Lœ˜ušžœ˜Kšžœ#žœ
˜-Kšžœžœžœ˜ —K˜K˜—šŸœ Pœ˜{šžœ˜Kšžœ#žœ
˜,Kšžœžœžœ˜ —K˜K˜—šŸœžœžœžœžœ!žœžœ˜gKšœ	žœžœ™*Kšœžœ˜(šžœ
žœžœ
žœ
žœžœ˜.Kš
œ:™:—Kšœžœx˜K˜K˜—šŸœ ;œ˜bKšœžœ
 ˜/Kšžœžœžœ ˜)K˜———™Kšœžœ˜"š
Ÿ
œžœžœžœžœ˜VKšœžœ(˜8šœ
žœžœžœ
ž˜&Kšœžœ˜<Kšœžœžœ˜%Kšœžœ	˜Kšžœ
˜—Kšœ	žœ0˜=K˜,Kš
œ˜K˜—šŸœžœ1žœžœ˜Wšœ
žœžœžœ
ž˜&Kšœžœ˜<Kšœžœžœ˜%Kšœžœ	˜Kšžœ
˜—Kšœ	žœ,˜9Kš
œ.˜.Kš
œ˜—K˜—š
Ϫ
code2šœ+žœ)˜WKš
œ˜Kš
œ&˜&Kš
œ(˜(Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ ˜ Kš
œ4˜4Kš
œ(˜(Kš
œ(˜(Kš
œ8˜8Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜K˜(K˜K˜K˜—šŸ	œžœ ะcsN œ˜~Kš
œ˜K˜Kšœžœ
˜Kš
œ˜Kš
œp˜pšžœ	žœžœ:žœ˜Ršžœ
žœ˜Kš
œ˜K˜—Kšœ
žœ+˜9Kšœžœ˜$Kšœžœ#˜+Kšžœ
˜šžœ
žœ˜K˜.K˜=K˜—Kšœžœ
˜Kš
œL˜LK˜—K˜K˜—šŸœžœ ขด
 œ˜่
K˜Kšœžœ
˜	Kš
œ˜Kš
œ"˜"Kš
œ‰
˜‰
K˜K˜'Kš
œ˜Kš
œ5™5K˜K˜—šŸ
œ 
œžœ˜ส
Kšœžœžœ˜&Kšœžœ˜Kš
œ˜Kšœžœ ˜(šžœžœ˜K˜.K˜8Kš
œ˜—Kšžœ[˜aK˜K˜—š
Ÿ	œžœ ข…
 
ข œ˜ฝ
Kš
œ˜˜
šžœ
žœ˜Kšžœ
žœ
žœ˜3Kšžœžœ
žœ˜/K˜—Kšœ2žœ
˜7Kšœžœ
˜ K˜K˜K˜3Kš
œ‡
˜‡
šžœ	žœžœ>žœ˜VKšœ0žœ	žœ˜DKšœcžœ˜jKšžœžœY˜jšžœž˜Kš
œ+˜+Kšœžœ˜KšžœR˜Y—KšœRžœžœ
žœ	˜tKš
œT˜TKš
œ0˜0šžœž˜Kšœ;žœ˜@Kšžœ5˜<—šžœžœ˜Kšœ4žœ˜:Kšœžœ
žœ˜6K˜—Kšœ$žœ
˜(K˜—Kšœ(žœ
˜,Kšžœ
žœ˜
š
ž˜Kš
œH˜H—K˜—K˜K˜—š
Ÿœžœ ขg 
ข œ˜ฃ
K˜Kšœžœ
˜Kšœžœ
žœ
˜Kš
œ˜Kšœžœ
˜K˜Kšœžœ
žœ
˜Kšœžœ
˜Kšœžœ˜K˜Kš
œ‡
˜‡
Kš
œT˜TKšžœžœ
žœ
žœ
˜Kšœžœ˜@š
œ
˜
Kšœžœ˜Kš
œ1˜1Kšžœ˜
Kš
œ˜—šžœžœ˜K˜.K˜4Kš
œ˜—šžœ˜	šžœ
žœ˜Kš
œ˜K˜—š
ž˜Kšœžœ
˜Kš	œžœ
žœžœ
žœ˜BKš
œ9˜9šžœžœ˜K˜.K˜4Kš
œ˜—Kš
œ˜Kšžœ˜Kšžœ"žœ
žœ
˜.Kšžœ
˜—K˜—K˜K˜K˜—šŸœžœCžœžœ˜vKš
œ*˜*Kšžœžœ
žœ
˜š
œ
˜
š	œžœžœžœ
žœ2˜ZKšžœ3˜7—Kšžœžœ˜ K˜—K˜K˜—šŸœžœžœžœžœžœžœžœ9žœžœžœžœ˜•Kšœžœ
˜!K˜K˜šŸœžœ˜Kšœžœ
˜Kšœ,žœ	žœ˜@Kšœcžœ˜jKšžœžœV˜gšžœž˜(Kš
œ+˜+Kšœžœ
˜KšžœP˜W—Kš
œG˜GKšœžœ˜'Kš
œ=˜=šžœžœ˜K˜.K˜JKš
œ˜—š
œ
˜
K™2Kšœ?žœ˜Fšžœ0žœ˜9K˜.K˜KKš
œ˜—Kš
œ˜—Kšœžœ
˜K˜K˜—šŸ	œžœžœ˜Kšœžœ
˜K™pKšœžœ˜"K˜šžœ
žœ"žœ
žœ˜@K˜VKš
œ˜—KšœQžœ˜Wšžœž˜Kšœ;žœ˜@Kšžœ/ ˜<—šžœžœ˜Kšœ4žœ˜:Kš
œ˜K˜—Kšœ žœ
˜$K˜K˜—Kš
œ˜K˜šžœ˜	šžœ
žœ˜Kšžœžœ
žœ˜+K˜—K˜Kšžœžœ
žœ˜.K˜Kšžœ˜K˜—K˜K˜—K˜šŸœžœ ขt 
ข 
ข4 œ˜๗
Kš
œ˜K˜šŸœžœžœžœ˜AKšœžœ
žœ
˜šžœ˜	šžœ
žœ˜Kšžœ
žœ
žœ ˜4K˜—Kš
œ,˜,š
ž˜Kšœžœ
˜Kš	œžœ
žœžœ
žœ˜BKšœžœ,˜>Kšžœžœ
žœ
˜Kš
œ:˜:šžœžœ˜&šžœžœ˜Kšœ.ก
˜/K˜4Kš
œ
˜
—Kšžœf˜jKš
œ˜—Kšžœ
˜—˜
K™+K™Kšžœ
žœ
žœ
˜Kšœ	žœžœžœ&˜OKš
œ˜Kšœžœ ˜(Kšœ
žœžœ˜)šžœ
žœ˜K˜.K˜5K˜—šžœžœ
žœ˜Kšœ
žœ!˜4Kšœžœžœžœ˜XKšœžœ˜6K˜—K˜—Kš
œ#˜#Kšœ)žœ
˜-K˜—K˜K˜—Kšœžœ
˜Kš
œ˜Kšœ\žœ˜uK˜Kšžœžœ
žœ5˜GK˜K˜—š
Ÿœžœžœžœžœ˜hšœžœž˜Kšœžœ˜Kšžœžœ˜—Kš
œ˜K˜—šŸœ  Nœ˜…
Kšœžœ
 ˜/Kšœžœ˜!Kš
œ˜K˜—šŸœ! Rœ˜‹
Kšœžœ
 ˜/Kšœžœ˜!Kš
œ˜K˜—šŸ
œ -œ˜XKšœžœ
 ˜/K˜K˜Kš
œ˜Kšœ9žœžœ
žœžœ
žœ
žœ
žœ˜‘
Kš
œ˜Kšžœžœ
žœ
žœ*˜AKšžœ
žœžœ˜Kš
œ˜K˜—šŸœ “
œ˜ฒ
Kšœžœ
 ˜/Kš
œ˜K˜—šŸœ Bœ˜sKšœžœ
 ˜/K˜Kš
œ˜K˜—šŸœ' Gœ˜Œ
Kšœžœ
 ˜/Kšœžœžœžœ
˜5šžœ
žœ˜Kšœžœ%˜-šžœ
žœ˜K˜.K˜aK˜—Kš
œ˜—šžœ.žœ
žœ™>K™5Kš
œ6™6Kš
œh™hKšœžœ0™8Kš
œ™—Kš
œ˜K˜—šŸœ! Uœžœ˜–
Kšœžœ
 ˜/Kšœžœžœžœ
˜5Kš
œ˜Kšœžœ ˜(šžœ
žœ˜K˜.K˜BK˜—šžœ
žœ
žœ
˜š
œ)˜)Kšžœžœžœ˜<Kš
œ˜—š
œ*˜*Kšžœ ˜&Kš
œ˜—š
œ*˜*Kšžœ ˜&Kš
œ˜—Kšžœžœ
žœ˜—Kš
œ˜K˜—šŸœ) 7œžœ˜ˆ
Kšœžœ
 ˜/Kšœžœžœžœ
˜5Kš
œ˜Kšœžœ ˜(Kšžœ
žœ2žœ
žœ
˜DKšžœ
žœ'žœžœžœ
žœ
˜YKš
œ6˜6Kš
œ˜K˜—šŸœžœ
žœ>žœ	žœ
žœžœžœ
žœž	œ˜ฃ
Kšœ
žœ
 ˜,Kšœžœžœ˜&Kšœžœ˜Kšœ	žœ
˜K˜šŸœžœ
žœžœ
žœžœžœžœ˜PKšžœ
žœžœ
˜Kš
œ,˜,Kš
œ+˜+šžœžœ˜ Kšœžœ-˜5šžœ	žœ˜K˜Kšžœ˜Kš
œ˜—Kš
œ˜—Kšœ(žœ ˜Pšžœžœ˜K˜Kšžœ˜Kš
œ˜—Kšžœ'žœ'˜TK˜—K˜Kšžœžœ
žœ0˜VK˜K˜—šœ	žœ˜%K˜—šŸœžœ>žœžœ
žœ
žœžœžœ˜™
Kšœ
žœ
 ˜,Kšœžœžœ˜&Kšœžœ˜Kšœ	žœ
˜K˜šŸœžœ
žœžœ
žœžœžœ˜IKšžœ
žœžœ
˜Kš
œ,˜,Kš
œ+˜+šžœžœ˜ Kšœžœ-˜5šžœ	žœ˜K˜Kšžœ˜Kš
œ˜—Kš
œ˜—Kšœ,žœ$˜Xšžœžœ˜K˜Kšžœ˜Kš
œ˜—Kšžœ'žœ*˜WK˜—Kš
œ˜Kšžœžœ
žœ1˜XKš
œ˜K˜—šŸœ ถ
œ˜ี
Kšœžœ
 ˜/Kšœžœ.žœEžœ ˜บ
Kšœžœ
˜K˜Kšœžœ
˜Kšœžœ
˜šžœž˜š
œ	˜	Kš
œ˜Kš
œ›
˜›
š
œ
˜
Kšœžœ˜%Kšœ8žœ˜MKšžœ
˜Kš
œ˜—Kš
œ0˜0Kš
œ4˜4K˜!Kšœžœ˜$Kšžœ˜K˜—š
œ˜KšœXžœžœ˜fKš
œ4˜4Kš	œRžœžœžœžœ˜
Kšžœžœžœ$˜KKšœžœžœ˜4Kšžœ˜Kš
œ˜—š
œ
˜
Kš
œ+˜+šžœžœžœ˜>KšœXžœžœ˜dKš
œ4˜4Kš	œRžœžœžœžœ˜
Kšžœžœžœ$˜KKšœžœžœ˜4Kš
œ
˜
—šžœ˜Kšœ“
žœžœžœ˜ฝ
šžœžœ
žœ˜Kš
œv˜vKš
œ˜—š
œ
˜
Kšœžœ˜%Kšœ8žœ˜KKšžœ
˜Kš
œ˜—Kš
œ4˜4Kšœžœ˜$Kš
œ˜—Kš
œ4˜4Kšžœ˜Kš
œ˜—š
œ˜Kš
œ’
˜’
šžœžœ
žœ˜Kš
œx˜xKš
œ˜—š
œ
˜
Kšœžœ˜%KšœTžœ˜gKšžœ
˜Kš
œ˜—Kš
œ4˜4Kšœžœ˜$Kšžœ˜K˜—Kšžœžœ
˜—Kš
œ˜K˜—šŸ	œ …
œ˜จ
Kš
œ˜K˜Kšœ
žœ
˜K˜K˜šŸœžœ˜Kšœžœ
˜Kšœ,žœ	žœ˜@Kšœcžœ˜jKšžœžœV˜gšžœž˜(Kš
œ+˜+Kšœžœ
˜KšžœQ˜X—K˜š
œ
˜
Kšœžœžœ˜-Kšžœžœ
žœTžœ%˜’
KšœKžœžœ A˜š
Kš
œ˜—Kšœžœ
˜K˜K˜—šŸ	œžœžœ˜Kšœžœ
˜šžœž˜Kšœ;žœ˜@Kšžœ/ ˜<—šžœžœ˜Kšœ4žœ˜:Kš
œ˜K˜—Kšœ žœ
˜$K˜K˜—K˜šžœ˜	šžœ
žœ˜Kšžœžœ
žœ˜+K˜—K˜K˜Kš
œ3˜3K˜—K˜Kš
œ˜K˜—šŸœ 0œ˜QKšœžœ
 ˜1Kšœžœžœžœ
˜3Kšœžœ˜Kšœ	žœ
˜K˜šŸœžœ
žœžœ
žœžœžœ˜IKšžœ
žœžœ
˜Kšœžœ
˜	Kš
œ+˜+K™pšžœžœ˜K˜šžœ
žœžœ
žœ˜6K˜Kšžœ˜%Kš
œ˜—K˜—Kšžœžœ
žœ0˜SKš
œ˜šžœ
žœ˜K˜Kšžœ˜Kš
œ˜—K˜—Kšžœžœ
žœ1˜XKš
œ˜K˜—šŸœžœ3žœ˜HKš
œ5˜5Kš
œh˜hšžœ-žœ
žœ8žœ˜uK˜.K˜NKš
œ˜—Kš
œ˜K˜—šŸœžœ  ขF œ˜Œ
Kšœžœ
 ˜/Kšœžœžœžœ
˜5šžœ
žœ
žœ
˜š
œ)˜)Kšœ
žœ*˜:Kšœžœžœ˜7Kš
œ˜—š
œ*˜*Kš
œV˜VKš
œ˜—š
œ*˜*Kš
œV˜VKš
œ˜—Kšžœu˜|—Kš
œ˜K˜—šŸœžœ ข* œ˜hKšžœ
žœ˜Kš
œ˜K˜—šŸœžœ  ข* œ˜pK˜4šžœ+žœ˜3K™2Kšžœžœ˜3K˜
—šžœ˜K™1Kšœ
žœ)˜7Kšœ
žœ@˜QKšœ	žœG˜TKšœžœžœ ˜<Kšžœ˜$Kš
œ˜—Kš
œ˜—K˜™KšŸ
œžœžœ
˜K˜Kšœžœ%žœ!˜ZKšœžœ%žœ*žœ˜mK˜šŸ
œžœžœžœ˜AKšžœ,˜2K˜—K˜šœžœžœ˜JKšœžœ ˜$Kšœ+žœ ˜SKšœ,žœ ˜RKšœ*žœ ˜QK˜K˜—šŸœžœžœžœžœžœžœžœ˜tKš
œ0˜0Kš
œ)˜)Kš
œ˜šžœ
žœžœ˜Kš
œ˜Kš
œ˜—Kš
œ˜—K˜š
Ÿ	œžœžœžœ
žœ˜+Kšœžœ˜Kšœžœ
žœ˜+šžœžœ
žœ
ž˜Kš
œ!˜!Kšžœ
˜—Kš
œ˜Kšžœ˜Kš
œ˜——™š
Ÿœžœ
žœžœžœ˜KKšžœžœ
˜4K˜K˜—š
Ÿœžœ
žœžœžœ˜KKšžœ,˜2K˜K˜—šŸœžœ
žœžœ˜Xšžœžœž˜Kš
œ˜Kš
œ˜Kšžœ*˜1—K˜K˜——™šŸœžœžœžœžœžœ˜YKšœžœ˜"KšœPžœ	˜^K˜K˜—Kšœžœ˜$Kšœžœ˜#Kšœžœ'˜EKšœžœ˜$Kšœžœ:˜UK˜šŸœžœžœžœ"˜RKšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ˜!Kš
œ˜Kš	žœ)žœžœ
žœ ˜MKš
œ:˜:Kšžœ
žœ˜&Kš
œ=˜=Kšžœ,žœ
žœ
˜:šžœ6˜8Kšžœq˜uKšžœJ˜N—š
œ:˜:Kšœ'žœ˜3—Kšžœžœ-˜FK˜K˜—K˜—š
žœžœžœžœ
žœ
˜-Kšžœ˜K˜K˜—š
žœžœžœžœ
žœ
˜-Kšžœ˜#K˜K™—šžœžœžœ
˜Kš
œ˜K˜K™——™™
Kšœžœ˜"—™Kšœ	žœžœ˜"šœžœžœ˜Kšœžœ
˜Kšœžœ
žœ
žœ˜(K˜—Kšœ
žœžœ ˜Fš
œžœžœ
žœžœ ˜dK˜—Kšœ
žœ$˜2šœžœžœ˜Kšœžœ ˜)Kš
œ˜Kš
œ˜K˜K˜—šŸœžœžœ˜KKšžœžœ
žœ	žœ4˜Qšžœ˜Kšžœ˜šžœ˜Kšœ	žœžœ˜3Kšœ	žœ˜%šžœžœ
žœž˜%K˜Kšžœ
˜—K˜K˜——Kš
œ ˜ K˜K˜K˜——K˜K™KšŸœžœ
žœžœ
™)Kšœžœžœ
žœ˜.K˜š
Ÿ	œžœžœžœžœ˜`K™sKšœžœ
˜Kš
œ˜Kšœžœ
˜Kšœžœ
˜K˜@šŸœžœ$žœ
žœžœ$žœžœžœžœ˜ฆ
K™oKš	œžœ5žœžœžœ1˜
šžœžœ
ž˜K˜—šžœ˜Kšœžœ
˜Kšœ
žœ
˜Kš
œ˜Kšœžœžœ
˜K˜
Kšœ
žœ
˜Kšœžœ˜%Kšœ	žœ˜K˜šžœž˜%Kš
œ<˜<—Kš
œ^˜^Kš
œ5˜5Kš
œ'˜'Kšžœžœ
žœ2˜HKšœ0žœ˜WK˜—K˜K˜—Kš	œ
žœžœžœžœ˜HKšœžœ
žœ˜&K˜šŸœžœžœ%žœžœžœžœ˜mJ™^Kšœžœ?žœ˜UKšœ	žœ!˜-KšœžœKžœ˜rKšœžœ-˜BKšœžœ
˜Kšœ%žœžœ
˜0Kš
œ˜K˜šŸœ˜'Jš
œR™RKš
œ$˜$K˜Kšžœ3žœ
žœ
žœ˜Hšžœ
žœ
ž˜šœ$žœ˜DK˜K˜—š
œ%˜%šžœžœž˜?Kšžœ
žœ˜
—Jš
œ(™(šžœžœ
ž˜šžœ(žœž˜9Kšœžœ
˜K˜$Kšžœ
˜——J™šžœ!žœžœ˜0J™9šžœ.žœ˜6Kšžœ5žœ˜AK˜
—šžœ˜Kšœ
žœžœ
˜Kšœžœ
˜ Kš
œ5žœžœ
žœžœ
žœžœ˜…
šžœ	žœ
žœ˜Kš
œŽ
˜Ž
K˜K˜—Kšžœ˜K˜—K˜—K˜—š
œ(˜(J™3šžœ.ž˜4Kšžœ
žœ˜
—Jš
œ(™(šžœžœ
ž˜šžœ(žœž˜9Kšœžœ
˜K˜$Kšžœ
˜——Jš
œ™šžœ!žœžœ˜0Jš
œ™Kš
œ˜šžœž˜˜Jš
œ™Kš
œ*˜*K˜—˜Jš
œ™šžœž˜Kš
œ*˜*—K˜—˜šžœ
žœ žœžœ˜2Kš
œ*˜*Kš
œ˜—Kš
œ+˜+K˜—˜šžœ
žœ žœžœ˜2K˜	Kš
œ˜—Kš
œ+˜+K˜—Kšžœžœ
˜—šžœžœ
žœ˜Kšžœ<žœ˜LK˜—K˜—K˜—Kšžœžœ
˜—K˜—J™J™šžœ+ž˜1Kšžœ
˜—J™น
Kšžœžœ4˜HKšœ:žœ˜Ašžœ
žœ
žœ˜0Kšžœžœ?žœ˜T—K˜—K˜K™˜
šžœ˜šžœ˜Kšžœžœ
žœ!žœ
˜5K˜—K˜—šžœ žœ
 ˜9Kš
œ,˜,—K™†
Kš
œ\˜\šžœžœ
ž˜Kš
œ+˜+—K˜—Kšžœžœ
žœ˜+K˜K˜—šŸœžœžœžœžœžœ	˜oK™๙
šžœ
žœ˜Kšžœžœ
žœ˜+K˜—Kšœžœ˜(Kšœ	žœ
˜Kšœžœ
˜Kšœžœ
˜ Kšœžœ˜šŸœ @œ˜lšžœ
žœ
ž˜šœ2žœ˜GKšœžœ
˜K˜—Kš
œ9™9šœ$žœ˜DKš
œ*˜*Kšœžœ
˜K˜—Kšžœžœ˜—K˜—Kš
œ˜Kšœ@žœžœ˜VK™Fšžœžœ*ž˜BKšœUžœ˜[šžœ ž˜&Kšžœ
˜—K˜:Kšœ9žœ˜@Kš
œo˜oKš
œ=žœžœžœžœ"žœžœ
˜ฑ
Kšžœžœ
žœ
žœ
˜Kšžœ
˜—K™lKšœฯt˜Kš
œ˜K˜K˜—šŸœžœžœ˜8K™4Kšžœ2žœ(˜hK˜——™K˜#Kš
œ+˜+K˜—K˜—…—รส