
DIRECTORY
Basics,
FinalizeOps,
IO USING [Close, STREAM],
List,
PFS,
PFSBackdoor,
PFSExtras,
PFSPrivate,
PFSCanonicalNames,
PFSCFSNames,
PFSClass,
PFSPrefixMap,
PFSNames,
PreDebug,
Process,
ProcessProps,
Rope USING [Cat, EqualSubstrs, IsEmpty, Fetch, Find, Length, ROPE],
UnixTypes USING [FD];


PFSImpl: CEDAR MONITOR
IMPORTS FinalizeOps, IO, List, PFS, PFSBackdoor, PFSCanonicalNames, PFSCFSNames, PFSClass, PFSNames, PFSPrefixMap, PFSPrivate, PreDebug, Process, ProcessProps, Rope
EXPORTS PFS, PFSExtras, PFSBackdoor
~ BEGIN OPEN PFS;

ROPE: TYPE ~ Rope.ROPE;
STREAM: TYPE ~ IO.STREAM;
PATH: TYPE ~ PFSNames.PATH;
OpenFileObject: PUBLIC TYPE = PFSClass.OpenFileObject;

Error: PUBLIC ERROR [error: PFS.ErrorDesc] ~ CODE;

AtomFromErrorGroup: PUBLIC PROC[eg: ErrorGroup] RETURNS[ATOM] ~ {
SELECT eg FROM
ok => RETURN[$ok];
bug => RETURN[$bug];
environment => RETURN[$environment];
client => RETURN[$client];
user => RETURN[$user];
ENDCASE => RETURN[$NIL];
};

ErrorGroupFromAtom: PUBLIC PROC[at: ATOM] RETURNS[ErrorGroup] ~ {
SELECT at FROM
$ok => RETURN[ok];
$bug => RETURN[bug];
$environment => RETURN[environment];
$client => RETURN[client];
$user => RETURN[user];
ENDCASE => RETURN[ErrorGroup.LAST];
};
RopeFromPath: PUBLIC PROC [path: PATH, format: NameFormat Ź slashes] RETURNS [rope: ROPE] ~ {
IF path=NIL THEN RETURN[NIL];
rope Ź IF format = slashes THEN PFSCanonicalNames.UnparseName[path] ELSE PFSCFSNames.UnparseName[path];
};
PathFromRope: PUBLIC PROC [rope: ROPE] RETURNS [path: PATH] ~ {
IF rope.IsEmpty[] THEN RETURN[NIL]
ELSE {
c0: CHAR Ź rope.Fetch[0];
SELECT c0 FROM
'[ => RETURN[PFSCFSNames.ParseName[rope]];
'/ => RETURN[PFSCanonicalNames.ParseName[rope]];
ENDCASE => IF rope.Find["/"] > 0 THEN RETURN[PFSCanonicalNames.ParseName[rope]] ELSE RETURN[PFSCFSNames.ParseName[rope]];
};
};
wDirKey: ATOM ~ $WorkingDirectory; -- val: [wDir: ROPE]

DoInWDir: PUBLIC PROC [ wDir: PATH, inner: PROC ] ~ {
wDirRope: ROPE ~ RopeFromPath[wDir];
propList: List.AList ~ List.PutAssoc[key: wDirKey, val: wDirRope, aList: NIL];
ProcessProps.AddPropList[propList: propList, inner: inner];
};

GetWDir: PUBLIC PROC RETURNS [ wDir: PATH ] ~ {
wDirRope: ROPE ~ GetWorkingDirectoryRope[];
wDir Ź PathFromRope[wDirRope];
};

AbsoluteName: PUBLIC PROC [short: PATH, wDir: PATH Ź NIL] RETURNS [absolute: PATH] ~ {
SELECT TRUE FROM
PFSNames.IsAbsolute[short] => absolute Ź short;
wDir#NIL => absolute Ź wDir.Cat[short];
ENDCASE => absolute Ź PFSNames.Cat[GetWDir[], short];
absolute Ź ResolveRelativeComponents[absolute];
};


ResolveRelativeComponents: PROC [path: PATH] RETURNS [PATH] ~ {
anyRelative: BOOL Ź FALSE;
FOR i: CARD IN [0..PFSNames.ComponentCount[path]) DO
comp: PFSNames.Component ~ path.Fetch[i];
IF Rope.EqualSubstrs[comp.name.base, comp.name.start, comp.name.len, "."] OR Rope.EqualSubstrs[comp.name.base, comp.name.start, comp.name.len, ".."] THEN {
anyRelative Ź TRUE; EXIT;
};
ENDLOOP;
IF anyRelative THEN {
comps: LIST OF PFSNames.Component Ź NIL;
FOR i: CARD IN [0..PFSNames.ComponentCount[path]) DO
comp: PFSNames.Component ~ path.Fetch[i];
SELECT TRUE FROM
Rope.EqualSubstrs[comp.name.base, comp.name.start, comp.name.len, "."] => NULL;
Rope.EqualSubstrs[comp.name.base, comp.name.start, comp.name.len, ".."] => {
comps Ź IF comps=NIL THEN NIL ELSE comps.rest;
};
ENDCASE => comps Ź CONS[comp, comps];
ENDLOOP;
RETURN[ PFSNames.ConstructName[components~comps, absolute~path.IsAbsolute[], directory~path.IsADirectory[], reverse~TRUE] ];
}
ELSE RETURN[ path ];
};

GetWorkingDirectoryRope: PROC RETURNS [ wDirRope: ROPE ] ~ {
propList: List.AList ~ ProcessProps.GetPropList[];
WITH List.Assoc[key: wDirKey, aList: propList] SELECT FROM
rope: ROPE => { wDirRope Ź rope };
ENDCASE;
IF ( wDirRope.IsEmpty[] ) THEN wDirRope Ź PFSPrivate.GetDefaultWDirRope[];
};

FileInfo: PUBLIC PROC [
name: PATH, 
wantedUniqueID: UniqueID Ź nullUniqueID 
] RETURNS [
fullFName, attachedTo: PATH, 
uniqueID: UniqueID,
bytes: INT, 
mutability: Mutability,
fileType: FileType
] ~
{
fs: PFSClass.FSHandle;
nameOnFS: PATH;
replacedPrefix: PATH;
suppliedPrefixLen: INT;
success: BOOL Ź TRUE;
version: PFSNames.Version;
absoluteName: PATH ~ AbsoluteName[name];
[fs, nameOnFS, replacedPrefix, suppliedPrefixLen] Ź ServerAndHints[absoluteName];
[version, attachedTo, bytes, uniqueID, mutability, fileType] Ź fs.procs.fileInfo[fs, nameOnFS, wantedUniqueID ];
fullFName Ź PFSNames.SetVersionNumber[absoluteName, version];
NoteEvent[$fileInfo, fullFName];
};
EnumerateForInfo: PUBLIC PROC [pattern: PATH, proc: InfoProc, lbound: PATH, hbound: PATH] ~
{
fs: PFSClass.FSHandle;
patternOnFS: PATH;
replacedPrefix: PATH;
suppliedPrefixLen: INT;
NameTranslator: InfoProc ~ {
IF lbound # NIL AND PFSNames.Compare[fullFName, lbound]=less THEN RETURN [TRUE];
IF hbound # NIL AND PFSNames.Compare[fullFName, hbound]=greater THEN RETURN [FALSE];
RETURN [ 
proc[ 
BackTranslate[fullFName, replacedPrefix, suppliedPrefixLen],
attachedTo, uniqueID, bytes, mutability, fileType] 
];
};
IF lbound # NIL THEN lbound Ź DoServer[AbsoluteName[lbound]].nameOnFS;
IF hbound # NIL THEN hbound Ź DoServer[AbsoluteName[hbound]].nameOnFS;
[fs, patternOnFS, replacedPrefix, suppliedPrefixLen] Ź ServerAndHints[AbsoluteName[pattern]];
fs.procs.enumerateForInfo[fs, patternOnFS, NameTranslator, lbound, hbound];
};

EnumerateForNames: PUBLIC PROC [pattern: PATH, proc: NameProc, lbound: PATH, hbound: PATH] ~
{
fs: PFSClass.FSHandle;
patternOnFS: PATH;
replacedPrefix: PATH;
suppliedPrefixLen: INT;
NameTranslator: NameProc ~ {
IF lbound # NIL AND PFSNames.Compare[name, lbound]=less THEN RETURN [TRUE];
IF hbound # NIL AND PFSNames.Compare[name, hbound]=greater THEN RETURN [FALSE];
RETURN [ 
proc[BackTranslate[name, replacedPrefix, suppliedPrefixLen]]
];
};
IF lbound # NIL THEN lbound Ź DoServer[AbsoluteName[lbound]].nameOnFS;
IF hbound # NIL THEN hbound Ź DoServer[AbsoluteName[hbound]].nameOnFS;
[fs, patternOnFS, replacedPrefix, suppliedPrefixLen] Ź ServerAndHints[AbsoluteName[pattern]];
fs.procs.enumerateForNames[fs, patternOnFS, NameTranslator, lbound, hbound];
};

BackTranslate: PROC [name, newPrefix: PATH, replacePrefixLen: CARD] RETURNS [PATH] ~ {
RETURN [ 
PFSNames.Cat[newPrefix, PFSNames.SubName[name, replacePrefixLen]]
]; 
};

FileLookup: PUBLIC PROC [name: PATH, tryExtensions: LIST OF ROPE] RETURNS [fullPath: PATH Ź NIL ] ~
{
fs: PFSClass.FSHandle;
nameOnFS: PATH;
replacedPrefix: PATH;
suppliedPrefixLen: INT;
[fs, nameOnFS, replacedPrefix, suppliedPrefixLen] Ź ServerAndHints[AbsoluteName[name]];
fullPath Ź fs.procs.lookupName[fs, nameOnFS ! PFS.Error => CONTINUE ];
IF fullPath = NIL THEN {
FOR extList: LIST OF ROPE Ź tryExtensions, extList.rest WHILE extList# NIL DO
ext: ROPE Ź extList.first;
IF( fullPath Ź fs.procs.lookupName[fs, AddExt[nameOnFS, ext] 
! PFS.Error => CONTINUE]) # NIL 
THEN EXIT;
ENDLOOP; 
};
IF fullPath # NIL THEN 
fullPath Ź BackTranslate[fullPath, replacedPrefix, suppliedPrefixLen]; 
};

FileSearch: PUBLIC PROC [name: PATH, searchRules: LIST OF -- Directory -- PATH] RETURNS [fullPath: PATH] ~
{
IF  name.IsAbsolute[] THEN RETURN[FileLookup[name, NIL]];
FOR dirList: LIST OF PATH Ź searchRules, dirList.rest WHILE dirList # NIL DO
dir: PATH Ź dirList.first;
IF (fullPath Ź FileLookup[PFSNames.Cat[dir, name], NIL]) # NIL THEN RETURN;
ENDLOOP;
RETURN[NIL];
};


Open: PUBLIC PROC [name: PATH, 
access: AccessOptions Ź read,
wantedUniqueID: UniqueID Ź nullUniqueID, 
checkFileType: BOOL Ź FALSE, fileType: FileType Ź tUnspecified,
createOptions: CreateOptions Ź defaultCreateOptions
] RETURNS [OpenFile] ~
{
fs: PFSClass.FSHandle;
nameOnFS: PATH;
openFile: OpenFile;
absoluteName: PATH Ź AbsoluteName[name];
[fs, nameOnFS] Ź DoServer[absoluteName];
openFile Ź fs.procs.open[fs, nameOnFS, wantedUniqueID, access, checkFileType, fileType, createOptions -- ! PFS.Error => IF access=read AND backingName#NIL THEN CONTINUE -- ];
IF openFile#NIL THEN {
openFile.fullFName Ź PFSNames.SetVersionNumber[absoluteName, openFile.fullFName.ShortName[].version]; 
openFile.access Ź access;
IF access # create THEN NoteEvent[$readOpen, openFile.fullFName];
[] Ź FinalizeOps.EnableFinalization[openFile, fq];
RETURN [openFile];
};
RETURN [openFile];
};
Retrieve: PUBLIC PROCEDURE [name: PATH, 
wantedUniqueID: UniqueID Ź nullUniqueID, 
proc: RetrieveConfirmProc, 
checkFileType: BOOL Ź FALSE, fileType: FileType Ź tUnspecified
] ~
{
fs: PFSClass.FSHandle;
nameOnFS: PATH;
absolute: PATH ~ AbsoluteName[name];
[fs, nameOnFS] Ź DoServer[absolute];
NoteEvent[$startRetrieving, absolute];
fs.procs.retrieve[fs, nameOnFS, wantedUniqueID, proc, checkFileType, fileType];
NoteEvent[$endRetrieving, absolute];
};
Store: PUBLIC PROCEDURE [name: PATH, 
wantedUniqueID: UniqueID, 
str: IO.STREAM,
proc: StoreConfirmProc,
createOptions: CreateOptions Ź defaultCreateOptions
] ~
{
fs: PFSClass.FSHandle;
nameOnFS: PATH;
absolute: PATH ~ AbsoluteName[name];
[fs, nameOnFS] Ź DoServer[absolute];
NoteEvent[$startStoring, absolute];
fs.procs.store[fs, nameOnFS, wantedUniqueID, str, proc, createOptions];
NoteEvent[$endStoring, absolute];
};
GetClass: PUBLIC PROC [file: OpenFile] RETURNS [ATOM] ~ 
{
RETURN[$PFS];
};

GetName: PUBLIC PROC [file: OpenFile] RETURNS [fullFName, attachedTo: PATH] ~ 
{
RETURN[file.fullFName, file.attachedTo];
};

GetInfo: PUBLIC PROC [file: OpenFile] RETURNS [
fullFName, attachedTo: PATH, 
uniqueID: UniqueID, 
bytes: INT, 
mutability: Mutability,
fileType: FileType
] ~
{
RETURN file.fs.procs.getInfo[file.fs, file];
};

SetAttributes: PUBLIC PROC [file: OpenFile, attributes: CreateOptions] ~
{
file.fs.procs.setAttributes[file.fs, file, attributes];
};

SetByteCountAndUniqueID: PUBLIC PROC [
file: OpenFile, 
bytes: INT Ź -1, 
uniqueID: UniqueID Ź nullUniqueID
] ~
{
file.fs.procs.setByteCountAndUniqueID[file.fs, file, bytes, uniqueID];
};

Read: PUBLIC UNSAFE PROC [file: OpenFile, filePosition, nBytes: CARD, to: POINTER TO Basics.RawBytes, toStart: CARD Ź 0] RETURNS [bytesRead: INT] ~
UNCHECKED {
RETURN [ file.fs.procs.read[file.fs, file, filePosition, nBytes, to, toStart] ];
};

Write: PUBLIC PROC [file: OpenFile, filePosition, nBytes: CARD, from: POINTER TO Basics.RawBytes, fromStart: CARD Ź 0] RETURNS [bytesWritten: INT] ~ {
TRUSTED {RETURN [ file.fs.procs.write[file.fs, file, filePosition, nBytes, from, fromStart] ]};
};

Close: PUBLIC PROC [file: OpenFile] ~
{
NewClose[file, FALSE];
};

NewClose: PUBLIC PROC [file: OpenFile, abort: BOOL _ FALSE] ~
{
file.state Ź closed;
file.fs.procs.close[file.fs, file, abort];
IF file.access # read THEN NoteEvent[$writeClose, file.fullFName];
};
Attach: PUBLIC PROC [attachment, attachedFile: PATH, 
keep: CARDINAL Ź 0, -- no keep processing
wantedUniqueID: UniqueID Ź nullUniqueID, 
remoteCheck: BOOL Ź TRUE 
] 
RETURNS [toFName: PATH] ~
{
fs: PFSClass.FSHandle;
attachmentOnFS: PATH;
absoluteTo: PATH ~ AbsoluteName[attachment];
[fs, attachmentOnFS] Ź DoServer[absoluteTo];
IF fs.procs.attach=NIL THEN ProduceError[notImplemented, "Attachments not implemented in this view", fs];
NoteEvent[$startCopying, absoluteTo];
toFName Ź fs.procs.attach[fs, attachmentOnFS, attachedFile, keep, wantedUniqueID, remoteCheck];
NoteEvent[$endCopying, absoluteTo];
};

Delete: PUBLIC PROC [name: PATH, 
wantedUniqueID: UniqueID Ź nullUniqueID,
confirmProc: NameConfirmProc 
] ~
{
fs: PFSClass.FSHandle;
nameOnFS: PATH;
replacedPrefix: PATH;
suppliedPrefixLen: INT;
NameTranslator: NameConfirmProc ~ {
RETURN [ 
confirmProc[BackTranslate[fullName, replacedPrefix, suppliedPrefixLen], uniqueID]
];
};
absolute: PATH ~ AbsoluteName[name];
[fs, nameOnFS, replacedPrefix, suppliedPrefixLen] Ź ServerAndHints[absolute];
NoteEvent[$startDeleting, absolute];
fs.procs.delete[fs, nameOnFS, wantedUniqueID, IF confirmProc#NIL THEN NameTranslator ELSE NIL];
NoteEvent[$endDeleting, absolute];
};

Rename: PUBLIC PROC [from, to: PATH, 
wantedUniqueID: UniqueID Ź nullUniqueID,
createOptions: CreateOptions Ź defaultCreateOptions,
confirmProc: NameConfirmProc 
] ~
{
fromFS, toFS: PFSClass.FSHandle;
fromNameOnFS, toNameOnFS: PATH;
replacedPrefix: PATH;
suppliedPrefixLen: INT;
NameTranslator: NameConfirmProc ~ {
RETURN [ 
confirmProc[BackTranslate[fullName, replacedPrefix, suppliedPrefixLen], uniqueID]
];
};
done: BOOL Ź FALSE;
absoluteTo: PATH ~ AbsoluteName[to];
[fromFS, fromNameOnFS] Ź DoServer[AbsoluteName[from]];
[toFS, toNameOnFS, replacedPrefix, suppliedPrefixLen] Ź ServerAndHints[absoluteTo];
NoteEvent[$startRenaming, absoluteTo];
IF fromFS=toFS THEN {
done Ź fromFS.procs.rename[fromFS, fromNameOnFS, wantedUniqueID, toNameOnFS, createOptions, IF confirmProc#NIL THEN NameTranslator ELSE NIL];
};
IF NOT done THEN {
ProduceError[notImplemented, "File rename requiring copying is not yet implemented"]
};
NoteEvent[$endRenaming, absoluteTo];
};


Copy: PUBLIC PROC [from, to: PATH, 
wantedUniqueID: UniqueID Ź nullUniqueID,
createOptions: CreateOptions Ź defaultCreateOptions,
confirmProc: NameConfirmProc 
] ~
{
fromFS, toFS: PFSClass.FSHandle;
fromNameOnFS, toNameOnFS: PATH;
replacedPrefix: PATH;
suppliedPrefixLen: INT;
CopyNameTranslator: NameConfirmProc ~ {
RETURN [ 
IF confirmProc#NIL THEN confirmProc[BackTranslate[fullName, replacedPrefix, suppliedPrefixLen], uniqueID] ELSE TRUE
];
};
StoreNameTranslator: StoreConfirmProc ~ {
RETURN [ 
IF confirmProc#NIL THEN confirmProc[BackTranslate[fullName, replacedPrefix, suppliedPrefixLen], wantedUniqueID] ELSE TRUE
];
};
done: BOOL Ź FALSE;
toStream, fromStream: IO.STREAM;
absoluteTo: PATH ~ AbsoluteName[to];
[fromFS, fromNameOnFS] Ź DoServer[AbsoluteName[from]];
[toFS, toNameOnFS, replacedPrefix, suppliedPrefixLen] Ź ServerAndHints[absoluteTo];
NoteEvent[$startCopying, absoluteTo];
IF fromFS=toFS THEN {
done Ź fromFS.procs.copy[fromFS, fromNameOnFS, wantedUniqueID, toNameOnFS, createOptions, IF confirmProc#NIL THEN CopyNameTranslator ELSE NIL];
};
IF NOT done THEN {
ENABLE UNWIND => {
IF toStream # NIL THEN IO.Close[toStream ! PFS.Error => CONTINUE];
IF fromStream # NIL THEN IO.Close[fromStream ! PFS.Error => CONTINUE];
};
fromStream Ź PFS.StreamOpen[fileName~from, accessOptions~read, wantedUniqueID~wantedUniqueID, streamOptions~[includeFormatting: TRUE, closeFSOpenFileOnClose: TRUE]];
IF wantedUniqueID=nullUniqueID THEN wantedUniqueID Ź GetInfo[OpenFileFromStream[fromStream]].uniqueID;
toFS.procs.store[toFS, toNameOnFS, wantedUniqueID, fromStream, StoreNameTranslator, createOptions];
IO.Close[fromStream];
};
NoteEvent[$endCopying, absoluteTo];
};

SetClientProperty: PUBLIC PROC [file: OpenFile, propertyName: ROPE, propertyValue: ROPE] ~
{
file.fs.procs.setClientProperty[file.fs, file, propertyName, propertyValue];
};
GetClientProperty: PUBLIC PROC [file: OpenFile, propertyName: ROPE] RETURNS [propertyValue: ROPE] ~
{
RETURN[file.fs.procs.getClientProperty[file.fs, file, propertyName]];
};

EnumerateClientProperties: PUBLIC PROC [file: OpenFile, proc: PropProc] ~
{
file.fs.procs.enumerateClientProperties[file.fs, file, proc];
};
PFSNameToUnixName: PUBLIC PROC [ file: PATH ] RETURNS [ ROPE ] ~ {
fs: PFSClass.FSHandle;
patternOnFS: PATH;
proc: PFSClass.PFSNameToUnixNameProc;
[fs, patternOnFS] Ź ServerAndHints[AbsoluteName[file]];
IF (proc Ź fs.procs.pfsNameToUnixName) # NIL 
THEN RETURN[proc[fs, patternOnFS]] 
ELSE {
ENABLE PFS.Error => GOTO GiveUp;
attachedFile: PATH ~ fs.procs.fileInfo[fs, patternOnFS, nullUniqueID].attachedTo;
IF attachedFile#NIL THEN RETURN[PFSNameToUnixName[attachedFile]];
EXITS
GiveUp => NULL;
};
RETURN[NIL]
};

CaseSensitive: PUBLIC PROC [ file: PATH ] RETURNS [ BOOL ] ~ {
fs: PFSClass.FSHandle;
patternOnFS: PATH;
proc: PFSClass.CaseSensitiveProc;
[fs, patternOnFS] Ź ServerAndHints[AbsoluteName[file]];
IF (proc Ź fs.procs.caseSensitive) # NIL 
THEN RETURN[proc[fs, patternOnFS]] 
ELSE {
message: ROPE ~ Rope.Cat["Class for ", RopeFromPath[file], " doesn't implement case-sensitivity determination."];
ProduceError[notImplemented, message];
RETURN[FALSE]; -- not reached
};
};
codeAtoms: ARRAY PFSBackdoor.ErrorCode OF ATOM Ź ALL[$unknown];

codeGroups: ARRAY PFSBackdoor.ErrorCode OF PFS.ErrorGroup Ź ALL[bug];

ProduceError: PUBLIC PROC [code: PFSBackdoor.ErrorCode, explanation: Rope.ROPE, info: REF Ź NIL] ~ {
codeAtom: ATOM ~ codeAtoms[code];
codeGroup: ErrorGroup ~ codeGroups[code];
ERROR Error[[codeGroup, codeAtom, explanation, info]];
};

ExplainPFSError: PreDebug.Explainer = {
msg Ź "PFS Error";
IF args=NIL THEN RETURN;
PreDebug.Raise[signalOrError, args ! PFS.Error => {
info: ROPE Ź NIL;
IF ~Rope.IsEmpty[error.explanation] THEN msg Ź Rope.Cat[msg, ": ", error.explanation];
WITH error.info SELECT FROM
r: ROPE => info Ź r;
p: PATH => info Ź RopeFromPath[p ! Error => CONTINUE];
ENDCASE => {};
IF ~Rope.IsEmpty[info] THEN msg Ź Rope.Cat[msg, ": ", info];
CONTINUE
}];
};

lastEvent: REF PFSBackdoor.Event Ź NIL;
newEvent: CONDITION;
NoteEvent: ENTRY PROC [op: PFSBackdoor.Op, fName: PFSNames.PATH] ~ {
IF lastEvent = NIL THEN RETURN; -- never activated
lastEvent.chain Ź NEW[PFSBackdoor.Event Ź [op, fName, NIL]];
lastEvent Ź lastEvent.chain;
BROADCAST newEvent;
};

NextEvent: PUBLIC ENTRY PROC [prev: REF READONLY PFSBackdoor.Event] RETURNS [REF READONLY PFSBackdoor.Event] ~ {
ENABLE UNWIND => NULL; -- may abort during wait
IF prev = NIL THEN {
IF lastEvent = NIL THEN lastEvent Ź NEW[PFSBackdoor.Event];
prev Ź lastEvent;
};
UNTIL prev.chain # NIL DO
WAIT newEvent;
ENDLOOP;
RETURN [prev.chain];
};
AtomFromErrorCode: PUBLIC PROC [code: PFSBackdoor.ErrorCode] RETURNS [ATOM] ~
{ RETURN[codeAtoms[code]] };

ErrorCodeFromAtom: PUBLIC PROC [atom: ATOM] RETURNS [PFSBackdoor.ErrorCode] ~ {
RETURN[ SELECT atom FROM
$ok => ok,
$inconsistent => inconsistent,
$resourceLimitExceeded => resourceLimitExceeded,
$ioError => ioError,
$volumeFull => volumeFull,
$noMoreVersions => noMoreVersions,
$serverInaccessible => serverInaccessible,
$connectionRejected => connectionRejected,
$connectionTimedOut => connectionTimedOut,
$badCredentials => badCredentials,
$accessDenied => accessDenied,
$quotaExceeded => quotaExceeded,
$invalidPropertyStorage => invalidPropertyStorage,
$outOfPropertySpace => outOfPropertySpace,
$positionNotInFile => positionNotInFile,
$invalidOpenFile => invalidOpenFile,
$notImplemented => notImplemented,
$fileTypeMismatch => fileTypeMismatch,
$unknownClass => unknownClass,
$unknownFile => unknownFile,
$unknownUniqueID => unknownUniqueID,
$illegalName => illegalName,
$patternNotAllowed => patternNotAllowed,
$versionSpecified => versionSpecified,
$cantUpdateTiogaFile => cantUpdateTiogaFile,
$invalidNameSyntax => invalidNameSyntax,
ENDCASE => LOOPHOLE[BYTE.LAST/2]
];
};
FDFromOpenFile: PROC [file: OpenFile] RETURNS [UnixTypes.FD] ~ {
WITH file.data SELECT FROM
ux: REF PFSBackdoor.UXData => {
ux.fdIndex Ź PFSBackdoor.unreliableIndex;
RETURN[ux.fd];
};
vux: REF PFSBackdoor.VUXData => {
vux.fdIndex Ź PFSBackdoor.unreliableIndex;
RETURN[vux.fd];
};
ENDCASE;
PFSBackdoor.ProduceError[notImplemented, "FDFromOpenFile not implemented for this file"];
RETURN[error];
};
FDFromOpenStream: PUBLIC PROC [self: IO.STREAM] RETURNS [UnixTypes.FD] ~ {
RETURN[FDFromOpenFile[PFS.OpenFileFromStream[self]]];
};
DoServer: PROC [name: PATH] RETURNS [fs: PFSClass.FSHandle, nameOnFS: PATH] ~ {
translation: PFSPrefixMap.PrefixTableEntry Ź PFSPrefixMap.TranslateAndGetHints[name];
IF NOT translation.translation.IsAbsolute[] THEN {
ProduceError[invalidNameSyntax, Rope.Cat["The prefix map produced a relative translation for ", RopeFromPath[name], " and an absolute translation is required."], translation.translation]
};
fs Ź PFSClass.GetFS[translation.fsName ! 
PFSClass.Error => ProduceError[unknownFile, Rope.Cat["The file server for ", RopeFromPath[name], " is unknown or unavailable."], NIL]];
nameOnFS Ź translation.nameOnFS;
};

ServerAndHints: PROC [name: PATH] RETURNS [fs: PFSClass.FSHandle, nameOnFS: PATH, replacedPrefix: PATH, suppliedPrefixLen: INT] ~ {
translation: PFSPrefixMap.PrefixTableEntry Ź PFSPrefixMap.TranslateAndGetHints[name];
IF NOT translation.translation.IsAbsolute[] THEN {
ProduceError[invalidNameSyntax, Rope.Cat["The prefix map produced a relative translation for ", RopeFromPath[name], " and an absolute translation is required."], translation.translation]
};
fs Ź PFSClass.GetFS[translation.fsName ! 
PFSClass.Error => ProduceError[unknownFile, Rope.Cat["The file server for ", RopeFromPath[name], " is unknown or unavailable."], NIL]];
nameOnFS Ź translation.nameOnFS;
replacedPrefix Ź translation.replacedPrefix;
suppliedPrefixLen Ź translation.suppliedPrefixLen;
};

AddExt: PROC [name: PATH, ext: ROPE] RETURNS [newName: PATH] ~ {
newBase: ROPE ~ Rope.Cat[PFSNames.ComponentRope[name.ShortName[]], ".", ext];
newName Ź PFSNames.ReplaceShortName[
name, 
[name~[newBase, 0, newBase.Length[]], version~[none, 0]] 
];
};

fq: FinalizeOps.CallQueue ~ FinalizeOps.CreateCallQueue[Finalizer];
openFilesFinalized: CARD Ź 0;
OpenFilesFinalized: PROC [] RETURNS [CARD] ~ {
RETURN[openFilesFinalized];
};
closedFilesFinalized: CARD Ź 0;
ClosedFilesFinalized: PROC [] RETURNS [CARD] ~ {
RETURN[closedFilesFinalized];
};

Finalizer: FinalizeOps.FinalizeProc ~ {
openFile: REF OpenFileObject Ź NARROW[object];
IF openFile # NIL THEN {
IF openFile.state # closed THEN {
NewClose[file~openFile, abort~TRUE ! PFS.Error => CONTINUE];
openFilesFinalized Ź openFilesFinalized + 1;
}
ELSE closedFilesFinalized Ź closedFilesFinalized + 1;
};
};

InitErrorArrays: PROC ~ {
codeGroups[ok] Ź ok;
FOR i: PFSBackdoor.ErrorCode IN [resourceLimitExceeded..invalidPropertyStorage] DO
codeGroups[i] Ź environment;
ENDLOOP;
FOR i: PFSBackdoor.ErrorCode IN [outOfPropertySpace..fileTypeMismatch] DO
codeGroups[i] Ź client;
ENDLOOP;
FOR i: PFSBackdoor.ErrorCode IN [unknownClass..invalidNameSyntax] DO
codeGroups[i] Ź user;
ENDLOOP;
codeAtoms[ok] Ź $ok;
codeAtoms[inconsistent] Ź $inconsistent;
codeAtoms[resourceLimitExceeded] Ź $resourceLimitExceeded;
codeAtoms[ioError] Ź $ioError;
codeAtoms[volumeFull] Ź $volumeFull;
codeAtoms[noMoreVersions] Ź $noMoreVersions;
codeAtoms[serverInaccessible] Ź $serverInaccessible;
codeAtoms[connectionRejected] Ź $connectionRejected;
codeAtoms[connectionTimedOut] Ź $connectionTimedOut;
codeAtoms[badCredentials] Ź $badCredentials;
codeAtoms[accessDenied] Ź $accessDenied;
codeAtoms[quotaExceeded] Ź $quotaExceeded;
codeAtoms[invalidPropertyStorage] Ź $invalidPropertyStorage;
codeAtoms[outOfPropertySpace] Ź $outOfPropertySpace;
codeAtoms[positionNotInFile] Ź $positionNotInFile;
codeAtoms[invalidOpenFile] Ź $invalidOpenFile;
codeAtoms[notImplemented] Ź $notImplemented;
codeAtoms[fileTypeMismatch] Ź $fileTypeMismatch;
codeAtoms[unknownClass] Ź $unknownClass;
codeAtoms[unknownFile] Ź $unknownFile;
codeAtoms[unknownUniqueID] Ź $unknownUniqueID;
codeAtoms[illegalName] Ź $illegalName;
codeAtoms[patternNotAllowed] Ź $patternNotAllowed;
codeAtoms[versionSpecified] Ź $versionSpecified;
codeAtoms[cantUpdateTiogaFile] Ź $cantUpdateTiogaFile;
codeAtoms[invalidNameSyntax] Ź $invalidNameSyntax;
};

InitErrorArrays[];

TRUSTED {
Process.EnableAborts[@newEvent];
};
PreDebug.RegisterErrorExplainer[PFS.Error, ExplainPFSError];
END.


     
PFSImpl.mesa
Copyright Ó 1989, 1990, 1991, 1992 by Xerox Corporation.  All rights reserved.
Carl Hauser, July 26, 1989 10:25:31 am PDT
Chauser, March 20, 1992 2:06 pm PST
Christian Jacobi, July 24, 1992 2:51 pm PDT
Willie-s, September 1, 1992 1:24 pm PDT
Michael Plass, January 29, 1992 10:27 am PST
Doug Wyatt, April 7, 1992 1:39 pm PDT

Copied Types and Constants
Exported to PFS
File Names
This is a quick hack implementation.  Let's do it right someday.

Working Directory
backing: PATH _ NIL;
BackingName: PROC [short: PATH] RETURNS [absolute: PATH] ~ {
SELECT TRUE FROM
backing=NIL => RETURN[NIL];
PFSNames.IsAbsolute[short] => RETURN[NIL];
ENDCASE => absolute _ PFSNames.Cat[backing, short];
absolute _ ResolveRelativeComponents[absolute];
};

SetBacking: PROC [ backingRope: ROPE ] ~ {
backing _ PathFromRope[backingRope];
};
gets the $WorkingDirectory property from the process property list;
if empty, uses the default working directory

File Information

Enumeration
Opening Files
backingName: PATH _ BackingName[name];
[fs, nameOnFS] _ DoServer[backingName];
openFile _ fs.procs.open[fs, nameOnFS, wantedUniqueID, access, checkFileType, fileType, createOptions];
openFile.fullFName _ PFSNames.SetVersionNumber[backingName, openFile.fullFName.ShortName[].version]; 
[] _ FinalizeOps.EnableFinalization[openFile, fq];
Store and Retrieve
Operations On Open Files
exported to PFSExtras; eventually PFS.Close should have this signature
General File Manipulations


Exported to PFSExtras
try for an attachment
Exported to PFSBackdoor
Events

Error Codes
FD from file/stream
This does not lock the OpenFile's data - the client had better beware of concurrent access, anyway!


Private Procedures
codeGroups array is initalized to bug
codeGroups[inconsistent] Ź bug;
codeAtoms array is initialized to $unknown
 Ęë  (cedarcode) styleNewlineDelimiter
 Icode
ĎeCNK*K#K+K'K,K%J K Ďk		KKK	KKKK
KKKK	KK		K		KKK3CK
K K KĐlnK¤K#K headKKK6K Ďn2K 
 AKKK$K

KKKK  AKKK$K	K	K#K
K@
  ]K
K%gKK 
 ?K"KK*K$0K$yKKK	Ďc7K code2 		5M
$MINM;;MM  	/M
+KKK  	VK//K'K.5K//KK K	K 
 	<KK*K,3K//KK  
*K$$KK 
 ?K$4K))HIKKKK($4K))KJOLLK.KK%KKn|KK	KK  <KCK,K22+:K"KK,JKK L K 	.1ÇKK
KKK	KK(KQKpK=K KK K
 
[KKKK K
*PK
-T	K<<K33KKK
2FK
2FK]]KKKKK K
 
\KKKK K
%KK
(O	K<<KKK
2FK
2FK]]KLLKK  V	KAAKKK K 
cKK
KKKWWK.
F

MKK>
^K
K	KKGGKK K 
ĄjK9
LKK
1KKKKK K K Z[ňKK
KK(K&K((KfĄEŽ
KffKK*AK2KKK''KggKeeK2KKM
 X'ąKK
K
$K$K&KOK$KM
 #Q KK
K
$K$K#KGK!KK 8KKK K NK"(KK K
 1K&,KK K .HK77KK K -oKFFKK K (	KJPKK  (KP_KK K %JKK K
 =KFKK*K(BKK 	Ą7ŔKKK,K,KNiK%K_K#KK K K K MlKK
KK #	KQQKKK
$KMK$K._K"KK K K ĽK  KKK #	KQQKKKK$K66KSK&K\KKTTKK$KK K K ŁK  KKK '	K	SsKK )	K	YyKKKK K$K6KSK%KZKK
BK
FKKpĽKCfKccKKK#KK K  ZKLLKK K
  cK?EKK K #IK==K
 	BKKK%K77K'-K#KK
 K?QK"AK
KKKK  	>KKK!!K77K#)K#K	dqK&&KĄKKK	?K K	EK  1dK
!K))K16KK  'KK%3KK".VKK%6KK!<KKKK K'K
	 	&DK	Ą2K!<KK	
KK  	pKĄ/K;KKK
KKKK 
 MKK 
 OK

KK00KKK""K**K**K**K""KK  K22K**K((K$$K""K&&KKK$$KK((K&&K,,K((K KK @KcK))KK!K**K	KKKYKKK  JJ5KK 
 #OKUU&2KşşKKŤąK  KK  #KUU&2KşşKKŤąK  K,,K22KK  @KMMKhhKK KC .KK 0KKK  	'K
	.!K
<K,KK15KKK  K%%KK1RKK(IKK#DKKK**KK((K::KK$$K,,K44K44K44K,,K((K**K<<K44K22K..K,,K00K((K&&K..K&&K22K00K66K22KK KK 	K  KK <KK K      YŇ  {Ý  