
    <<TiogaOps2Impl.mesa>>
        <<Copyright © 1985 by Xerox Corporation.  All rights reserved.>>
        <<written by Bill Paxton. June 1982>>
        <<last written by Paxton. December 30, 1982 11:13 am>>
        <<Last Edited by: Maxwell, January 6, 1983 11:48 am>>
        <<Russ Atkinson (RRA) January 23, 1986 0:02:15 am PST>>
        <<Michael Plass, March 29, 1985 5:51:36 pm PST>>
        <<Rick Beach, March 28, 1985 10:15:04 am PST>>
        <<Doug Wyatt, April 14, 1985 7:58:45 pm PST>>

    DIRECTORY
        Atom USING [GetPName, MakeAtom],
        MessageWindow USING [Append],
        NodeStyleOps USING [StyleNameForNode],
        Rope USING [Concat, FromChar, IsEmpty, Map, ROPE],
        RunReader USING [Backwards, FreeRunReader, Get, GetRunReader, Ref, SetPosition],
        TEditDocument USING [Selection],
        TEditDocumentPrivate USING [CloseAndOpenPreviousFile, DefaultMenus, DoCloseAndNewViewer, DoCloseAndOpenImplFile, DoLoadFile, 
        DoLoadImplFile, DoNewViewer, DoOpenFile, DoOpenImplFile, DoStoreFile, EmptyViewer, JumpToPrevious, LoadPreviousFile, 
        OpenPreviousFile, Reselect, Reset, Save],
        TEditInput USING [AllLevels, CloseEvent, FewerLevels, FirstLevelOnly, MoreLevels, Normalize],
        TEditInputOps USING [CallWithLocks, DoFindPlaceholders, DoNextViewer, DoSelectMatchingBrackets],
        TEditOps USING [RememberCurrentPosition],
        TEditProfile USING [selectionCaret],
        TEditRefresh USING [ScrollToEndOfSel],
        TEditScrolling USING [ScrollToPosition],
        TEditSelection USING [FindWhere, MakeSelection, Position, pSel, SetSelLooks],
        TextEdit USING [FetchLooks, FromRope, SetLooks, Size],
        TextFind USING [MalformedPattern, PatternErrorCode],
        TextFindPrivate USING [FinderRecord],
        TextLooks USING [Look, Looks, noLooks, Runs],
        TextLooksSupport USING [LooksAND],
        TextNode USING [Body, Location, NarrowToTextNode, Ref, RefTextNode, StepBackward, StepForward],
        TiogaMenuOps USING [],
        TiogaOps USING [CommentControl, Dir, Finder, FinderRec, Pattern, PatternErrorCode, PatternRec, SearchDir],
        TiogaOpsDefs USING [Location, Viewer],
        TreeFind USING [CommentControl, Create, CreateFromRope, Try, TryBackwards];

    TiogaOps2Impl: CEDAR PROGRAM
    IMPORTS Atom, MessageWindow, NodeStyleOps, Rope, RunReader, TEditDocumentPrivate, TEditInput, TEditInputOps, TEditOps, 
    TEditProfile, TEditRefresh, TEditScrolling, TEditSelection, TextEdit, TextFind, TextLooksSupport, TextNode, TreeFind
    EXPORTS TiogaOpsDefs, TiogaOps, TiogaMenuOps
    = BEGIN OPEN TiogaOps, TiogaOpsDefs;

        ROPE: TYPE ~ Rope.ROPE;
        Ref: TYPE = REF NodeBody; -- points to a Tioga node
        NodeBody: PUBLIC TYPE = TextNode.Body;
        Finder: TYPE = REF FinderRec;
        FinderRec: PUBLIC TYPE = TextFindPrivate.FinderRecord;
        MakeName: PROC [r: ROPE] RETURNS [ATOM] ~ {
        RETURN [IF r.IsEmpty THEN NIL ELSE Atom.MakeAtom[r]];
        };
<<Search>>
    LooksRope: PROC [looks: TextLooks.Looks] RETURNS [r: ROPE] = {
        FOR c: CHAR IN TextLooks.Look DO
            IF looks[c] THEN r _ Rope.Concat[r, Rope.FromChar[c]];
            ENDLOOP
        };

    RopeToLooks: PROC [r: ROPE] RETURNS [looks: TextLooks.Looks] = {
        Set: PROC [c: CHAR] RETURNS [quit: BOOL _ FALSE] = { looks[c] _ TRUE };
        [] _ Rope.Map[base: r, action: Set];
        };

    tiogaOpsEcFromTextFindEc: ARRAY TextFind.PatternErrorCode OF PatternErrorCode _ [
        toobig: toobig,
        endquote: endquote,
        endtilda: endtilda,
        boundary: boundary,
        missingNameEnd: missingNameEnd,
        unmatchedNameEnd: unmatchedNameEnd
        ];

    MalformedPattern: PUBLIC ERROR [ec: PatternErrorCode] ~ CODE;

    ReportMalformedPattern: PROC [textFindEc: TextFind.PatternErrorCode] ~ {
        tiogaOpsEc: PatternErrorCode ~ tiogaOpsEcFromTextFindEc[textFindEc];
    ERROR MalformedPattern[tiogaOpsEc];
        };

    CreateGeneralPattern: PUBLIC PROC [
        target: Ref, -- node from which to get the pattern
        text: BOOL _ TRUE, -- if true, match target text
        looks: BOOL _ FALSE, -- if true, match target looks
        format: BOOL _ FALSE, -- if true, match target format
        style: BOOL _ FALSE, -- if true, match target style
        comment: BOOL _ FALSE, -- if true, match target comment property
        case: BOOL _ TRUE, -- if true, match case
        literal: BOOL _ FALSE, -- if true, treat target literally rather than as a pattern
        word: BOOL _ FALSE, -- if true, match words only
        subset: BOOL _ TRUE, -- if true, use subset for looks test, else use equality
        addBounds: BOOL _ FALSE] -- if true, add |'s to both ends of pattern
        RETURNS [pattern: Pattern] = {
        error: BOOL _ FALSE;
        errorCode: TextFind.PatternErrorCode;
        txt: TextNode.RefTextNode = TextNode.NarrowToTextNode[target];
        patternTxt: TextNode.RefTextNode _ txt;
        pattern _ NEW[PatternRec];
        IF looks AND ~text THEN { -- make a phony search pattern and get the looks
            size: INT = TextEdit.Size[txt];
            lks: TextLooks.Looks = IF size=0 THEN TextLooks.noLooks ELSE TextEdit.FetchLooks[txt,0];
            pattern.searchLooks _ LooksRope[lks];
            FOR i: INT IN [1..size) DO
                IF TextEdit.FetchLooks[txt,i]#lks THEN {
                    OPEN MessageWindow;
                    Append["Search pattern does not have uniform looks.",TRUE];
                    Append["  Using looks from first char."];
                    EXIT };
                ENDLOOP;
            literal _ FALSE;
            patternTxt _ TextEdit.FromRope["#*"];
            TextEdit.SetLooks[NIL, patternTxt, lks];
            };
        pattern.text _ text;
        pattern.looks _ looks;
        pattern.word _ word;
        pattern.looksExact _ ~subset;
        pattern.commentControl _ IF ~comment OR txt=NIL THEN includeComments
            ELSE IF txt.comment THEN commentsOnly ELSE excludeComments;
        pattern.checkFormat _ format;
        pattern.format _ IF target=NIL OR target.formatName=NIL THEN NIL ELSE
            Atom.GetPName[target.formatName];
        pattern.checkStyle _ style;
        pattern.style _ IF ~style THEN NIL ELSE Atom.GetPName[NodeStyleOps.StyleNameForNode[target]];
        IF text OR looks THEN { -- create a description of the pattern
            pattern.finder _ TreeFind.Create[patternTxt, literal, word, ~looks, ~case, addBounds !
            TextFind.MalformedPattern => { errorCode _ ec; error _ TRUE; CONTINUE }];
            };
        IF error THEN ReportMalformedPattern[errorCode];
        };

    CreateSimplePattern: PUBLIC PROC [
        target: ROPE, -- node from which to get the pattern
        case: BOOL _ TRUE, -- if true, match case
        literal: BOOL _ FALSE, -- if true, treat target literally rather than as a pattern
        word: BOOL _ FALSE, -- if true, match words only
        addBounds: BOOL _ FALSE] -- if true, add |'s to both ends of pattern
        RETURNS [pattern: Pattern] = {
        error: BOOL _ FALSE;
        errorCode: TextFind.PatternErrorCode;
        pattern _ NEW[PatternRec];
        pattern.text _ TRUE;
        pattern.looks _ FALSE;
        pattern.word _ word;
        pattern.commentControl _ includeComments;
        pattern.checkFormat _ FALSE;
        pattern.format _ NIL;
        pattern.checkStyle _ FALSE;
        pattern.style _ NIL;
        pattern.finder _ TreeFind.CreateFromRope[target, literal, word, ~case, addBounds !
        TextFind.MalformedPattern => { errorCode _ ec; error _ TRUE; CONTINUE }];
        IF error THEN ReportMalformedPattern[errorCode];
        };

    FindCC: PROC [cc: CommentControl] RETURNS [TreeFind.CommentControl] = {
        RETURN [SELECT cc FROM
            includeComments => includeComments,
            excludeComments => excludeComments,
            commentsOnly => commentsOnly,
            ENDCASE => ERROR] };

    SelectionSearch: PUBLIC PROC [
        pattern: Pattern, whichDir: SearchDir _ forwards, interrupt: REF BOOL _ NIL,
        startBoundaryNode, endBoundaryNode: Ref _ NIL,
        startBoundaryOffset: INT _ 0, endBoundaryOffset: INT _ LAST[INT]]
        RETURNS [found: BOOL] = {
        pSel: TEditDocument.Selection = TEditSelection.pSel;
        Found: PROC [tSel: TEditDocument.Selection] = {
            tSel.viewer _ pSel.viewer;
            tSel.data _ pSel.data;
            TEditOps.RememberCurrentPosition[pSel.viewer];
            TEditSelection.SetSelLooks[tSel];
            TEditSelection.MakeSelection[new: tSel];
            TEditInput.CloseEvent[];
            TEditRefresh.ScrollToEndOfSel[tSel.viewer, FALSE] };
        Locations: PROC RETURNS [start, end: TextNode.Location] = {
            start _ pSel.start.pos; end _ pSel.end.pos };
        found _ DoSearch[pattern, whichDir, interrupt, Found, Locations,
            startBoundaryNode, endBoundaryNode,
            startBoundaryOffset, endBoundaryOffset] };

    DocLoc: PROC [loc: Location] RETURNS [TextNode.Location] = {
        RETURN [[loc.node, loc.where]] };

    MyLoc: PROC [loc: TextNode.Location] RETURNS [Location] = {
        RETURN [[loc.node, loc.where]] };

    NodeSearch: PUBLIC PROC [
        pattern: Pattern, whichDir: SearchDir _ forwards,
        startLoc, endLoc: Location, interrupt: REF BOOL _ NIL,
        startBoundaryNode, endBoundaryNode: Ref _ NIL,
        startBoundaryOffset: INT _ 0, endBoundaryOffset: INT _ LAST[INT]]
        RETURNS [found: BOOL, start, end: Location] = {
        Found: PROC [tSel: TEditDocument.Selection] = {
            start _ MyLoc[tSel.start.pos]; end _ MyLoc[tSel.end.pos] };
        Locations: PROC RETURNS [start, end: TextNode.Location] = {
            start _ DocLoc[startLoc]; end _ DocLoc[endLoc] };
        found _ DoSearch[pattern, whichDir, interrupt, Found, Locations,
            startBoundaryNode, endBoundaryNode,
            startBoundaryOffset, endBoundaryOffset] };

    DoSearch: PROC [
        pattern: Pattern, whichDir: SearchDir _ forwards, interrupt: REF BOOL _ NIL,
        foundProc: PROC [tSel: TEditDocument.Selection],
        locationProc: PROC RETURNS [start, end: TextNode.Location],
        startBoundaryNode, endBoundaryNode: Ref _ NIL,
        startBoundaryOffset: INT _ 0, endBoundaryOffset: INT _ LAST[INT]]
        RETURNS [found: BOOL] = {
        at, atEnd, offset: INT;
        first: TextNode.Ref;
        where: TextNode.RefTextNode;
        startLoc, endLoc: TextNode.Location;

        DoLookForPattern: PROC [root: TextNode.Ref, tSel: TEditDocument.Selection] = {
            Forwards: PROC = {
                IF (offset _ endLoc.where+1) >=
                    TextEdit.Size[TextNode.NarrowToTextNode[first _ endLoc.node]] THEN {
                    first _ TextNode.StepForward[first]; offset _ 0 };
                [found,where,at,atEnd,,] _
                    TreeFind.Try[finder: pattern.finder, first: first, start: offset,
                        last: endBoundaryNode, lastLen: endBoundaryOffset,
                        interrupt: interrupt,
                        looksExact: pattern.looksExact,
                        checkFormat: pattern.checkFormat,
                        format: MakeName[pattern.format],
                        commentControl: FindCC[pattern.commentControl],
                        checkStyle: pattern.checkStyle,
                        style: MakeName[pattern.style],
                        styleProc: NodeStyleOps.StyleNameForNode] };

            Backwards: PROC = {
                IF (offset _ startLoc.where)=0 THEN {
                    first _ TextNode.StepBackward[startLoc.node];
                    offset _ LAST[INT] }
                ELSE first _ startLoc.node;
                [found,where,at,atEnd,,] _
                    TreeFind.TryBackwards[finder: pattern.finder,
                        first: first, len: offset,
                        last: startBoundaryNode, lastStart: startBoundaryOffset,
                        interrupt: interrupt,
                        looksExact: pattern.looksExact,
                        checkFormat: pattern.checkFormat,
                        format: MakeName[pattern.format],
                        commentControl: FindCC[pattern.commentControl],
                        checkStyle: pattern.checkStyle,
                        style: MakeName[pattern.style],
                        styleProc: NodeStyleOps.StyleNameForNode] };

            [startLoc, endLoc] _ locationProc[];
            IF interrupt#NIL THEN interrupt^ _ FALSE;
            SELECT whichDir FROM
                forwards => Forwards[];
                backwards => Backwards[];
                anywhere => {
                    Forwards[];
                    IF found THEN whichDir _ forwards ELSE {
                        whichDir _ backwards; Backwards[] }};
                ENDCASE => ERROR;
            IF ~found OR where=NIL THEN RETURN;
            IF pattern.looks AND ~pattern.text AND ~pattern.word THEN
                [at,atEnd] _ Extend[whichDir=forwards,
                    pattern.looksExact, RopeToLooks[pattern.searchLooks], where, at, atEnd];
            tSel.start.pos _ [where,at];
            tSel.end.pos _ [where,MAX[0,atEnd-1]];
            tSel.granularity _
                IF ~pattern.looks AND ~pattern.text THEN node
                ELSE IF pattern.word THEN word ELSE char;
            tSel.insertion _ IF TEditProfile.selectionCaret=before THEN before ELSE after;
            foundProc[tSel];
            };

        TEditInputOps.CallWithLocks[DoLookForPattern, read] };

    Extend: PROC
        [forward, looksExact: BOOL, searchLooks: TextLooks.Looks,
            where: TextNode.RefTextNode, at, atEnd: INT,
            last: TextNode.Ref _ NIL, lastLen: INT _ LAST[INT]]
        RETURNS [newAt, newAtEnd: INT] = {
        runrdr: RunReader.Ref _ RunReader.GetRunReader[];
        looks: TextLooks.Looks;
        runLen: INT;
        runs: TextLooks.Runs _ where.runs;
        IF forward THEN { -- extend toward end of node
            size: INT ~ TextEdit.Size[where];
            IF atEnd<size THEN {
                lastLen _ IF where=last THEN MIN[size,lastLen] ELSE size;
                RunReader.SetPosition[runrdr,runs,atEnd];
                WHILE atEnd < lastLen DO
                    IF runs=NIL THEN { runLen _ size-atEnd; looks _ TextLooks.noLooks }
                    ELSE [runLen,looks] _ RunReader.Get[runrdr];
                    IF ~looksExact THEN looks _ TextLooksSupport.LooksAND[looks,searchLooks];
                    IF searchLooks # looks THEN EXIT;
                    atEnd _ atEnd+runLen;
                    ENDLOOP;
                atEnd _ MIN[atEnd,lastLen];
                };
            }
        ELSE IF at>0 THEN { -- extend backward
            RunReader.SetPosition[runrdr,runs,at];
            WHILE at > 0 DO
                IF runs=NIL THEN { runLen _ at; looks _ TextLooks.noLooks }
                ELSE [runLen,looks] _ RunReader.Backwards[runrdr];
                IF ~looksExact THEN looks _ TextLooksSupport.LooksAND[looks,searchLooks];
                IF searchLooks # looks THEN EXIT;
                at _ at-runLen;
                ENDLOOP;
            };
        RunReader.FreeRunReader[runrdr];
        RETURN[at, atEnd];
        };

    SelectMatchingBrackets: PUBLIC PROC [before, after: CHAR] RETURNS [found: BOOL] = {
        found _ TEditInputOps.DoSelectMatchingBrackets[before, after] };

    NextPlaceholder: PUBLIC PROC [dir: Dir _ forward, gotoend: BOOL,
        startBoundaryNode, endBoundaryNode: Ref _ NIL,
        startBoundaryOffset: INT _ 0, endBoundaryOffset: INT _ LAST[INT]]
        RETURNS [found, wenttoend: BOOL] = {
        [found, wenttoend] _ TEditInputOps.DoFindPlaceholders[
            dir=forward, gotoend,
            startBoundaryNode, endBoundaryNode,
            startBoundaryOffset, endBoundaryOffset] };

    NextViewer: PUBLIC PROC [dir: Dir _ forward] RETURNS [found: BOOL] = {
        found _ TEditInputOps.DoNextViewer[dir=forward] };

    SearchWhere: PROC [whichDir: SearchDir] RETURNS [TEditSelection.FindWhere] = INLINE {
        RETURN [SELECT whichDir FROM
            forwards => forwards,
            backwards => backwards,
            anywhere => anywhere,
            ENDCASE => ERROR] };

<<Places menu commands>>
    Position: PUBLIC PROC [viewer: Viewer] = {
        TEditSelection.Position[viewer];
        };

    Normalize: PUBLIC PROC [viewer: Viewer] = {
        [] _ TEditInput.Normalize[viewer];
        };

    PrevPlace: PUBLIC PROC [viewer: Viewer] = {
        TEditDocumentPrivate.JumpToPrevious[viewer];
        };

    Reselect: PUBLIC PROC [viewer: Viewer] = {
        TEditDocumentPrivate.Reselect[viewer];
        };
<<Files and text viewers>>
    Save: PUBLIC PROC [viewer: Viewer] = {
        TEditDocumentPrivate.Save[viewer];
        };

    Load: PUBLIC PROC [viewer: Viewer, fileName: ROPE _ NIL,
        fileNameProcViewer: Viewer _ NIL] = {
        [] _ TEditDocumentPrivate.DoLoadFile[viewer, fileName, FALSE, fileNameProcViewer];
        };

    Open: PUBLIC PROC [fileName: ROPE _ NIL, fileNameProcViewer: Viewer _ NIL] RETURNS [Viewer] = {
        RETURN [TEditDocumentPrivate.DoOpenFile[fileName, fileNameProcViewer]];
        };

    CloseAndOpen: PUBLIC PROC [viewer: Viewer, fileName: ROPE _ NIL, fileNameProcViewer: Viewer _ NIL] RETURNS [Viewer] = {
        RETURN [TEditDocumentPrivate.DoLoadFile[viewer, fileName, TRUE, fileNameProcViewer]];
        };

    LoadImpl: PUBLIC PROC [viewer: Viewer, fileName: ROPE _ NIL] = {
        [] _ TEditDocumentPrivate.DoLoadImplFile[viewer, fileName];
        };

    OpenImpl: PUBLIC PROC [fileName: ROPE _ NIL] RETURNS [Viewer] = {
        RETURN [TEditDocumentPrivate.DoOpenImplFile[fileName]];
        };

    CloseAndOpenImpl: PUBLIC PROC [viewer: Viewer, fileName: ROPE _ NIL] RETURNS [Viewer] = {
        RETURN [TEditDocumentPrivate.DoCloseAndOpenImplFile[viewer, fileName]];
        };

    LoadPreviousFile: PUBLIC PROC [parent: Viewer] = {
        TEditDocumentPrivate.LoadPreviousFile[parent];
        };

    OpenPreviousFile: PUBLIC PROC [parent: Viewer] = {
        TEditDocumentPrivate.OpenPreviousFile[parent];
        };

    CloseAndOpenPreviousFile: PUBLIC PROC [parent: Viewer] = {
        TEditDocumentPrivate.CloseAndOpenPreviousFile[parent];
        };

    DefaultMenus: PUBLIC PROC [viewer: Viewer, paint: BOOL _ FALSE] = {
        TEditDocumentPrivate.DefaultMenus[viewer, paint];
        };

    Store: PUBLIC PROC [viewer: Viewer, fileName: ROPE _ NIL] = {
        TEditDocumentPrivate.DoStoreFile[viewer, fileName];
        };

    New: PUBLIC PROC RETURNS [Viewer] = {
        RETURN [TEditDocumentPrivate.DoNewViewer[]];
        };

    Empty: PUBLIC PROC [viewer: Viewer] = {
        TEditDocumentPrivate.EmptyViewer[viewer];
        };

    CloseAndNewViewer: PUBLIC PROC [viewer: Viewer] RETURNS [Viewer] = {
        RETURN [TEditDocumentPrivate.DoCloseAndNewViewer[viewer]];
        };

    Reset: PUBLIC PROC [viewer: Viewer] = {
        TEditDocumentPrivate.Reset[viewer];
        };

    Jump: PUBLIC PROC [viewer: Viewer, loc: Location] = {
        [] _ TEditScrolling.ScrollToPosition[viewer, [loc.node, loc.where]];
        };
<<Levels menu commands>>

        FirstLevelOnly: PUBLIC PROC [viewer: Viewer] = { [] _ TEditInput.FirstLevelOnly[viewer] };

        MoreLevels: PUBLIC PROC [viewer: Viewer] = { [] _ TEditInput.MoreLevels[viewer] };

        FewerLevels: PUBLIC PROC [viewer: Viewer] = { [] _ TEditInput.FewerLevels[viewer] };

        AllLevels: PUBLIC PROC [viewer: Viewer] = { [] _ TEditInput.AllLevels[viewer] };

    END.