<<>>
<<FSOnPFSImpl.mesa>>
    <<Copyright Ó 1988, 1989, 1990, 1991 by Xerox Corporation.  All rights reserved.>>
    <<Andy Litman May 24, 1988 7:58:10 pm PDT>>
    <<JKF October 31, 1988 9:23:34 am PST>>
    <<Eduardo Pelegri-Llopart March 16, 1989 1:28:42 pm PST>>
    <<Chauser, November 8, 1990 9:05 am PST>>
    <<Doug Wyatt, September 25, 1990 4:51 pm PDT>>
    <<Willie-s, August 20, 1991 5:52 pm PDT>>
    <<Michael Plass, November 27, 1991 11:04 am PST>>

    DIRECTORY
        Commander, -- for debug expandname
        BasicTime,
        Convert,
        FS,
        FSBackdoor,
        FSName,
        IO,
        PFS,
        PFSNames,
        RefText,
        Rope;

    FSOnPFSImpl: CEDAR PROGRAM
        IMPORTS Commander, Convert, IO, PFSNames, PFS, RefText, Rope
        EXPORTS FS, FSBackdoor,  FSName
        ~ BEGIN

        ROPE: PRIVATE TYPE = Rope.ROPE;
        STREAM: PRIVATE TYPE = IO.STREAM;

        <<Stuff from FS (to be replaced by PFS)>>

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

        Wrap: PROC [inner: PROC, wDir: ROPE] ~ {
            IF wDir = NIL THEN inner[] ELSE PFS.DoInWDir[PFS.PathFromRope[wDir], inner];
            };

        StreamOpen: PUBLIC PROC [fileName: ROPE, 
        accessOptions: FS.AccessOptions Ź $read, 
        streamOptions: FS.StreamOptions Ź FS.defaultStreamOptions, 
        keep: CARDINAL Ź 1, 
        createByteCount: INT Ź 2560, 
        streamBufferParms: FS.StreamBufferParms Ź FS.defaultStreamBufferParms, 
        extendFileProc: FS.ExtendFileProc Ź NIL, 
        wantedCreatedTime: BasicTime.GMT Ź BasicTime.nullGMT, 
        remoteCheck: BOOL Ź TRUE, 
        wDir: ROPE Ź NIL,
        checkFileType: BOOL Ź FALSE,
        fileType: FS.FileType Ź FS.tUnspecified
        ] RETURNS [st: STREAM] = {
            StreamOpenInner: PROC ~ {
                st Ź PFS.StreamOpen[
                    fileName: PFS.PathFromRope[fileName], 
                    accessOptions: (SELECT accessOptions FROM read => read, write => write, create => create, append => append, ENDCASE => ERROR), 
                    wantedUniqueID: UIDFromGMT[wantedCreatedTime],
                    checkFileType: checkFileType,
                    fileType: [fileType],
                    createOptions: [keep: keep],
                    streamOptions: [includeFormatting: NOT streamOptions[tiogaRead], closeFSOpenFileOnClose: streamOptions[closeFSOpenFileOnClose]], 
                    streamBufferParms: [bytesPerBuffer: streamBufferParms.vmPagesPerBuffer*512, nBuffers: streamBufferParms.nBuffers]
                    ];
                };
            Wrap[StreamOpenInner, wDir];
            };

        OpenFileFromStream: PUBLIC PROC [self: STREAM] RETURNS [FS.OpenFile] = {
            RETURN [WrapOpenFile[PFS.OpenFileFromStream[self]]]
            };

        StreamFromOpenFile: PUBLIC PROC [openFile: FS.OpenFile, 
        accessRights: FS.Lock Ź $read, 
        initialPosition: FS.InitialPosition Ź $start, 
        streamOptions: FS.StreamOptions Ź FS.defaultStreamOptions, 
        streamBufferParms: FS.StreamBufferParms Ź FS.defaultStreamBufferParms, 
        extendFileProc: FS.ExtendFileProc Ź NIL
        ] RETURNS [stream: STREAM Ź NIL] = {
            stream Ź PFS.StreamFromOpenFile[
                openFile: BreakOpenFile[openFile],
                accessOptions: SELECT TRUE FROM
                    (accessRights = read) => read,
                    ((accessRights = write) AND (initialPosition = start)) => write,
                    ((accessRights = write) AND (initialPosition = end)) => append,
                    ENDCASE => ERROR, -- Can't get here
                streamOptions: [includeFormatting: NOT streamOptions[tiogaRead], closeFSOpenFileOnClose: streamOptions[closeFSOpenFileOnClose]],
                streamBufferParms: [bytesPerBuffer: streamBufferParms.vmPagesPerBuffer*512, nBuffers: streamBufferParms.nBuffers]
                ];
            };

        Open: PUBLIC PROC [name: ROPE, 
        lock: FS.Lock Ź $read, 
        wantedCreatedTime: BasicTime.GMT Ź BasicTime.nullGMT, 
        remoteCheck: BOOL Ź TRUE, 
        wDir: ROPE Ź NIL,
        verifyNow: BOOL Ź FALSE,
        checkFileType: BOOL Ź FALSE,
        fileType: FS.FileType Ź FS.tUnspecified
        ] RETURNS [file: FS.OpenFile Ź FS.nullOpenFile] ~ {
            OpenInner: PROC ~ {
                file Ź WrapOpenFile[PFS.Open[
                    name: PFS.PathFromRope[name], 
                    access: SELECT lock FROM read => read, write => write, ENDCASE => ERROR,
                    wantedUniqueID: UIDFromGMT[wantedCreatedTime],
                    checkFileType: checkFileType,
                    fileType: [fileType]
                    ]];
                };
            Wrap[OpenInner, wDir];
            };

        Create: PUBLIC PROC [name: ROPE, 
        setPages: BOOL Ź FALSE, pages: INT Ź 0, 
        setKeep: BOOL Ź FALSE, keep: CARDINAL Ź 1, 
        wDir: ROPE Ź NIL,
        fileType: FS.FileType Ź FS.tUnspecified
        ] RETURNS [file: FS.OpenFile Ź FS.nullOpenFile] ~ {
            CreateInner: PROC ~ {
                file Ź WrapOpenFile[PFS.Open[
                    name: PFS.PathFromRope[name], 
                    access: create,
                    fileType: [fileType],
                    createOptions: [keep: IF setKeep THEN keep ELSE 0, fileType: [fileType]]
                    ]];
                };
            Wrap[CreateInner, wDir];
            };

        BreakOpenFile: PROC [file: FS.OpenFile] RETURNS [PFS.OpenFile] = {
            WITH file SELECT FROM
                pfs: REF PFS.OpenFile => RETURN [pfs­];
                ENDCASE => RETURN [NIL];
            };

        WrapOpenFile: PROC [file: PFS.OpenFile] RETURNS [FS.OpenFile] = {
            RETURN [IF file = NIL THEN FS.nullOpenFile ELSE [NEW[PFS.OpenFile Ź file]]]
            };

        GetInfo: PUBLIC PROC [file: FS.OpenFile] 
        RETURNS [keep: CARDINAL Ź 0, pages: INT Ź 0, bytes: INT Ź 0, created: BasicTime.GMT, lock: FS.Lock Ź read, fileType: 
        FS.FileType Ź FS.tUnspecified] = {
            <<known clients are only interested in the create time>>
            uniqueID: PFS.UniqueID;
            pfsFileType: PFS.FileType;
            [uniqueID: uniqueID, bytes: bytes, fileType: pfsFileType] Ź PFS.GetInfo[BreakOpenFile[file]];
            pages Ź (bytes + 511)/512;
            created Ź uniqueID.egmt.gmt;
            fileType Ź [pfsFileType];
            };

        nameFormat: PFS.NameFormat Ź brackets;
        RopeFromPath: PROC [path: PFS.PATH] RETURNS [ROPE] = INLINE {
            RETURN [IF path = NIL THEN NIL ELSE PFS.RopeFromPath[path, nameFormat]]
            };

        GetName: PUBLIC PROC [file: FS.OpenFile] RETURNS [fullFName, attachedTo: ROPE] = {
            <<takes advantage of the fact that all of the clients are only intersted in fullFName>>
            fullPath, attachedPath: PFS.PATH;
            [fullFName: fullPath, attachedTo: attachedPath] Ź PFS.GetInfo[BreakOpenFile[file]];
            fullFName Ź RopeFromPath[fullPath];
            attachedTo Ź RopeFromPath[attachedPath];
            };

        SetByteCountAndCreatedTime: PUBLIC PROC [file: FS.OpenFile, 
        bytes: INT Ź -1, created: BasicTime.GMT Ź BasicTime.nullGMT] ~ {
            PFS.SetByteCountAndUniqueID[BreakOpenFile[file], bytes, UIDFromGMT[created]];
            };

        FilePtr: TYPE = LONG POINTER TO INT;

        Copy: PUBLIC PROC [from, to: ROPE, 
        setKeep: BOOL Ź FALSE, keep: CARDINAL Ź 1, 
        wantedCreatedTime: BasicTime.GMT Ź BasicTime.nullGMT, 
        remoteCheck: BOOL Ź TRUE, 
        attach: BOOL Ź FALSE, 
        wDir: ROPE Ź NIL
        ] RETURNS [toFName: ROPE] = {
            CopyInner: PROC ~ {
                Confirm: PFS.NameConfirmProc ~ {
                    <<PROC [fullName: PATH, uniqueID: UniqueID] RETURNS [continue: BOOL _ FALSE];>>
                    toFName Ź RopeFromPath[fullName];
                    RETURN [TRUE];
                    };
                IF attach THEN toFName Ź RopeFromPath[
                    PFS.Attach[
                        attachment: PFS.PathFromRope[to],
                        attachedFile: PFS.PathFromRope[from],
                        wantedUniqueID: UIDFromGMT[wantedCreatedTime],
                        remoteCheck: remoteCheck ! PFS.Error => { attach Ź FALSE; CONTINUE }
                        ]
                    ];
                IF NOT attach THEN {
                    PFS.Copy[
                        from: PFS.PathFromRope[from],
                        to: PFS.PathFromRope[to],
                        wantedUniqueID: UIDFromGMT[wantedCreatedTime],
                        confirmProc: Confirm
                        ];
                    };
                };
            Wrap[CopyInner, wDir];
            };

        Rename: PUBLIC PROC [from, to: ROPE, 
        setKeep: BOOL Ź FALSE, keep: CARDINAL Ź 1, 
        wantedCreatedTime: BasicTime.GMT Ź BasicTime.nullGMT, 
        wDir: ROPE Ź NIL
        ] = {
            RenameInner: PROC ~ {
                PFS.Rename[
                    from: PFS.PathFromRope[from],
                    to: PFS.PathFromRope[to],
                    wantedUniqueID: UIDFromGMT[wantedCreatedTime]
                    ];
                };
            Wrap[RenameInner, wDir];
            };

        UIDFromGMT: PROC [gmt: BasicTime.GMT] RETURNS [PFS.UniqueID] ~ INLINE {
            RETURN [[egmt: [gmt: gmt, usecs: 0]]]
            };

        Delete: PUBLIC PROC [name: ROPE, 
        wantedCreatedTime: BasicTime.GMT Ź BasicTime.nullGMT, 
        wDir: ROPE Ź NIL
        ] = {
            DeleteInner: PROC ~ {
                PFS.Delete[name: PFS.PathFromRope[name], wantedUniqueID: UIDFromGMT[wantedCreatedTime]];
                };
            Wrap[DeleteInner, wDir];
            };

        FileInfo: PUBLIC PROC [
        name: ROPE, 
        wantedCreatedTime: BasicTime.GMT Ź BasicTime.nullGMT, 
        remoteCheck: BOOL Ź TRUE, 
        wDir: ROPE Ź NIL
        ] RETURNS [
        fullFName, attachedTo: ROPE Ź NIL, 
        keep: CARDINAL Ź 1, 
        bytes: INT Ź 0, 
        created: BasicTime.GMT Ź BasicTime.nullGMT,
        fileType: FS.FileType Ź FS.tUnspecified
        ] = {
            <<Takes advantage of the fact that the only client is C2CPrincOps which just>>
            <<cares about the keep value, which is always 1 for UX>>
            FileInfoInner: PROC ~ {
                fullPath, attachedPath: PFS.PATH;
                uniqueID: PFS.UniqueID;
                pfsFileType: PFS.FileType;
                [fullFName: fullPath, attachedTo: attachedPath, uniqueID: uniqueID, bytes: bytes, fileType: pfsFileType] Ź PFS.FileInfo[name: 
                PFS.PathFromRope[name], wantedUniqueID: UIDFromGMT[wantedCreatedTime]];
                fullFName Ź RopeFromPath[fullPath];
                attachedTo Ź RopeFromPath[attachedPath];
                created Ź uniqueID.egmt.gmt;
                fileType Ź [pfsFileType];
                };
            Wrap[FileInfoInner, wDir];
            };


        SetKeep: PUBLIC PROC [name: ROPE, keep: CARDINAL Ź 1, wDir: ROPE Ź NIL] = {
            SetKeepInner: PROC ~ {
                [] Ź PFS.PathFromRope[name]; -- Syntax check
                };
            Wrap[SetKeepInner, wDir];
            };

        BytesForPages: PUBLIC PROC [pages: INT] RETURNS [bytes: INT] = {
            RETURN [pages * 512] -- Ignore real page size
            };

        PagesForBytes: PUBLIC PROC [bytes: INT] RETURNS [pages: INT] = {
            RETURN [(bytes+511)/512]
            };

        GetWDir: PUBLIC PROC [wDir: ROPE Ź NIL] RETURNS [ans: ROPE] ~ {
            GetWDirInner: PROC ~ {ans Ź RopeFromPath[PFS.GetWDir[]]};
            Wrap[GetWDirInner, wDir];
            };

        DIRPtr: TYPE = POINTER;
        DirEntPtr: TYPE = POINTER;

        EnumerateForNames: PUBLIC PROC [pattern: ROPE, proc: FS.NameProc, wDir: ROPE Ź NIL] = {
            EachPath: PFS.NameProc ~ {
                <<PROC [name: PATH] RETURNS [continue: BOOL _ TRUE];>>
                continue Ź proc[RopeFromPath[name]];
                };
            EnumerateForNamesInner: PROC ~ {
                PFS.EnumerateForNames[pattern: PFS.PathFromRope[pattern], proc: EachPath];
                };
            Wrap[EnumerateForNamesInner, wDir];
            };

        EnumerateForInfo: PUBLIC PROC [pattern: ROPE, proc: FS.InfoProc, wDir: ROPE Ź NIL] = {
            EachInfo: PFS.InfoProc ~ {
                <<PROC [
                fullFName, attachedTo: PATH, 
                uniqueID: UniqueID, 
                bytes: INT, 
                mutability: Mutability,
                fileType: FileType
                ] RETURNS [continue: BOOL _ TRUE]>>
                continue Ź proc[fullFName~RopeFromPath[fullFName], attachedTo~RopeFromPath[attachedTo], created~uniqueID.egmt.gmt, bytes~bytes, 
                keep~1, fileType~[fileType]];
                };
            EnumerateForInfoInner: PROC ~ {
                PFS.EnumerateForInfo[pattern: PFS.PathFromRope[pattern], proc: EachInfo];
                };
            Wrap[EnumerateForInfoInner, wDir];
            };

        Close: PUBLIC PROC [file: FS.OpenFile] = {
            PFS.Close[BreakOpenFile[file]]
            };

        nullCP: FS.ComponentPositions = [server: nullPos, dir: nullPos, subDirs: nullPos, base: nullPos, ext: nullPos, ver: nullPos];
        nullPos: FS.Position = [start: 0, length: 0];

        ExpandName: PUBLIC PROC[name: ROPE, wDir: ROPE Ź NIL] 
        RETURNS [fullFName: ROPE Ź NIL, cp: FS.ComponentPositions, dirOmitted: BOOL] = {
            path: PFS.PATH;
            scratch: REF TEXT ~ RefText.ObtainScratch[100];
            text: REF TEXT Ź scratch;
            GetPath: PROC ~ {
                path Ź PFS.AbsoluteName[PFS.PathFromRope[name]];
                };
            lastVersion: PFSNames.Version Ź [none];
            Append: PROC [t: REF TEXT, p: PFS.PATH, i: INT] RETURNS [REF TEXT] ~ {
                comp: PFSNames.Component ~ PFSNames.Fetch[p, i];
                RETURN[ RefText.AppendRope[t, comp.name.base, comp.name.start, comp.name.len] ];
                };
            isADirectory: BOOL;
            comps: NAT;
            Wrap[GetPath, wDir];
            comps Ź PFSNames.ComponentCount[path];
            isADirectory Ź PFSNames.IsADirectory[path];
            dirOmitted Ź FALSE;
            cp Ź nullCP;
            <<n.b. the view component is not represented in CFS-style names.>>
            <<Form the server component>>
            IF comps >= 2 THEN {
                text Ź RefText.AppendChar[text, '[ ];
                cp.server.start Ź text.length;
                text Ź Append[text, path, 1];
                cp.server.length Ź text.length-cp.server.start;
                text Ź RefText.AppendChar[text, '] ];
                cp.dir.start Ź text.length;
                cp.subDirs.start Ź text.length;
                };
            <<Form the directory component>>
            SELECT TRUE FROM
                comps>3 OR comps=3 AND isADirectory  => {
                    text Ź RefText.AppendChar[text, '< ];
                    cp.dir.start Ź text.length;
                    text Ź Append[text, path, 2];
                    cp.dir.length Ź text.length-cp.dir.start; 
                    text Ź RefText.AppendChar[text, '> ];
                    cp.subDirs.start Ź text.length;
                    };
                comps=3 AND NOT isADirectory  => {
                    cp.base.start Ź text.length;
                    text Ź Append[text, path, 2];
                    cp.base.length Ź text.length-cp.base.start;
                    lastVersion Ź path.ShortName[].version;
                    dirOmitted Ź TRUE;
                    };
                ENDCASE => dirOmitted Ź TRUE;
            <<Form the remaining the components ...>>
            FOR i: NAT IN [3..comps) DO
                IF i<comps-1 OR isADirectory THEN {
                    <<subdirectories and ...>>
                    text Ź Append[text, path, i];
                    cp.subDirs.length Ź text.length-cp.subDirs.start;
                    text Ź RefText.AppendChar[text, '> ];
                    }
                ELSE {
                    <<the base.>>
                    cp.base.start Ź text.length;
                    text Ź Append[text, path, i];
                    cp.base.length Ź text.length-cp.base.start;
                    lastVersion Ź path.ShortName[].version;
                    };
                ENDLOOP;
            <<Form the version part>>
            IF lastVersion.versionKind # none THEN  {
                text Ź RefText.AppendChar[text, '! ];
                cp.ver.start Ź text.length;
                text Ź SELECT lastVersion.versionKind FROM
                    lowest => RefText.AppendChar[text, 'L ],
                    highest => RefText.AppendChar[text, 'H ],
                    all => RefText.AppendChar[text, '* ],
                    numeric => Convert.AppendCard[text, lastVersion.version],
                    ENDCASE => text;
                cp.ver.length Ź text.length-cp.ver.start;
                };
            <<Parse the base into base and extension>>
            FOR i: NAT DECREASING IN [cp.base.start..cp.base.start+cp.base.length) DO
                IF text[i] = '. THEN {
                    cp.ext.start Ź i+1;
                    cp.ext.length Ź cp.base.start+cp.base.length-(i+1);
                    cp.base.length Ź i-cp.base.start;
                    EXIT;
                    };
                ENDLOOP;
            <<Fix up the component positions so they are properly monotonic>>
            IF cp.base = nullPos THEN { cp.base.start Ź text.length };
            IF cp.ext = nullPos THEN {cp.ext.start Ź cp.base.start+cp.base.length;
                IF cp.ext.start = CARDINAL[text.length-1] THEN cp.ext.start Ź cp.ext.start+1};
            IF cp.ver = nullPos THEN {cp.ver.start Ź cp.ext.start+cp.ext.length;
                IF cp.ver.start = CARDINAL[text.length-1] THEN cp.ver.start Ź cp.ver.start+1};
            fullFName Ź Rope.FromRefText[text];
            RefText.ReleaseScratch[scratch];
            };

        <<Stuff from FSBackdoor>>
        EnumerateCacheForNames: PUBLIC PROC [proc: FSBackdoor.NameProc, volName, pattern: ROPE] = { -- This is pretty easy for Unix - it 
        has no cache to enumerate.
        };
    group: PACKED ARRAY FSBackdoor.ErrorCode OF FS.ErrorGroup = [
    -- 4-- bug, bug, bug, bug,
    --14-- environment, environment, environment, environment, environment, environment, environment, environment, environment, 
    environment, environment, environment, environment, environment,
    -- 2-- environment, environment,
    -- 9-- client, client, client, client, client, client, client, client, client,
    --12-- user, user, user, user, user, user, user, user, user, user, user, user 
    ];
    codeAtom: ARRAY FSBackdoor.ErrorCode OF ATOM = [
    $ok, $inconsistent, $software, $badFP,
    $wentOffline, $hardware, $volumeFull, $fragmented, $noMoreVersions, $serverInaccessible, $connectionRejected, $connectionTimedOut, 
    $badCredentials, $accessDenied, $quotaExceeded, $invalidPropertyPage, $badBTree, $outOfPropertySpace,
    $lockConflict, $fileBusy,
    $noCache, $wrongLock, $globalWriteLock, $zeroKeep, $badByteCount, $unknownPage, $invalidOpenFile, $notImplemented, 
    $fileTypeMismatch,
    $nonCedarVolume, $unknownServer, $unknownVolume, $unknownFile, $unknownCreatedTime, $illegalName, $patternNotAllowed, 
    $versionSpecified, $globalCreation, $badWorkingDir, $noKeeps, $cantUpdateTiogaFile
    ];
    ProduceError: PUBLIC PROC [code: FSBackdoor.ErrorCode, explanation: ROPE] = {
    ERROR Error [ [group[code], codeAtom[code], explanation] ];
    };

        <<From FSPseudoServers:>>

        TranslateForRead: PUBLIC PROC [server: ROPE] RETURNS [LIST OF ROPE] = {
            RETURN [NIL] -- who uses this stuff?
            <<RETURN[UFSPseudoServers.TranslateForRead[server]]>>
            };
            <<>>
        <<Lookup: PUBLIC PROC [server: ROPE] RETURNS [FSPseudoServers.PseudoServerList] = TRUSTED {>>
            <<RETURN [NIL] -- who uses this stuff?>>
            <<RETURN[LOOPHOLE[UFSPseudoServers.Lookup[server]]]>>
            <<};>>
        <<>>
        <<From FSName>>

    BangVersionFile: PUBLIC PROC [file: ROPE, version: FSBackdoor.Version] RETURNS [ROPE] = {
    length: CARDINAL = Rope.Length[file];
    bangIndex: CARDINAL = Rope.Index[file, IF length > 6 THEN length - 6 ELSE 0, "!"];
    RETURN [ Rope.Replace [ file, bangIndex, length - bangIndex, VersionPartFromVersion[version] ] ];
    };
    VersionFromRope: PUBLIC PROC [r: ROPE] RETURNS [v: FSBackdoor.Version] = {
    IF Rope.IsEmpty[r]
    THEN v Ź FSBackdoor.highestVersion
    ELSE [v, ] Ź ParseVersion[r, 0, FALSE];
    };
    VersionPartFromVersion: PROC [version: FSBackdoor.Version] RETURNS [r: Rope.Text] = {
    t: REF TEXT;
    SELECT version FROM
    FSBackdoor.lowestVersion, FSBackdoor.highestVersion => r Ź NIL;
    ENDCASE => TRUSTED {
    r Ź Rope.NewText[6];
    t Ź LOOPHOLE[r];
    t[0] Ź '!;
    t.length Ź 1;
    [] Ź Convert.AppendInt[t, version];
    };
    };

    ParseVersion: PROC [name: ROPE, index: CARDINAL, pattern: BOOL Ź FALSE]
    RETURNS [value: FSBackdoor.Version, vI: FSName.VersionInfo] = {
    c: CHAR;
    lastIndex: CARDINAL = Rope.Length[name] - 1;
    IF lastIndex IN [index .. index+4] THEN SELECT c Ź Rope.Fetch[name, index] FROM
    IN ['0 .. '9] => {
    num: LONG CARDINAL Ź 0;
    DO
    num Ź num*10 + (c - '0);
    IF index = lastIndex THEN {
    IF num NOT IN (FSBackdoor.lowestVersion .. FSBackdoor.highestVersion)
    THEN EXIT;
    value Ź [num];
    vI Ź number;
    RETURN;
    };
    index Ź index + 1;
    c Ź Rope.Fetch[name, index];
    IF c NOT IN ['0 .. '9]
    THEN EXIT;
    ENDLOOP;
    };
    'H, 'h =>
    IF index = lastIndex THEN {
    value Ź FSBackdoor.highestVersion;  vI Ź bangH; RETURN };
    'L, 'l =>
    IF index = lastIndex THEN {
    value Ź FSBackdoor.lowestVersion; vI Ź bangL; RETURN };
    '* =>
    IF index = lastIndex AND pattern THEN {
    value Ź FSBackdoor.highestVersion; vI Ź bangStar; RETURN };
    ENDCASE;
    IllegalVersion[name];
    };
    IllegalVersion: PROC [n: ROPE] = {
    ProduceError[ illegalName, QuotedName[n, " has an illegal version part"] ];
    };

    QuotedName: PROC [n, rest: ROPE] RETURNS [ROPE] = {
    RETURN [ Rope.Cat["\"", n, "\"", rest] ];
    };

        DebugExpandName: Commander.CommandProc ~ {
            ENABLE Error => {msg Ź error.explanation; result Ź $Failure; CONTINUE};
            fullFName: ROPE;
            cp: FS.ComponentPositions;
            WHILE Rope.Match[" *", cmd.commandLine] DO cmd.commandLine Ź Rope.Substr[cmd.commandLine, 1] ENDLOOP;
            cmd.commandLine Ź Rope.Substr[cmd.commandLine, 0, cmd.commandLine.SkipTo[skip: "\l\r"]];
            [fullFName, cp] Ź ExpandName[cmd.commandLine];
            IO.PutRope[cmd.out, fullFName];
            IO.PutRope[cmd.out, "\n"];
            IO.PutF[cmd.out, "[%g, %g], ", [integer[cp.server.start]], [integer[cp.server.length]]];
            IO.PutF[cmd.out, "[%g, %g], ", [integer[cp.dir.start]], [integer[cp.dir.length]]];
            IO.PutF[cmd.out, "[%g, %g], ", [integer[cp.subDirs.start]], [integer[cp.subDirs.length]]];
            IO.PutF[cmd.out, "[%g, %g], ", [integer[cp.base.start]], [integer[cp.base.length]]];
            IO.PutF[cmd.out, "[%g, %g], ", [integer[cp.ext.start]], [integer[cp.ext.length]]];
            IO.PutF[cmd.out, "[%g, %g]\n", [integer[cp.ver.start]], [integer[cp.ver.length]]];
            };

    Commander.Register["DebugExpandName", DebugExpandName];

    END.