<<>>
    <<SpyToolImpl.mesa>>
        <<Copyright ╙ 1990, 1991 by Xerox Corporation.  All rights reserved.>>
        <<Michael Plass, May 24, 1991 11:04 am PDT>>
        <<Chauser, October 8, 1992 9:23 am PDT>>

    DIRECTORY RefTab, ImagerColor, Imager, List, CardTab, InputFocus, Spy, ViewerLocks, Menus, TreeGrapher, Convert, ViewerClasses, 
    Rope, RefText, Atom, TreeGrapherViewer, IO, PFS, ViewerOps, Commander, CommanderOps;

    SpyToolImpl: CEDAR PROGRAM
    IMPORTS RefTab, ImagerColor, Imager, List, CardTab, Rope, InputFocus, Spy, ViewerLocks, Menus, TreeGrapher, Commander, 
    CommanderOps, Convert, RefText, Atom, TreeGrapherViewer, IO, PFS, ViewerOps
    ~ BEGIN

        ROPE: TYPE ~ Rope.ROPE;
        Color: TYPE ~ ImagerColor.Color;

        StripQuotes: PROC [text: REF TEXT] ~ {
        <<Does not handle multi-character escaped things.>>
            i, j: NAT м 0;
            UNTIL i = text.length DO
                SELECT text[i] FROM
                    '" => { i м i + 1 };
                    '\\ => { i м i + 1; IF i = text.length THEN ERROR; text[j] м text[i]; i м i+1; j м j+1 };
                    ENDCASE => { text[j] м text[i]; i м i + 1; j м j + 1 };
                ENDLOOP;
            text.length м j;
            };

        Canon: PROC [rope: ROPE] RETURNS [ROPE] ~ {
            RETURN [Atom.GetPName[Atom.MakeAtom[rope]]];
            };

        ReadAny: PROC [stream: IO.STREAM] RETURNS [REF] ~ {
            buffer: REF TEXT м NEW[TEXT[80]];
            tokenKind: IO.TokenKind;
            charsSkipped: INT;
            error: IO.TokenError;
            stack: LIST OF LIST OF REF м NIL;
            head: LIST OF REF м LIST[NIL];
            last: LIST OF REF м head;
            DO
                v: REF м NIL;
                [tokenKind, buffer, charsSkipped, error] м IO.GetCedarToken[stream: stream, buffer: buffer, flushComments: FALSE];
                SELECT tokenKind FROM
                    tokenSINGLE => {
                        SELECT buffer[0] FROM
                            '; => { [] м IO.GetLine[stream, buffer]; LOOP };
                            '( => {
                                head.first м last;
                                stack м CONS[head, stack];
                                last м head м LIST[NIL];
                                LOOP;
                                };
                            ') => {
                                v м head.rest;
                                head м stack.first;
                                stack м stack.rest;
                                last м NARROW[head.first];
                                head.first м NIL;
                                };
                            ENDCASE => GOTO ParseFailed;
                        };
                    tokenDECIMAL => {
                        v м NEW[CARD м Convert.CardFromRope[RefText.TrustTextAsRope[buffer]]];
                        };
                    tokenID => {
                        v м Atom.MakeAtomFromRefText[buffer];
                        };
                    tokenROPE => {
                        StripQuotes[buffer];
                        <<We canonicalize these, because we expect lots of repeats.>>
                        v м Atom.GetPName[Atom.MakeAtomFromRefText[buffer]];
                        };
                    ENDCASE => GOTO ParseFailed;
                IF stack = NIL THEN RETURN [v];
                last м last.rest м LIST[v];
                ENDLOOP;
            EXITS ParseFailed => CommanderOps.Failed[IO.PutFR1["Parse error near %g", [integer[IO.GetIndex[stream]]]]];
            };

        ST: TYPE ~ LIST OF REF;

        STCount: PROC [st: ST] RETURNS [CARD] ~ {
            IF st.first = $Merged THEN {
                i: CARD м 0;
                FOR tail: LIST OF REF м st.rest, tail.rest UNTIL tail = NIL DO
                    i м i + STCount[NARROW[tail.first]];
                    ENDLOOP;
                RETURN [i];
                };
            WITH st.first SELECT FROM
                c: REF CARD => RETURN [cн];
                c: REF REF CARD => RETURN [cнн];
                ENDCASE => ERROR;
            };
        STName: PROC [st: ST] RETURNS [ROPE] ~ {
            RETURN [IF st.first = $Merged THEN "*" ELSE NARROW[st.rest.first]];
            };
        STEntryPC: PROC [st: ST] RETURNS [CARD] ~ {
            RETURN [IF st.first = $Merged THEN 0 ELSE NARROW[st.rest.rest.first, REF CARD]н];
            };
        STOffset: PROC [st: ST] RETURNS [CARD] ~ {
            RETURN [IF st.first = $Merged THEN 0 ELSE NARROW[st.rest.rest.rest.first, REF CARD]н];
            };
        STChildren: PROC [st: ST] RETURNS [LIST OF REF] ~ {
            RETURN [IF st.first = $Merged THEN st.rest ELSE st.rest.rest.rest.rest];
            };
        STLocalCount: PROC [st: ST] RETURNS [CARD] ~ {
            IF st.first = $Merged THEN RETURN [0] ELSE {
                i: CARD м STCount[st];
                FOR tail: LIST OF REF м STChildren[st], tail.rest UNTIL tail = NIL DO
                    i м i - STCount[NARROW[tail.first]];
                    ENDLOOP;
                RETURN [i]
                };
            };
        STDeleted: PROC [st: ST] RETURNS [BOOL] ~ {
            WITH st.first SELECT FROM
                c: REF CARD => RETURN [FALSE];
                c: REF REF CARD => RETURN [TRUE];
                ENDCASE => {
                    FOR tail: LIST OF REF м STChildren[st], tail.rest UNTIL tail = NIL DO
                        IF NOT STDeleted[NARROW[tail.first]] THEN RETURN [FALSE];
                        ENDLOOP;
                    RETURN [TRUE]
                    };
            };
        STDelete: PROC [st: ST] ~ {
            IF st.first = $Merged
                THEN {
                    FOR tail: LIST OF REF м STChildren[st], tail.rest UNTIL tail = NIL DO
                        STDelete[NARROW[tail.first]];
                        ENDLOOP;
                    }
                ELSE {
                    WITH st.first SELECT FROM
                        c: REF CARD => st.first м NEW[REF CARD м c];
                        ENDCASE;
                    };
            };
        STUnDelete: PROC [st: ST] ~ {
            WITH st.first SELECT FROM
                c: REF REF CARD => st.first м cн;
                ENDCASE;
            FOR tail: LIST OF REF м STChildren[st], tail.rest UNTIL tail = NIL DO
                STUnDelete[NARROW[tail.first]];
                ENDLOOP;
            };


        ReadTreeFromFile: PROC [fileName: ROPE] RETURNS [ST] ~ {
            ENABLE PFS.Error => { CommanderOps.Failed[error.explanation] };
            stream: IO.STREAM ~ PFS.StreamOpen[PFS.PathFromRope[fileName]];
            spyTree: ST м NARROW[ReadAny[stream]];
            IO.Close[stream];
            RETURN [spyTree]
            };

        CookedNode: TYPE ~ REF CookedNodeRep;
        CookedNodeRep: TYPE ~ RECORD [
            st: ST,
            ep: CARD,
            name: ROPE,
            cumulativeCount: CARD,
            localCount: CARD,
            counted: BOOL,
            mergeTarget: BOOL м FALSE,
            mergedNodes: CARD м 0,
            mergedCount: CARD м 0,
            children: LIST OF CookedNode,
            merged: CookedNode м NIL
            ];

        enableName: ROPE м Canon["SignalsImpl._XR_Enable"];

        Control: TYPE ~ { pruneJunk, collapseEnables, collapseSelfRecursion, collapseThreads, unmerged, stackChains };
        Controls: TYPE ~ PACKED ARRAY Control OF TrueBool;
        TrueBool: TYPE ~ BOOL м TRUE;
        controlNames: ARRAY Control OF ATOM м [
            pruneJunk: $Junk,
            collapseEnables: $Enables,
            collapseSelfRecursion: $SelfCalls,
            collapseThreads: $Threads,
            unmerged: $Merge,
            stackChains: $Chains
            ];

        junk: LIST OF ROPE м LIST[
            Canon["Threads2._XR_Yield"],
            Canon["sigpause._sigpause"],
            Canon["ThreadsQueues._XR_WaitCV"],
            Canon["ThreadsQueues._XR_MonitorEntryOutOfLine"],
            Canon["ThreadsQueues._XR_MonitorExitOutOfLine"],
            Canon["Threads1._XR_ExitJumpee"],
            Canon["ThreadsMachDep._XR_MonitorEntry"],
            Canon["select._select"],
            Canon["sigsetmask._sigsetmask"],
            Canon["ThreadsInlines._XR_CheckReschedRequest"]
            ];

        SetCountedJunk: PROC [cooked: CookedNode, counted: BOOL] ~ {
            FOR tail: LIST OF CookedNode м cooked.children, tail.rest UNTIL tail = NIL DO
                SetCountedJunk[tail.first, counted];
                ENDLOOP;
            FOR tail: LIST OF ROPE м junk, tail.rest UNTIL tail = NIL DO
                IF tail.first = cooked.name THEN {
                    cooked.counted м counted;
                    };
                ENDLOOP;
            };

        MergeData: TYPE ~ REF MergeDataRep;
        MergeDataRep: TYPE ~ RECORD [
            nest: CARD м 0,
            maxNest: CARD м 0,
            count: CARD м 0,
            max: CookedNode м NIL
            ];
        MergeSimilarNodes: PROC [root: CookedNode] ~ {
            tab: CardTab.Ref ~ CardTab.Create[];
            merged: LIST OF CookedNode м NIL;
            Get: PROC [ep: CARD] RETURNS [data: MergeData] ~ {
                Action: CardTab.UpdateAction ~ {
                    <<PROC [found: BOOL, val: Val] RETURNS [op: UpdateOperation _ none, new: Val _ NIL]>>
                    IF found
                        THEN data м NARROW[val]
                        ELSE { op м store; new м data м NEW[MergeDataRep] }
                    };
                CardTab.Update[tab, ep, Action];
                };
            Pass1: PROC [cooked: CookedNode] ~ {
                data: MergeData ~ Get[cooked.ep];
                data.nest м data.nest + 1;
                data.maxNest м MAX[data.nest, data.maxNest];
                data.count м data.count + 1;
                <<IF data.max = NIL OR data.max.cumulativeCount < cooked.cumulativeCount THEN data.max _ cooked;>>
                FOR tail: LIST OF CookedNode м cooked.children, tail.rest UNTIL tail = NIL DO
                    Pass1[tail.first];
                    ENDLOOP;
                data.nest м data.nest - 1;
                };
            Pass2: PROC [cooked: CookedNode] ~ {
                data: MergeData ~ Get[cooked.ep];
                IF cooked.ep # 0 AND data.maxNest = 1 AND data.count > 1 THEN {
                    copy: CookedNode м NEW[CookedNodeRep м cookedн];
                    merged м MergeAdjacentSiblings[MergeLists[merged, LIST[copy]]];
                    cooked.merged м copy;
                    cooked.children м NIL;
                    cooked.localCount м cooked.cumulativeCount;
                    };
                FOR tail: LIST OF CookedNode м cooked.children, tail.rest UNTIL tail = NIL DO
                    Pass2[tail.first];
                    ENDLOOP;
                };
            [] м Accumulate[root];
            Pass1[root];
            Pass2[root];
            IF merged # NIL THEN {
                copy: CookedNode м NEW[CookedNodeRep м rootн];
                FOR tail: LIST OF CookedNode м merged, tail.rest UNTIL tail = NIL DO
                    data: MergeData ~ Get[tail.first.ep];
                    tail.first.mergedNodes м data.count;
                    ENDLOOP;
                root.children м CONS[copy, merged];
                root.localCount м 0;
                [] м Accumulate[root];
                root.mergedCount м root.cumulativeCount - copy.cumulativeCount;
                };
            CardTab.Erase[tab];
            };

        Cook: PROC [spyTree: ST, controls: Controls] RETURNS [CookedNode] = {
            cooked: CookedNode ~ ReallyCook[spyTree, controls];
            SetCountedJunk[cooked, NOT controls[pruneJunk]];
            IF NOT controls[unmerged] THEN {
                MergeSimilarNodes[cooked];
                };
            RETURN [cooked]
            };

        ReallyCook: PROC [spyTree: ST, controls: Controls] RETURNS [CookedNode] = {
            ep: CARD м STEntryPC[spyTree];
            localCount: CARD м 0;
            children: LIST OF CookedNode м NIL;
            last: LIST OF CookedNode м NIL;
            Adopt: PROC [new: LIST OF CookedNode] ~ {
                children м MergeLists[children, new];
                last м children;
                IF last # NIL THEN UNTIL last.rest = NIL DO last м last.rest ENDLOOP;
                };
            IF NOT STDeleted[spyTree] THEN {
                localCount м STLocalCount[spyTree];
                FOR tail: LIST OF REF м STChildren[spyTree], tail.rest UNTIL tail = NIL DO
                    child: CookedNode м ReallyCook[NARROW[tail.first], controls];
                    SELECT TRUE FROM
                        controls[collapseThreads] AND (child.ep MOD 2 # 0) => {
                            <<Enable clause - do some merging>>
                            Adopt[child.children];
                            localCount м localCount + child.localCount;
                            };
                        controls[collapseEnables] AND (child.name = enableName AND child.children # NIL AND child.children.rest = NIL) => {
                            <<Enable clause - do some merging>>
                            Adopt[child.children.first.children];
                            localCount м localCount + child.localCount + child.children.first.localCount;
                            };
                        controls[collapseSelfRecursion] AND (child.ep = ep) => {
                            <<Direct recursion - collapse into parent.>>
                            Adopt[child.children];
                            localCount м localCount + child.localCount;
                            };
                        ENDCASE => {
                        <<Normal case>>
                            new: LIST OF CookedNode м LIST[child];
                            IF last = NIL THEN last м children м new ELSE last м last.rest м new;
                            };
                    ENDLOOP;
                children м MergeAdjacentSiblings[children];
                };
            RETURN [NEW[CookedNodeRep м [
                st: spyTree, 
                ep: ep,
                name: STName[spyTree],
                cumulativeCount: 0, -- filled in later
                localCount: localCount,
                counted: TRUE,
                children: children
                ]]]
            };

        MergeSTs: PROC [a, b: ST] RETURNS [ST] ~ {
            aSet: LIST OF REF ~ IF a.first = $Merged THEN NARROW[a.rest] ELSE LIST[a];
            bSet: LIST OF REF ~ IF b.first = $Merged THEN NARROW[b.rest] ELSE LIST[b];
            RETURN [CONS[$Merged, List.Append[aSet, bSet]]]
            };

        MergeAdjacentSiblings: PROC [nodes: LIST OF CookedNode] RETURNS [LIST OF CookedNode] ~ {
            rest: LIST OF CookedNode м NIL;
            FOR tail: LIST OF CookedNode м nodes, rest UNTIL tail = NIL DO
                rest м tail.rest;
                IF rest # NIL AND rest.first.ep = tail.first.ep AND NOT (tail.first.mergeTarget AND rest.first.mergeTarget) THEN {
                    IF rest.first.mergeTarget THEN {
                    <<Do not lose a mergeTarget!>>
                        t: CookedNode м rest.first;
                        rest.first м tail.first;
                        tail.first м t;
                        };
                    IF rest.first.merged = NIL
                        THEN {
                            tail.first.localCount м tail.first.localCount + rest.first.localCount;
                            tail.first.children м MergeAdjacentSiblings[MergeLists[tail.first.children, rest.first.children]];
                            }
                        ELSE {
                            IF rest.first.merged = tail.first THEN {
                                tail.first.mergedCount м tail.first.mergedCount - MIN[tail.first.mergedCount, tail.first.localCount];
                                };
                            };
                    tail.first.st м MergeSTs[tail.first.st, rest.first.st];
                    tail.rest м rest.rest;
                    rest м tail;
                    };
                ENDLOOP;
            RETURN [nodes]
            };

        MergeLists: PROC [a, b: LIST OF CookedNode] RETURNS [LIST OF CookedNode] ~ {
            IF a = NIL THEN RETURN[b];
            IF b = NIL THEN RETURN[a];
            IF a.first.ep <= b.first.ep
                THEN RETURN [CONS[a.first, MergeLists[a.rest, b]]]
                ELSE RETURN [CONS[b.first, MergeLists[a, b.rest]]]
            };

        Accumulate: PROC [cooked: CookedNode] RETURNS [CARD] ~ {
            <<Fills in the cumulativeCount fields.>>
            sum: CARD м 0;
            FOR tail: LIST OF CookedNode м cooked.children, tail.rest UNTIL tail = NIL DO
                sum м sum + Accumulate[tail.first];
                ENDLOOP;
            IF cooked.counted THEN sum м sum + cooked.localCount;
            cooked.cumulativeCount м sum;
            RETURN [sum - MIN[cooked.mergedCount, sum]]
            };

        GetReal: PROC [viewer: ViewerClasses.Viewer, key: ATOM, default: REAL] RETURNS [REAL] ~ {
            IF viewer # NIL THEN WITH ViewerOps.FetchProp[viewer, key] SELECT FROM
                r: REF REAL => RETURN [rн];
                ENDCASE;
            RETURN [default]
            };

        ShortenName: PROC [rope: ROPE] RETURNS [ROPE] ~ {
            text: REF TEXT м RefText.AppendRope[to: RefText.ObtainScratch[Rope.Size[rope]], from: rope];
            i, j, u, d: NAT м 0;
            UNTIL i = text.length DO
                c: CHAR ~ text[i];
                IF c = '_ THEN {IF i > 0 AND text[i-1] = '. THEN { i м i + 1; LOOP } ELSE u м j };
                d м IF c IN ['0..'9] THEN d + 1 ELSE 0;
                text[j] м c; i м i + 1; j м j + 1;
                ENDLOOP;
            text.length м IF u + 2 + d = j AND text[u + 1] = 'P THEN u ELSE j;
            rope м Atom.GetPName[Atom.MakeAtomFromRefText[text]];
            RefText.ReleaseScratch[text];
            RETURN [rope]
            };

        GrapherFromCooked: PROC [cooked: CookedNode, data: TreeGrapherViewer.ViewerData, viewer: ViewerClasses.Viewer] RETURNS 
        [TreeGrapher.Node] = {
            textFormat: TreeGrapherViewer.TextFormat ~ TreeGrapherViewer.FindFormat[data, $spynode];
            sum: CARD м Accumulate[cooked];
            scale: REAL м 200.0/MAX[sum, 1];
            threshold: REAL ~ sum*GetReal[viewer, $SpyCutoff, 0.03];
            c: REF Controls ~ IF viewer # NIL THEN NARROW[ViewerOps.FetchProp[viewer, $SpyToolControls]] ELSE NIL;
            Inner: PROC [cooked: CookedNode] RETURNS [n: TreeGrapher.Node] = {
                IF cooked.cumulativeCount < threshold THEN RETURN [NIL] ELSE {
                    name: ROPE м ShortenName[cooked.name];
                    children: LIST OF TreeGrapher.Node м NIL;
                    IF cooked.mergedNodes # 0 THEN name м IO.PutFR["%g *(%g)", [rope[name]], [cardinal[cooked.mergedNodes]]];
                    IF cooked.merged # NIL THEN name м Rope.Concat[name, "--> *"];
                    IF cooked.children # NIL AND cooked.children.rest = NIL AND cooked.localCount = 0 AND (c = NIL OR c[stackChains])
                        THEN {
                        <<Collapse long call chains...>>
                            n м Inner[cooked.children.first];
                            IF n # NIL THEN {
                                d: TreeGrapherViewer.TextData ~ NARROW[n.data];
                                d.clientData м cooked;
                                d.lines м CONS[name, d.lines];
                                };
                            }
                        ELSE {
                            clippedCount: CARD м 0;
                            FOR tail: LIST OF CookedNode м cooked.children, tail.rest UNTIL tail = NIL DO
                                child: TreeGrapher.Node ~ Inner[tail.first];
                                IF child # NIL
                                    THEN { children м CONS[child, children] }
                                    ELSE { clippedCount м clippedCount + (tail.first.cumulativeCount - MIN[tail.first.mergedCount, tail.first.cumulativeCount]) };
                                ENDLOOP;
                            {
                                nested: CARD м cooked.cumulativeCount;
                                Detract: PROC [otherCount: CARD] RETURNS [CARD] ~ INLINE {
                                    IF otherCount > nested THEN otherCount м 0;
                                    nested м nested - otherCount;
                                    RETURN [otherCount]
                                    };
                                merged: CARD ~ Detract[cooked.mergedCount];
                                local: CARD ~ Detract[IF cooked.counted THEN cooked.localCount ELSE 0];
                                clipped: CARD ~ Detract[clippedCount];
                                counts: ROPE ~ Rope.Cat["(", Convert.RopeFromCard[cooked.cumulativeCount], "/", Convert.RopeFromCard[sum], ")" ];
                                n м TreeGrapherViewer.NodeFromText[
                                    lines: LIST[name, counts],
                                    textFormat: textFormat,
                                    fillSizes: LIST[
                                        REAL[merged]*scale,
                                        REAL[local]*scale,
                                        REAL[clipped]*scale,
                                        REAL[nested]*scale
                                        ],
                                    clientData: cooked,
                                    click: data.click];
                                };
                            n.children м children;
                            };
                    };
                };
            RETURN [Inner[cooked]]
            };

        SetCounted: PROC [cooked: CookedNode, counted: BOOL] ~ {
            FOR tail: LIST OF CookedNode м cooked.children, tail.rest UNTIL tail = NIL DO
                SetCounted[tail.first, counted];
                ENDLOOP;
            cooked.counted м counted;
            };

        debug: BOOL м TRUE;

        MenuClick: ViewerClasses.ClickProc ~ {
            <<PROC [parent: Viewer, clientData: REF ANY _ NIL, mouseButton: MouseButton _ red, shift, control: BOOL _ FALSE]>>
            repaint: BOOL м FALSE;
            Inner: PROC ~ {
                ENABLE UNCAUGHT => { Spy.SampleMyStack[]; ViewerOps.BlinkDisplay[]; IF NOT debug THEN CONTINUE };
                WITH parent.data SELECT FROM
                    data: TreeGrapherViewer.ViewerData => {
                        cooked: CookedNode м NARROW[NARROW[data.tree.data, TreeGrapherViewer.TextData].clientData];
                        tree: TreeGrapher.Node м data.tree;
                        SetCutoff: PROC [r: REAL] ~ {
                            repaint м TRUE;
                            ViewerOps.AddProp[parent, $SpyCutoff, NEW[REAL м r]];
                            };
                        SELECT clientData FROM
                            $UnDelete => {
                                c: REF Controls ~ NARROW[ViewerOps.FetchProp[parent, $SpyToolControls]];
                                STUnDelete[cooked.st];
                                cooked м Cook[cooked.st, cн];
                                repaint м TRUE;
                                };
                            $PrevRoot => {
                                c: REF Controls ~ NARROW[ViewerOps.FetchProp[parent, $SpyToolControls]];
                                old: LIST OF ST м NARROW[ViewerOps.FetchProp[parent, $SpyPreviousRoot]];
                                IF old # NIL THEN {
                                    ViewerOps.AddProp[parent, $SpyPreviousRoot, old.rest];
                                    cooked м Cook[old.first, cн];
                                    repaint м TRUE;
                                    };
                                };
                            $C10 => {SetCutoff[0.10]};
                            $C5 => {SetCutoff[0.05]};
                            $C3 => {SetCutoff[0.03]};
                            $C1 => {SetCutoff[0.01]};
                            $C0 => {SetCutoff[0.00001]}; -- not quite zero, because we want zero counts to vanish.
                            ENDCASE => {
                                FOR control: Control IN Control DO
                                    IF clientData = controlNames[control] THEN {
                                        val: BOOL ~ mouseButton # red;
                                        c: REF Controls ~ NARROW[ViewerOps.FetchProp[parent, $SpyToolControls]];
                                        IF c[control] # val THEN {
                                            c[control] м val;
                                            cooked м Cook[cooked.st, cн];
                                            repaint м TRUE;
                                            };
                                        EXIT;
                                        };
                                    ENDLOOP;
                                };
                        IF repaint THEN {
                            cooked.counted м TRUE;
                            tree м GrapherFromCooked[cooked, data, parent];
                            TreeGrapher.DoLayout[tree, data.lp];
                            data.tree м tree;
                            data.origin м [1.0-tree.layout.treeBox.xmin, parent.ch/2 - 0.5*(tree.layout.bounds.ymax+tree.layout.bounds.ymin)];
                            };
                        };
                    ENDCASE;
                };
            ViewerLocks.CallUnderWriteLock[Inner, parent];
            IF repaint THEN ViewerOps.PaintViewer[parent, client];
            };

        TreeClick: ViewerClasses.ClickProc ~ {
            <<PROC [parent: Viewer, clientData: REF ANY _ NIL, mouseButton: MouseButton _ red, shift, control: BOOL _ FALSE]>>
            repaint: BOOL м FALSE;
            normalize: BOOL м FALSE;
            input: LIST OF REF м LIST[NIL];
            last: LIST OF REF м input;
            Inner: PROC ~ {
                ENABLE UNCAUGHT => { Spy.SampleMyStack[]; ViewerOps.BlinkDisplay[]; IF NOT debug THEN CONTINUE };
                WITH parent.data SELECT FROM
                    data: TreeGrapherViewer.ViewerData => {
                        tree: TreeGrapher.Node м data.tree;
                        root: CookedNode м NARROW[NARROW[data.tree.data, TreeGrapherViewer.TextData].clientData];
                        WITH clientData SELECT FROM
                            node: TreeGrapher.Node => {
                                WITH node.data SELECT FROM
                                    textData: TreeGrapherViewer.TextData => {
                                        WITH textData.clientData SELECT FROM
                                            cooked: CookedNode => {
                                                SELECT TRUE FROM
                                                    control AND shift => {
                                                        IF cooked # root THEN {
                                                            c: REF Controls ~ NARROW[ViewerOps.FetchProp[parent, $SpyToolControls]];
                                                            list: LIST OF ST м NARROW[ViewerOps.FetchProp[parent, $SpyPreviousRoot]];
                                                            list м CONS[root.st, list];
                                                            ViewerOps.AddProp[parent, $SpyPreviousRoot, list];
                                                            normalize м repaint м TRUE;
                                                            cooked м Cook[cooked.st, cн];
                                                            root м cooked;
                                                            };
                                                        };
                                                    control AND NOT shift => {
                                                        c: REF Controls ~ NARROW[ViewerOps.FetchProp[parent, $SpyToolControls]];
                                                        STDelete[cooked.st];
                                                        root м Cook[root.st, cн];
                                                        repaint м TRUE;
                                                        };
                                                    shift AND NOT control => {
                                                        dlm: ROPE м " ";
                                                        FOR tail: LIST OF ROPE м textData.lines, tail.rest UNTIL tail = NIL DO
                                                            last м last.rest м LIST[tail.first];
                                                            IF tail.rest # NIL THEN last м last.rest м LIST[dlm];
                                                            ENDLOOP;
                                                        };
                                                    ENDCASE;
                                                };
                                            ENDCASE;
                                        };
                                    ENDCASE;
                                };
                            ENDCASE;
                        IF repaint THEN {
                            root.counted м TRUE;
                            tree м GrapherFromCooked[root, data, parent];
                            TreeGrapher.DoLayout[tree, data.lp];
                            data.tree м tree;
                            IF normalize THEN data.origin м [1.0-tree.layout.treeBox.xmin, parent.ch/2 - 0.5*(tree.layout.bounds.ymax+tree.layout.bounds.ymin)];
                            };
                        };
                    ENDCASE;
                };
            ViewerLocks.CallUnderWriteLock[Inner, parent];
            IF input.rest # NIL THEN {
                focus: InputFocus.Focus ~ InputFocus.GetInputFocus[];
                Inner: PROC ~ {
                    ViewerOps.NotifyViewer[focus.owner, input.rest];
                    };
                ViewerLocks.CallUnderWriteLock[Inner, focus.owner];
                };
            IF repaint THEN ViewerOps.PaintViewer[parent, client];
            };

        MakeMenu: PROC RETURNS [ViewerClasses.Menu] ~ {
            menu: ViewerClasses.Menu м Menus.CreateMenu[1];
            Item: PROC [atom: ATOM] ~ {
                Menus.InsertMenuEntry[menu, Menus.CreateEntry[name: Atom.GetPName[atom], proc: MenuClick, clientData: atom]];
                };
            Item[$UnDelete];
            Item[$PrevRoot];
            FOR control: Control DECREASING IN Control DO
                Item[controlNames[control]];
                ENDLOOP;
            Item[$C10];
            Item[$C5];
            Item[$C3];
            Item[$C1];
            Item[$C0];
            RETURN [menu]
            };

        InitStyle: PROC [style: RefTab.Ref] ~ {
            Def: PROC [formatName: ATOM, fontName: ROPE, textColor: Color м Imager.black, fillColors: LIST OF Color м NIL] ~ {
                [] м RefTab.Insert[style, formatName, NEW[TreeGrapherViewer.TextFormatRep м [
                    font: LIST[Imager.FindFontScaled[fontName, 1]],
                    textColor: textColor,
                    fillColors: fillColors,
                    propList: NIL
                    ]]];
                };
            <<Def[>>
                <<$spynode,>>
                <<"xerox/tiogafonts/tioga10",>>
                <<Imager.black,>>
                <<LIST[>>
                    <<ImagerColor.ColorFromRGB[[0.619,0.861,0.873]], -- light cyan (merged)>>
                    <<ImagerColor.ColorFromRGB[[0.873,0.68,0.619]], -- light orange (local counts)>>
                    <<ImagerColor.ColorFromRGB[[0.659,0.659,0.659]], -- light gray (clipped children)>>
                    <<ImagerColor.ColorFromRGB[[1,1,0.8]] -- very pale yellow (children)>>
                    <<]];>>
            Def[
                $spynode,
                "xerox/tiogafonts/tioga10",
                Imager.black,
                LIST[
                    ImagerColor.ColorFromRGB[[0.94, 0.76, 0.94]], -- violet (merged)
                    ImagerColor.ColorFromRGB[[0.873,0.68,0.619]], -- light orange (local counts)
                    ImagerColor.ColorFromRGB[[0.659,0.659,0.659]], -- light gray (clipped children)
                    ImagerColor.ColorFromRGB[[0.7, 1.0, 1.0]] -- light cyan (children)
                    ]];
            };

        SpyToolCommand: Commander.CommandProc ~ {
            fileName: ROPE ~ CommanderOps.NextArgument[cmd];
            IF fileName = NIL
                THEN CommanderOps.Failed[cmd.procData.doc]
                ELSE {
                    data: TreeGrapherViewer.ViewerData м TreeGrapherViewer.NewViewerData[];
                    spyTree: ST м ReadTreeFromFile[fileName];
                    cooked: CookedNode м Cook[spyTree, []];
                    InitStyle[data.style];
                    data.click м TreeClick;
                    data.tree м GrapherFromCooked[cooked, data, NIL];
                    TreeGrapher.DoLayout[data.tree, data.lp];
                    data.origin м [1.0-data.tree.layout.treeBox.xmin, 1.0-data.tree.layout.treeBox.ymin];
                    {
                        v: ViewerClasses.Viewer м ViewerOps.CreateViewer[flavor: $TreeGrapher, info: [name: fileName, hscrollable: TRUE, data: data, menu: 
                        MakeMenu[]]];
                        CommanderOps.PutProp[cmd, $TreeGrapherViewer, v];
                        ViewerOps.AddProp[v, $SpyToolControls, NEW[Controls м []]];
                        };
                    };
            };

        Commander.Register["SpyTool", SpyToolCommand, "<filename> - create a tool to anaylze data created with SpyStart/SpyStop commands"];

    END.