
    <<FileDWIMImpl.mesa>>
        <<Copyright Ó 1992 by Xerox Corporation.  All rights reserved.>>
        <<Last tweaked by Mike Spreitzer on September 15, 1992 1:02 pm PDT>>
        <<Willie-s, April 3, 1992 5:24 pm PST>>

    DIRECTORY BasicTime, Commander, CommanderOps, Convert, DFCachingUtilities, DFUtilities, FileDWIM, IO, MorePfsNames, PFS, PFSNames, 
    RefTab, RefText, Rope, RopeList, RopeParts, SimpleFeedback, SymTab, TEditOps, TEditProfile, UserProfile, VersionMap, 
    VersionMapDefaults, ViewerClasses;

    FileDWIMImpl: CEDAR PROGRAM
        IMPORTS BasicTime, Commander, CommanderOps, Convert, DFCachingUtilities, IO, MorePfsNames, PFS, PFSNames, RefText, Rope, RopeList, 
        RopeParts, SimpleFeedback, SymTab, TEditOps, TEditProfile, UserProfile, VersionMap, VersionMapDefaults
        EXPORTS FileDWIM
        =

    BEGIN OPEN FileDWIM, MPfsN:MorePfsNames, RP:RopeParts;

    RopePart: TYPE = RP.RopePart;
    ROPEList: TYPE = LIST OF ROPE;
    Viewer: TYPE = ViewerClasses.Viewer;
<<The basic stuff>>
    <<Modeled after TEditDocuments2Impl.LookupSource --- too bad that doesn't have quite the right interface.>>

    ResolveHint: PUBLIC PROC [hint: ROPE, contextFileName: ROPE Ź NIL, searchHack: BOOL Ź FALSE, tryAll: BOOL Ź TRUE] RETURNS [ans: 
    Answer] = {
        ans Ź ProtectedResolveHint[hint, contextFileName, searchHack, tryAll !PFS.Error => GOTO Bombed];
        EXITS Bombed => ans Ź [NIL]};

    ProtectedResolveHint: PROC [hint, contextFileName: ROPE, searchHack, tryAll: BOOL] RETURNS [ans: Answer] = {
        hintPath: PFS.PATH ~ PFS.PathFromRope[hint];
        contextPath: PFS.PATH ~ PFS.PathFromRope[contextFileName];
        contextShortName: ROPE ~ IF contextPath.ComponentCount[] > 0 THEN contextPath.ShortName[].ComponentRope[--exclude version--] ELSE 
        NIL;
        isADfFileName: BOOL ~ Rope.Match["*.df", contextShortName, FALSE];
        wDir: PFS.PATH ~ IF contextFileName#NIL THEN contextPath.Directory[] ELSE PFS.GetWDir[];
        InWDir: PROC ~ {
            wDirName: ROPE ~ PFS.RopeFromPath[PFS.GetWDir[]];
            fullHint: PFS.PATH ~ PFS.AbsoluteName[hintPath];
            fullHintName: ROPE ~ PFS.RopeFromPath[fullHint];
            IF OK[ans Ź TryFull[fullHint]] THEN RETURN;
            {hadDir: BOOL = hintPath.ComponentCount[] > 1;
            hintShort: PFSNames.Component ~ fullHint.ShortName[];
            hintExtParsed: PFS.PATH ~ ParseForExtension[hintShort];
            hasExt: BOOL = hintExtParsed.ComponentCount[] > 1;
            hasVersion: BOOL = hintShort.version.versionKind # none;
            base: PFS.PATH = hintExtParsed.SubName[count: 1];
            extComp: PFSNames.Component = FetchOrNil[hintExtParsed, 1];
            ext: ROPE ~ extComp.ComponentRope[];
            hintDir: PFS.PATH ~ fullHint.Directory[];
            extless: PFS.PATH = hintDir.Cat[base];
            extlessName: ROPE ~ PFS.RopeFromPath[extless];
            dwimAns: PFS.PATH;
            standardExtension: BOOL Ź FALSE;
            IF hasExt OR hasVersion OR NOT tryAll THEN NULL ELSE {
                IF verbose THEN SimpleFeedback.Append[$FileDWIM, oneLiner, $FYI, Rope.Concat["Trying source extensions to ", extlessName]];
                IF OK[ans Ź TryExtensions[fullHint, TEditProfile.sourceExtensions]] THEN RETURN;
                };
            [dwimAns, ans.searchFor, ans.line, ans.char] Ź DWIMit[hintPath, NIL, contextPath, searchHack, isADfFileName];
            IF dwimAns#NIL THEN {ans.fullFileName Ź PFS.RopeFromPath[dwimAns]; RETURN};
            IF hasVersion OR NOT tryAll THEN RETURN;
            IF searchHack AND hasExt THEN {
                standardExtension Ź RopeList.Memb[TEditProfile.sourceExtensions, ext, FALSE];
                IF NOT standardExtension THEN {
                    IF verbose THEN SimpleFeedback.Append[$FileDWIM, oneLiner, $FYI, Rope.Cat["Looking for prog=", extlessName, ", search=", ext]];
                    IF OK[ans Ź TryExtensions[extless, TEditProfile.implExtensions]] THEN {ans.searchFor Ź ext; RETURN};
                    };
                };
            IF (NOT hadDir) AND TEditProfile.tryVersionMap THEN {
                baseName: ROPE ~ PFS.RopeFromPath[base];
                IF verbose THEN SimpleFeedback.Append[$FileDWIM, begin, $FYI, Rope.Concat["Trying version maps for ", baseName]];
                SELECT TRUE FROM
                    NOT hasExt => ans Ź TryVersionMapExtensions[baseName, TEditProfile.sourceExtensions];
                    ENDCASE => {
                        asked: PFSNames.Component ~ StripComponentVersion[hintShort];
                        ans Ź TryVersionMapExtensions[baseName, CONS[ext, IF NOT searchHack THEN NIL ELSE IF standardExtension THEN 
                        TEditProfile.sourceExtensions ELSE TEditProfile.implExtensions]];
                        IF OK[ans] AND searchHack AND NOT PFSNames.EqualComponents[StripComponentVersion[PFS.PathFromRope[ans.fullFileName].ShortName[]], 
                        asked, FALSE] THEN ans.searchFor Ź ext};
                IF verbose THEN SimpleFeedback.Append[$FileDWIM, end, $FYI, " ."];
                };
            }};
        ans Ź [NIL];
        PFS.DoInWDir[wDir, InWDir];
        RETURN};

    OK: PROC [ans: Answer] RETURNS [ok: BOOL] = {ok Ź ans.fullFileName.Length[] # 0};

    TryFull: PROC [fullFileName: PFS.PATH] RETURNS [ans: Answer] = {
        RETURN [IF Exists[fullFileName] THEN [PFS.RopeFromPath[fullFileName]] ELSE [NIL]]};

    TryExtensions: PROC [extless: PFS.PATH, extensions: LIST OF ROPE] RETURNS [ans: Answer] = {
        ans Ź [NIL];
        FOR list: ROPEList Ź extensions, list.rest UNTIL list=NIL DO
            extended: PFS.PATH ~ AddExtension[extless, list.first];
            IF Exists[extended] THEN {
                ans.fullFileName Ź PFS.RopeFromPath[extended];
                RETURN};
            ENDLOOP;
        RETURN};

    TryVersionMap: PROC [shortName: ROPE] RETURNS [ans: Answer] = {
        mapList: VersionMap.MapList ~ VersionMapDefaults.GetMapList[$Source];
        ranges: VersionMap.RangeList ~ VersionMap.ShortNameToRanges[mapList, shortName];
        bestName: ROPE Ź NIL;
        bestDate: BasicTime.GMT Ź BasicTime.nullGMT;
        FOR list: VersionMap.RangeList Ź ranges, list.rest UNTIL list=NIL DO
            range: VersionMap.Range Ź list.first;
            WHILE range.len # 0 DO
                fullName: ROPE;
                created: BasicTime.GMT;
                [name: fullName, created: created, next: range] Ź VersionMap.RangeToEntry[range];
                IF bestDate = BasicTime.nullGMT OR BasicTime.Period[from: bestDate, to: created] > 0 THEN {bestDate Ź created; bestName Ź fullName};
                ENDLOOP;
            ENDLOOP;
        ans Ź [bestName];
        };

    TryVersionMapExtensions: PROC [name: ROPE, extensions: ROPEList] RETURNS [ans: Answer] = {
        mapList: VersionMap.MapList ~ VersionMapDefaults.GetMapList[$Source];
        ans Ź [VersionMap.LookupByExtension[mapList, name, extensions], NIL];
        RETURN};

<<From old GetDWIM ...>>
    processDF, assocExts, followAttachments: BOOLEAN Ź FALSE;

    BaseMatchTester: TYPE ~ PROC [dir: PFS.PATH, file: PFSNames.Component, ext: ROPE] RETURNS [stop: BOOL];
    FullMatchTester: TYPE ~ PROC [dir: PFS.PATH, nonDir: PFSNames.Component] RETURNS [stop: BOOL];

    DWIMit: PROC [orgName, wDir, contextFileName: PFS.PATH, searchHack, isADfFileName: BOOL] RETURNS [fileName: PFS.PATH, search: ROPE 
    Ź NIL, line, char: INT Ź -1] = {
        Try: PROC [dir, short: PFS.PATH, BaseMatch: BaseMatchTester, FullMatch: FullMatchTester] RETURNS [stop: BOOL] = {
            testFull: PFS.PATH ~ PFS.AbsoluteName[short, dir];
            testDir: PFS.PATH ~ testFull.Directory[];
            testShort: PFSNames.Component ~ testFull.ShortName[];
            stop Ź FALSE;
            IF goalVersioned THEN {
                IF testShort.EqualComponents[c2: goalNonDir, case: FALSE] THEN stop Ź FullMatch[testDir, goalNonDir];
                }
            ELSE {
                extParsed: PFS.PATH ~ ParseForExtension[testShort];
                testBase: PFSNames.Component ~ extParsed.Fetch[0];
                testExt: ROPE ~ FetchOrNil[extParsed, 1].ComponentRope[];
                IF testBase.EqualComponents[goalBase, FALSE] THEN {
                    stop Ź IF testExt.Equal[goalExt, FALSE] THEN FullMatch[testDir, goalNonDir] ELSE BaseMatch[testDir, testBase, testExt]
                    };
                };
            stop Ź stop;
            };
        FullMatch: PROC [dir: PFS.PATH, nonDir: PFSNames.Component] RETURNS [stop: BOOL] = {
            IF Exists[fileName Ź ExtendPath[dir, nonDir]] THEN {
                search Ź NIL;
                RETURN [found Ź TRUE]};
            stop Ź FALSE;
            };
        BaseMatch: PROC [dir: PFS.PATH, file: PFSNames.Component, ext: ROPE] RETURNS [stop: BOOL] = {
            allButExt: PFS.PATH ~ ExtendPath[dir, file];
            stop Ź FALSE;
            IF goalExtended THEN {
                IF assocExts AND Exists[fileName Ź AddExtension[allButExt, goalExt]] THEN {
                    search Ź NIL;
                    RETURN [found Ź TRUE]};
                IF searchHack AND RopeList.Memb[TEditProfile.implExtensions, ext, FALSE] AND Exists[fileName Ź AddExtension[allButExt, ext]] THEN {
                    search Ź goalExt;
                    RETURN [found Ź TRUE]};
                IF searchHack AND assocExts AND NOT allButExt.Equal[lastImplAssoced, FALSE] THEN {
                    lastImplAssoced Ź allButExt;
                    FOR ifel: ROPEList Ź TEditProfile.implExtensions, ifel.rest WHILE ifel # NIL DO
                        IF Exists[fileName Ź AddExtension[allButExt, ifel.first]] THEN {
                            search Ź goalExt;
                            RETURN [found Ź TRUE]};
                        ENDLOOP;
                    };
                };
            IF NOT goalExtended THEN {
                IF RopeList.Memb[TEditProfile.sourceExtensions, ext, FALSE] AND Exists[fileName Ź AddExtension[allButExt, ext]] THEN {
                    search Ź NIL;
                    RETURN [found Ź TRUE]};
                IF assocExts AND NOT allButExt.Equal[lastSourceAssoced, FALSE] THEN {
                    lastSourceAssoced Ź allButExt;
                    FOR ifel: ROPEList Ź TEditProfile.sourceExtensions, ifel.rest WHILE ifel # NIL DO
                        IF NOT ifel.first.Equal[ext] AND Exists[fileName Ź AddExtension[allButExt, ifel.first]] THEN {
                            search Ź NIL;
                            RETURN [found Ź TRUE]};
                        ENDLOOP;
                    };
                };
            stop Ź stop;
            };
        SeekTags: PROC [short, item: ROPE] RETURNS [BOOL] ~ {
            FOR tfs: Tagfiles Ź tagfiles, tfs.rest WHILE tfs#NIL DO
                tf: Tagfile ~ tfs.first;
                f: TaggedFile Ź NARROW[tf.files.Fetch[short].val];
                IF f#NIL THEN {
                    t: Tags Ź IF f.items#NIL THEN NARROW[f.items.Fetch[item].val]
                        ELSE NIL;
                    fileName Ź f.name;
                    IF item=NIL THEN search Ź NIL
                    ELSE IF t=NIL THEN LOOP
                    ELSE {search Ź item; line Ź t.line; char Ź t.char};
                    RETURN [TRUE]};
                ENDLOOP;
            RETURN [FALSE]};
        SeekExtTags: PROC [short, item: ROPE] RETURNS [BOOL] ~ {
            FOR ifel: ROPEList Ź TEditProfile.sourceExtensions, ifel.rest WHILE ifel # NIL DO
                IF SeekTags[short.Cat[".", ifel.first], item] THEN RETURN[TRUE];
                ENDLOOP;
            RETURN[FALSE]};
        found, resolved: BOOL Ź FALSE;
        goalExpanded, goalExtParsed: PFS.PATH;
        goalShort, goalBase, goalNonDir: PFSNames.Component;
        goalExt, goalBaseRope, goalShortRope: ROPE;
        goalExtended, goalVersioned: BOOL;
        lastSourceAssoced, lastImplAssoced: PFS.PATH Ź NIL;
        goalExpanded Ź PFS.AbsoluteName[orgName, wDir];
        goalShort Ź goalExpanded.ShortName[];
        goalExtParsed Ź ParseForExtension[goalShort];
        goalBase Ź goalExtParsed.Fetch[0];
        goalExt Ź FetchOrNil[goalExtParsed, 1].ComponentRope[];
        goalNonDir Ź StripComponentVersion[goalShort];
        goalExtended Ź goalExtParsed.ComponentCount[] > 1;
        goalVersioned Ź goalShort.version.versionKind # none;
        <<First, look around locally.>>
            {
            Consume: PROC [fullFName, attachedTo: PFS.PATH, uniqueID: PFS.UniqueID, bytes: INT, mutability: PFS.Mutability, fileType: 
            PFS.FileType] RETURNS [continue: BOOLEAN] --FS.InfoProc-- = {
                IF Try[NIL, fullFName, BaseMatch, FullMatch] THEN RETURN [FALSE];
                IF followAttachments AND attachedTo#NIL AND attachedTo#fullFName AND Try[NIL, GuessView[attachedTo], BaseMatch, FullMatch] THEN 
                RETURN [FALSE];
                continue Ź TRUE;
                };
            IF resolved THEN PFS.EnumerateForInfo[pattern: goalExpanded, proc: Consume !PFS.Error => CONTINUE];
            IF found THEN RETURN;
            IF assocExts AND followAttachments THEN {
                goalOhneExt: PFS.PATH ~ goalExpanded.ReplaceShortName[goalBase];
                IF verbose THEN SimpleFeedback.Append[$FileDWIM, oneLiner, $FYI, Rope.Concat["Looking for attachments to follow from ", 
                PFS.RopeFromPath[goalOhneExt]]];
                PFS.EnumerateForInfo[pattern: goalOhneExt.SetVersionNumber[[highest]], proc: Consume !PFS.Error => CONTINUE];
                IF found THEN RETURN;
                PFS.EnumerateForInfo[pattern: goalExpanded.ReplaceShortName[[name: [goalBase.ComponentRope[--exclude version--].Concat[".*"], 0, 
                NAT.LAST], version: [highest]]], proc: Consume !PFS.Error => CONTINUE];
                IF found THEN RETURN;
                }
            <<ELSE {--redundant with first standard TryExtensions>>
                <<EnumerateForInfo[base: goalBase, exts: TEditProfile.sourceExtensions, proc: Consume, wDir: wDir];>>
                <<IF found THEN RETURN;>>
                <<};>>
            };
        <<Next, try DF-file smarts.>>
        IF contextFileName.ComponentCount[] # 0 THEN {
            IF processDF AND isADfFileName THEN {
                Find[contextFileName, Try, BaseMatch, FullMatch];
                IF found THEN RETURN;
                };
            };
        <<Next, try tags files.>>
        goalShortRope Ź goalShort.ComponentRope[];
        IF SeekTags[goalShortRope, NIL] THEN RETURN;
        IF goalExtended THEN {
            goalBaseRope Ź goalBase.ComponentRope[];
        IF SeekTags[goalBaseRope, goalExt] THEN RETURN;
        IF SeekExtTags[goalBaseRope, goalExt] THEN RETURN};
        IF SeekExtTags[goalShortRope, NIL] THEN RETURN;
        <<Lastly, give up.>>
        fileName Ź NIL;
        search Ź NIL;
        line Ź char Ź -1;
        RETURN};

    uxC: PFSNames.Component ~ MPfsN.ConsComponent[RP.Make["-ux"]];
    vuxC: PFSNames.Component ~ MPfsN.ConsComponent[RP.Make["-vux"]];

    GuessView: PROC [path: PFS.PATH] RETURNS [PFS.PATH] ~ {
        lastC: PFSNames.Component ~ path.ShortName[];
        IF path.ComponentCount[]<2 OR lastC.version#[none] OR NOT uxC.EqualComponents[path.Fetch[0]] THEN RETURN [path];
        {short: RopePart ~ MPfsN.ComponentName[lastC];
        dotPos: INT ~ short.FindBackward[RP.Make["."]];
        len: INT ~ short.Length[];
        IF dotPos>0 AND dotPos+3<len AND short.InlineFetch[dotPos+1]='~ AND short.InlineFetch[len-1]='~ AND short.SkipOver[dotPos+2, 
        RP.Make["1234567890"]]=len-1 THEN {
            newC: PFSNames.Component ~ MPfsN.ConsComponent[short.Substr[len: dotPos], [numeric, Convert.IntFromRope[short.Substr[start: 
            dotPos+2, len: len-dotPos-3].ToRope[]]] ];
            RETURN path.ReplaceShortName[newC].ReplaceComponent[0, vuxC]};
        RETURN [path]}};

    Find: PROC
        [
            dfFileName: PFS.PATH,
            Try: PROC
                [
                    dir, short: PFS.PATH,
                    BaseMatch: BaseMatchTester,
                    FullMatch: FullMatchTester]
                RETURNS [stop: BOOL],
            BaseMatch: BaseMatchTester,
            FullMatch: FullMatchTester]
        =
        BEGIN
        stack: LIST OF ROPE Ź LIST["Trying DF smarts"];
        PerItem: PROC [item: REF ANY] RETURNS [stop, clip, dontCache: BOOL Ź FALSE] --DFUtilities.ProcessItemProc-- =
            BEGIN
            WITH item SELECT FROM
                di: REF DFUtilities.DirectoryItem => dir Ź PFS.PathFromRope[di.path1];
                fi: REF DFUtilities.FileItem => IF Try[dir, PFS.PathFromRope[fi.name], BaseMatch, FullMatch] THEN stop Ź TRUE;
                ni: REF DFCachingUtilities.NestItem => SELECT ni.bracket FROM
                    begin => {
                        dfPath: PFS.PATH ~ PFS.PathFromRope[ni.df.name];
                        IF pacifyDFEnumeration THEN {
                            dfShort: PFSNames.Component ~ dfPath.ShortName[];
                            dfExtParsed: PFS.PATH ~ ParseForExtension[dfShort];
                            base: ROPE ~ dfExtParsed.Fetch[0].ComponentRope[];
                            this: ROPE ~ Rope.Concat[" ", base];
                            stack Ź CONS[Rope.Concat[stack.first, this], stack];
                            SimpleFeedback.Append[$FileDWIM, middle, $FYI, this];
                            };
                        IF Try[NIL, dfPath, BaseMatch, FullMatch] THEN stop Ź TRUE
                        ELSE {
                            tryThis: BOOL Ź ni.filter.file.files=NIL;
                            RightOn: PROC [dir: PFS.PATH, nonDir: PFSNames.Component] RETURNS [stop: BOOL] = {
                                tryThis Ź stop Ź TRUE;
                                };
                            Almost: PROC [dir: PFS.PATH, file: PFSNames.Component, ext: ROPE] RETURNS [stop: BOOL] = {
                                IF stop Ź assocExts THEN tryThis Ź TRUE;
                                };
                            TryPair: PROC [key: ROPE, val: REF ANY] RETURNS [quit: BOOL] ~ {
                                quit Ź Try[NIL, PFS.PathFromRope[key], Almost, RightOn];
                                RETURN};
                            IF NOT tryThis THEN [] Ź ni.filter.file.files.Pairs[TryPair];
                            clip Ź NOT tryThis;
                            };
                        };
                    end => {
                        IF pacifyDFEnumeration THEN {
                            stack Ź stack.rest;
                            SimpleFeedback.Append[$FileDWIM, begin, $FYI, stack.first];
                            };
                        };
                    ENDCASE => ERROR;
                ii: REF DFUtilities.ImportsItem => NULL;
                ii: REF DFUtilities.IncludeItem => NULL;
                c: REF DFUtilities.CommentItem => NULL;
                w: REF DFUtilities.WhiteSpaceItem => NULL;
                ENDCASE => ERROR;
            RETURN;
            END;
        cache: DFCachingUtilities.EnumerationCache ~ DFCachingUtilities.CreateEnumerationCache[];
        dir: PFS.PATH Ź NIL;
        IF verbose OR pacifyDFEnumeration THEN SimpleFeedback.Append[$FileDWIM, begin, $FYI, "Trying DF smarts"];
        [] Ź DFCachingUtilities.EnumerateDFContents[
            df: [PFS.RopeFromPath[dfFileName]],
            Consumer: PerItem,
            cache: cache
            ! DFCachingUtilities.FSErrorOnDF => {
                IF verbose THEN SimpleFeedback.Append[$FileDWIM, oneLiner, $Error, IO.PutFR["FS.Error[%g, %g]", [atom[error.code]], 
                [rope[error.explanation]] ]];
                RESUME};
            DFCachingUtilities.Miss => RESUME;
            DFCachingUtilities.SyntaxError => {
                IF verbose THEN SimpleFeedback.Append[$FileDWIM, oneLiner, $Error, IO.PutFR["Syntax error (%g) at %g in %g", [rope[reason]], 
                [integer[position]], [rope[dfFileName]] ]];
                RESUME}
            ];
        IF verbose OR pacifyDFEnumeration THEN SimpleFeedback.Append[$FileDWIM, end, $FYI, " ."];
        END;
<<Tags Files>>
    Tagfiles: TYPE ~ LIST OF Tagfile;

    Tagfile: TYPE ~ REF TagfilePrivate;
    TagfilePrivate: TYPE ~ RECORD [
        name: PFS.PATH,
        uid: PFS.UniqueID,
        files: SymTab.Ref--short name -> TaggedFile--
        ];

    TaggedFile: TYPE ~ REF TaggedFilePrivate;
    TaggedFilePrivate: TYPE ~ RECORD [
        name: PFS.PATH,
        items: SymTab.Ref--name -> tags--
        ];

    Tags: TYPE ~ REF TagsPrivate;
    TagsPrivate: TYPE ~ RECORD [line, char: INT];

    tagAnalyses: SymTab.Ref--tag file name -> Tagfile-- ~ SymTab.Create[];

    tagfiles: Tagfiles Ź NIL;

    GetTagfiles: PROC [filenames: ROPEList] RETURNS [Tagfiles] ~ {
        IF filenames=NIL THEN RETURN [NIL];
        {tf1: Tagfile ~ GetTagfile[filenames.first];
        RETURN [CONS[tf1, GetTagfiles[filenames.rest]]]}};

    GetTagfile: PROC [name: ROPE] RETURNS [tf: Tagfile] ~ {
        path: PFS.PATH Ź NIL;
        in: IO.STREAM Ź NIL;
        uid: PFS.UniqueID Ź PFS.nullUniqueID;
        version: ROPE;
        path Ź PFS.PathFromRope[name !PFS.Error => {
            SimpleFeedback.PutFL[$FileDWIM, oneLiner, $Error, "PFS.PathFromRope[\"%q\"] => PFS.Error[%g, %g, %g]", LIST[ [rope[name]], 
            [atom[PFS.AtomFromErrorGroup[error.group]]], [atom[error.code]], [rope[error.explanation]] ]];
            CONTINUE}];
        IF path=NIL THEN RETURN [NIL];
        tf Ź NARROW[tagAnalyses.Fetch[name].val];
        uid Ź PFS.FileInfo[path !PFS.Error => {
            SimpleFeedback.PutFL[$FileDWIM, oneLiner, $Error, "PFS.FileInfo[\"%q\"] => PFS.Error[%g, %g, %g]", LIST[ [rope[name]], 
            [atom[PFS.AtomFromErrorGroup[error.group]]], [atom[error.code]], [rope[error.explanation]] ]];
            CONTINUE}].uniqueID;
        IF tf#NIL AND tf.uid=uid THEN RETURN;
        tf Ź NEW[TagfilePrivate Ź [
            name: path,
            uid: uid,
            files: SymTab.Create[] ]];
        [] Ź tagAnalyses.Store[name, tf];
        in Ź PFS.StreamOpen[path !PFS.Error => {
            SimpleFeedback.PutFL[$FileDWIM, oneLiner, $Error, "PFS.StreamOpen[\"%q\"] => PFS.Error[%g, %g, %g]", LIST[ [rope[name]], 
            [atom[PFS.AtomFromErrorGroup[error.group]]], [atom[error.code]], [rope[error.explanation]] ]];
            CONTINUE}];
        IF in=NIL THEN RETURN;
        {ENABLE UNWIND => in.Close[abort: TRUE];
        version Ź in.GetTokenRope[FtagsToken].token;
        SELECT TRUE FROM
            version.Equal["<<FTAGS-1.0>>"] => ParseFtags1[PFSNames.Directory[path], name, tf, in];
            ENDCASE => SimpleFeedback.PutFL[$FileDWIM, oneLiner, $Error, "Unknown tags format %g in file %g", LIST[ [rope[version]], 
            [rope[name]] ]];
        };
        in.Close[];
        RETURN};

    ParseFtags1: PROC [wDir: PFS.PATH, name: ROPE, tf: Tagfile, in: IO.STREAM] ~ {
        taggedName: ROPE;
        taggedPath: PFS.PATH;
        taggedShort: ROPE;
        db: INT;
        f: TaggedFile;
        buff: REF TEXT Ź RefText.ObtainScratch[100];
        NextNot: PROC [e: CHAR] RETURNS [BOOL] ~ {
            c: CHAR ~ in.GetChar[];
            IF c=e THEN RETURN [FALSE];
            RefText.ReleaseScratch[buff];
            SimpleFeedback.PutFL[$FileDWIM, oneLiner, $Error, "Syntax error at %g in %g: '\\%03b expected, '\\%03b found", LIST[ 
            [integer[in.GetIndex[]-1]], [rope[name]], [cardinal[e.ORD]], [cardinal[c.ORD]] ]];
            RETURN [TRUE]};
        IF NOT debugParseFtags THEN SimpleFeedback.PutF[$FileDWIM, oneLiner, $FYI, "Reading %g.", [rope[name]] ];
        {WHILE NOT in.EndOf[] DO
            IF in.PeekChar[]='< THEN {
                idx: INT ~ in.GetIndex[];
                v2: ROPE ~ in.GetTokenRope[FtagsToken].token;
                IF NOT v2.Equal["<<FTAGS-1.0>>"] THEN {
                    SimpleFeedback.PutFL[$FileDWIM, oneLiner, $Error, "Syntax error at %g in %g: got unrecognized (%q) version, not <<FTAGS-1.0>>", 
                    LIST[ [integer[idx]], [rope[name]], [rope[v2]] ]];
                    RefText.ReleaseScratch[buff];
                    RETURN};
                };
            IF NextNot['\014] THEN RETURN;
            taggedName Ź in.GetTokenRope[IO.IDProc].token;
            IF NextNot[',] THEN RETURN;
            db Ź in.GetInt[];
            IF NextNot['\l] THEN RETURN;
            taggedPath Ź PFS.AbsoluteName[PFS.PathFromRope[taggedName], wDir];
            taggedShort Ź taggedPath.ShortNameRope[];
            f Ź NEW[TaggedFilePrivate Ź [
                name: taggedPath,
                items: NIL ]];
            [] Ź tf.files.Store[taggedShort, f];
            IF debugParseFtags THEN SimpleFeedback.PutF[$FileDWIM, oneLiner, $Debug, "Noting %g", [rope[taggedShort]] ];
            IF readFtagsItems THEN {
                f.items Ź SymTab.Create[];
                DO
                    item: ROPE;
                    tags: Tags;
                    IF in.EndOf[] THEN GOTO Done;
                    SELECT in.PeekChar[] FROM
                        '\014, '< => EXIT;
                        ENDCASE => NULL;
                    item Ź in.GetTokenRope[FtagsToken].token;
                    tags Ź NEW [TagsPrivate];
                    IF NextNot['\177] THEN RETURN;
                    [] Ź in.GetToken[FtagsToken, buff];
                    IF NextNot['\177] THEN RETURN;
                    tags.line Ź in.GetInt[];
                    IF NextNot[',] THEN RETURN;
                    tags.char Ź in.GetInt[];
                    IF NextNot['\012] THEN RETURN;
                    [] Ź f.items.Store[item, tags];
                    ENDLOOP;
                }
            ELSE {
                wuz: INT ~ in.GetIndex[];
                in.SetIndex[wuz+db];
                };
            ENDLOOP;
        EXITS Done => NULL};
        RefText.ReleaseScratch[buff];
        IF NOT debugParseFtags THEN SimpleFeedback.PutF[$FileDWIM, oneLiner, $FYI, "Done reading %g.", [rope[name]] ];
        RETURN};
        debugParseFtags: BOOL Ź FALSE;
        readFtagsItems: BOOL Ź FALSE;

    FtagsToken: PROC [char: CHAR] RETURNS [IO.CharClass] --IO.BreakProc--
        ~ {SELECT char FROM
            '\177, '\012, '\014 => RETURN [break];
            ENDCASE => RETURN [other]};
<<Tioga Helper>>
    inPlace, doSearchHack: BOOL Ź FALSE;

    OldFNP: PROC [ROPE, Viewer] RETURNS [fileName: ROPE, search: ROPE] Ź NIL;

    GetDWIM: PROC [orgName: ROPE, viewer: Viewer] RETURNS [fileName: ROPE Ź NIL, search: ROPE]--TEditOps.FileNameProc-- = {
        IF orgName.Length[]=0 THEN RETURN [NIL, NIL];
        {orgPath: PFS.PATH ~ PFS.PathFromRope[orgName !PFS.Error => GOTO Bad];
        IF orgPath.IsAbsolute[] THEN RETURN [NIL, NIL];
        {contextFileName: ROPE ~ IF viewer # NIL THEN IF viewer.file = NIL THEN viewer.name ELSE viewer.file ELSE NIL;
        contextPath: PFS.PATH ~ PFS.PathFromRope[contextFileName];
        isADfFileName: BOOL Ź FALSE;
        Doit: PROC ~ {
            dwimAns: PFS.PATH;
            [dwimAns, search,,] Ź DWIMit[orgPath, NIL, contextPath, doSearchHack, isADfFileName];
            IF dwimAns#NIL THEN fileName Ź PFS.RopeFromPath[dwimAns];
            RETURN};
        IF contextFileName.Length[]#0 THEN {
            wDir: PFS.PATH ~ contextPath.Directory[];
            contextShort: ROPE ~ contextPath.ShortName[].ComponentRope[--exclude version--];
            isADfFileName Ź Rope.Match["*.df", contextShort, FALSE];
            PFS.DoInWDir[wDir, Doit];
            }
        ELSE Doit[];
        IF fileName=NIL AND OldFNP#NIL THEN [fileName, search] Ź OldFNP[orgName, viewer];
        };
        EXITS Bad => search Ź NIL};
        RETURN};
<<Common Utoolities>>
    wDirKey: ATOM ~ $WorkingDirectory;
    verbose, pacifyDFEnumeration: BOOL Ź TRUE;

    Exists: PROC [fileName: PFS.PATH] RETURNS [exists: BOOLEAN] = {
        exists Ź FALSE;
        exists Ź PFS.FileInfo[
            name: fileName
            ! PFS.Error => CONTINUE].bytes # -1;
        RETURN};

    ParseForExtension: PROC [c: PFSNames.Component] RETURNS [PFS.PATH] ~ {
        pos: INT ~ Rope.FindBackward[c.name.base, ".", c.name.start+c.name.len-1];
        nameLen: INT ~ c.name.start+c.name.len;
        len: INT ~ MIN[c.name.base.Length[], nameLen];
        IF pos >= c.name.start THEN RETURN [PFSNames.ConstructName[LIST[
            [[c.name.base, c.name.start, pos-c.name.start]],
            [[c.name.base, pos+1, len-pos-1]]
            ]]]
        ELSE RETURN [PFSNames.ConstructName[LIST[c]]]};

    ExtendPath: PROC [path: PFS.PATH, component: PFSNames.Component] RETURNS [PFS.PATH] ~ {
        RETURN path.Cat[PFSNames.ConstructName[LIST[component]]]};

    AddExtension: PROC [path: PFS.PATH, ext: ROPE] RETURNS [PFS.PATH] ~ {
        RETURN path.ReplaceShortName[[name: [path.ShortName[].ComponentRope[].Cat[".", ext], 0, NAT.LAST]]]};

    FetchOrNil: PROC [path: PFS.PATH, index: INT] RETURNS [PFSNames.Component] ~ {
        IF index=path.ComponentCount[] THEN RETURN [[]];
        RETURN path.Fetch[index]};

    StripComponentVersion: PROC [c: PFSNames.Component] RETURNS [PFSNames.Component]
        ~ {RETURN [[c.name, [none]]]};

    TestCmd: PROC [cmd: Commander.Handle] RETURNS [result: ATOM Ź NIL, msg: ROPE Ź NIL] --Commander.CommandProc-- ~ {
        argv: CommanderOps.ArgumentVector ~ CommanderOps.Parse[cmd];
        hint, contextFileName: ROPE Ź NIL;
        searchHack, errd: BOOL Ź FALSE;
        tryAll: BOOL Ź TRUE;
        ans: Answer;
        IF argv.argc<=1 THEN RETURN [$Failure, "Usage: FileDWIM (-s | +s | -a | +a)* || ([contextFileName] hint)"];
        FOR i: NAT IN [1..argv.argc) DO
            SELECT TRUE FROM
                argv[i].Equal["-s"] => searchHack Ź FALSE;
                argv[i].Equal["+s"] => searchHack Ź TRUE;
                argv[i].Equal["-a"] => tryAll Ź FALSE;
                argv[i].Equal["+a"] => tryAll Ź TRUE;
                hint=NIL => hint Ź argv[i];
                ENDCASE => contextFileName Ź argv[i];
            ENDLOOP;
        ans Ź ResolveHint[hint, contextFileName, searchHack, tryAll !PFS.Error => {
            errd Ź TRUE;
            msg Ź IO.PutFR["PFS.Error[%g, %g]", [atom[error.code]], [rope[error.explanation]] ];
            CONTINUE}];
        IF errd THEN RETURN [$Failure, msg];
        msg Ź IO.PutFR["[fullFileName: %g, searchFor: %g]", [rope[ans.fullFileName]], [rope[ans.searchFor]] ];
        RETURN};

    NoticeProfileChanges: PROC [reason: UserProfile.ProfileChangeReason] --UserProfile.ProfileChangedProc-- = {
        tagfilenames: ROPEList Ź UserProfile.ListOfTokens["FileDWIM.Tagfiles", NIL];
        doSearchHack Ź UserProfile.Boolean["FileDWIM.DoSearchHack", FALSE];
        processDF Ź UserProfile.Boolean["FileDWIM.ProcessDF", TRUE];
        assocExts Ź UserProfile.Boolean["FileDWIM.AssociateExtensions", TRUE];
        followAttachments Ź UserProfile.Boolean["FileDWIM.FollowAttachments", TRUE];
        verbose Ź UserProfile.Boolean["FileDWIM.Verbose", FALSE];
        pacifyDFEnumeration Ź UserProfile.Boolean["FileDWIM.PacifyDFEnumeration", FALSE];
        tagfiles Ź GetTagfiles[tagfilenames];
        IF (processDF OR assocExts) AND NOT inPlace THEN
            BEGIN
            inPlace Ź TRUE;
            OldFNP Ź TEditOps.ReplaceFileNameProc[GetDWIM];
            END;
        };

    UserProfile.CallWhenProfileChanges[NoticeProfileChanges];
    Commander.Register["FileDWIM", TestCmd, "FileDWIM (-s | +s | -a | +a)* || ([contextFileName] hint) tests FileDWIM"];

    END.