<<>>
    <<MakeDoReportOnFiles.Mesa>>
        <<Copyright Ó 1991 by Xerox Corporation.  All rights reserved.>>
        <<Last tweaked by Mike Spreitzer on April 26, 1990 9:57:00 am PDT>>
        <<Carl Hauser, April 11, 1985 3:43:34 pm PST>>
        <<Eduardo Pelegri-Llopart March 20, 1989 9:51:55 am PST>>
        <<JKF January 11, 1989 10:32:27 am PST>>
        <<Willie-s, September 27, 1991 4:44 pm PDT>>
        <<Michael Plass, September 30, 1991 12:51 pm PDT>>

    DIRECTORY
        CedarProcess USING [Process],
        Commander USING [CommandObject, Handle],
        FS USING [ComponentPositions, Error, ExpandName, StreamOpen],
        IO USING [Close, noInputStream, noWhereStream, PutF, PutFL, PutFR, PutRope, STREAM, Value],
        IOClasses USING [CreateDribbleOutputStream],
        List USING [AList, Assoc, DotCons, PutAssoc],
        MakeDo USING [ActionRep, EnumerateResults, NodeClassRep, NodeRep, PublicPartsOfNode, UncurrentProducer],
        MakeDoBasics USING [CheckIn, EndFork, Execution, InnerSuspectNodeChange, NeedToFinish, RegisterReporter, Reporter, ReporterRep, 
        SetES],
        MakeDoPrivate USING [ActionRep, AddFailedCmd, NodeClassRep, NodeRep],
        MoreIOClasses USING [CreateBuffer, SendBuffer],
        Process USING [Abort, InvalidProcess],
        RefTab USING [Delete],
        Rope,
        SimpleFeedback USING [Append];


    MakeDoReportOnFiles: CEDAR MONITOR
        IMPORTS FS, IO, IOClasses, List, MakeDo, MakeDoBasics, MakeDoPrivate, MoreIOClasses, Process, RefTab, Rope, SimpleFeedback
        <<EXPORTS MakeDo, MakeDoBasics>>
        EXPORTS MakeDo
        <<INVARIANT>>
            <<The integrity of the aux box data structure.>>

    =
    BEGIN OPEN MakeDo, MakeDoPrivate, MakeDoBasics;

    ROPE: TYPE = Rope.ROPE;
    NodeRep: PUBLIC TYPE = MakeDoPrivate.NodeRep;
    ActionRep: PUBLIC TYPE = MakeDoPrivate.ActionRep;
    NodeClassRep: PUBLIC TYPE = MakeDoPrivate.NodeClassRep;
<<Viewer Manipulation>>
    reporterOnFiles: MakeDoBasics.Reporter ~ NEW [MakeDoBasics.ReporterRep Ź [
        destroyAuxBox: DestroyAuxBox,
        auxBoxDestroyed: AuxBoxDestroyed,
        buffer: Buffer,
        msg: Msg,
        flush: Flush
        ]];

    AuxBox: TYPE ~ LIST OF FileExecutionViewer;
    auxBox: AuxBox Ź NIL;

    FileExecutionViewer: TYPE ~ REF FileExecutionViewerRep;
    FileExecutionViewerRep: TYPE ~ RECORD [
        logFileName: ROPE,
        logStream: IO.STREAM
        ];

    bufKey: ATOM = $MakeDoBuffer;

    logFilePrefix: ROPE Ź ".makeLog.";

    auxBoxOccupancy: INT Ź 0;
    monitor: BOOL Ź FALSE;

    DestroyAuxBox: -- PUBLIC -- PROC ~ {
        FOR auxRest: AuxBox Ź auxBox, auxRest.rest WHILE auxRest # NIL DO
            exView: FileExecutionViewer ~ auxRest.first;
            exView.logStream.Close[];
            ENDLOOP;
        auxBox Ź NIL;
        };

    AuxBoxDestroyed: -- PUBLIC -- PROC RETURNS [BOOL Ź TRUE] ~ {
        RETURN [auxBox = NIL];
        };

    Buffer: -- PUBLIC -- ENTRY PROC [e: Execution] = {
        ENABLE UNWIND => NULL;
        InnerBuffer[e];
        RETURN};

    InnerBuffer: INTERNAL PROC [e: Execution] = {--structure contorted to avoid Cirio blind spots
        ch: Commander.Handle ~ e.ch;
        bufout: IO.STREAM = MoreIOClasses.CreateBuffer[];
        gname, verless, logFileName, fmterr: ROPE;
        logStream: IO.STREAM;
        IF AuxBoxDestroyed[] THEN {
            auxBoxOccupancy Ź 0;
            };
        auxBoxOccupancy Ź auxBoxOccupancy + 1;
        e.bch Ź NEW [Commander.CommandObject Ź [
            commandLine: "Shouldn't care",
            propertyList: List.PutAssoc[bufKey, bufout, CopyAList[ch.propertyList]]
            ]];
        gname Ź MakeDo.PublicPartsOfNode[e.goal].name;
        {lgname: ROPE ~ gname;
        fullName: ROPE;
        cp: FS.ComponentPositions;
        [fullName, cp, ] Ź FS.ExpandName[lgname !FS.Error => GOTO Genit];
        verless Ź Rope.Substr[base: fullName, start: 0, len: cp.ext.start+cp.ext.length];
        logFileName Ź Rope.Replace[verless, cp.base.start, 0, logFilePrefix];
        EXITS Genit => {
            logFileName Ź IO.PutFR["%gAction%g", [rope[logFilePrefix]], [integer[actionCount Ź actionCount.SUCC]]];
            ch.err.PutF["Log for making %g going to %g\n", [rope[gname]], [rope[logFileName]] ]};
        };
        e.bch.in Ź IO.noInputStream;
        {llogFileName: ROPE ~ logFileName;
        llogStream: IO.STREAM;
        llogStream Ź FS.StreamOpen[fileName: llogFileName, accessOptions: create !FS.Error => {
            fmterr Ź IO.PutFR["FS.Error[%g, %g]", [atom[error.code]], [rope[error.explanation]] ];
            GOTO Complain}];
        logStream Ź llogStream;
        EXITS Complain => {
            ch.err.PutF["%g when trying to create command log %g; output will not be logged.\n", [rope[fmterr]], [rope[logFileName]] ];
            logStream Ź IO.noWhereStream}
        };
        {exView: FileExecutionViewer ~ NEW [FileExecutionViewerRep Ź [logFileName: logFileName, logStream: logStream]];
        this: LIST OF FileExecutionViewer ~ LIST[exView];
        e.view Ź exView;
        IF auxBox = NIL
            THEN auxBox Ź this
            ELSE { this.rest Ź auxBox; auxBox Ź this };
        };
        e.bch.err Ź e.bch.out Ź IOClasses.CreateDribbleOutputStream[bufout, logStream];
        e.es Ź buffered;
        };

    CopyAList: PUBLIC PROC [old: List.AList] RETURNS [new: List.AList] ~ {
        <<CopyAList copies the CONS cells of the list itself and also copies the DotCons cells which are the elements of the list.  Because 
        the DotCons cells are copied, one can change the key-value mappings in the new list without affecting the mappings in the 
        old list. Because the CONS cells are copied, one can alter the list without affecting the old list.>>
        tail: List.AList Ź NIL;
        new Ź NIL;
        UNTIL old = NIL DO
            newItem: List.AList Ź LIST[List.DotCons[key: old.first.key, val: old.first.val]];
            IF tail = NIL THEN new Ź newItem ELSE tail.rest Ź newItem;
            old Ź old.rest;
            tail Ź newItem;
            ENDLOOP;
        <<ERROR CommanderOps.Failed["CommandTool.CopyAList is deimplemented"];>>
        };
        <<>>


    actionCount: INT Ź 0;

    Abandonit: PROC [e: Execution] ~ {
        {OPEN e;
        IF NeedToFinish[e] THEN {
            ENABLE UNWIND => {
                EndFork[e.resources];
                Flush[e, TRUE, TRUE, a.cmd];
                [] Ź job.processes.Delete[process];
                };
            IF forked THEN Flush[e, TRUE, TRUE, a.cmd];
            a.fails Ź true;
            AddFailedCmd[job, a];
            EnumerateResults[a, InnerSuspectNodeChange];
            CheckIn[job, goal, a, e.process];
            SetES[e, final];
            UncurrentProducer[goal];
            SimpleFeedback.Append[$MakeDo, oneLiner, $info, "command execution abandoned"];
            }
        ELSE SimpleFeedback.Append[$MakeDo, oneLiner, $info, "command execution already finishing"];
        }};

    Stopit: PROC [e: Execution]  = {
        message: ROPE Ź "command execution ABORTed";
        IF e.process # NIL AND e.process.status = busy
            THEN TRUSTED {Process.Abort[e.process.process !Process.InvalidProcess => {
                message Ź 
                    IF process#e.process.process THEN "Zowie!  Bug 6 encountered!"
                    ELSE IF e.process.status=busy THEN "Wow!  CedarProcess bug observed!"
                    ELSE "Already gone!";
                CONTINUE;
                }]}
            ELSE message Ź IF e.process = NIL
                THEN "Can't ABORT because it's not gotten started yet"
                ELSE SELECT e.process.status FROM
                    done => "Can't ABORT because it's already done",
                    aborted => "Can't ABORT because it's already ABORTED",
                    debugging => "Won't ABORT because it's being debugged",
                    busy => "Wouldn't ABORT because it was not busy a few microseconds ago",
                    invalid => "Won't ABORT because it's invalid",
                    ENDCASE => "Won't ABORT because status unrecognized (I'm suffering software rot!)";
        SimpleFeedback.Append[$MakeDo, oneLiner, $info,  message];
        RETURN};

    Gushit: PROC [e: Execution] = {
        e.gushMe Ź TRUE;
        };


    Msg: -- PUBLIC -- ENTRY PROC [ch: Commander.Handle, format: ROPE, v1, v2, v3, v4, v5: IO.Value Ź [null[]]] = {
        ENABLE UNWIND => NULL;
        ch.out.PutFL[format, LIST[v1, v2, v3, v4, v5]];
        };

    Flush: --PUBLIC-- ENTRY PROC [e: Execution, long, abandon: BOOL, asRope: ROPE] = {
        ENABLE UNWIND => NULL;
        exView: FileExecutionViewer ~ NARROW[e.view];
        bch: Commander.Handle ~ e.bch;
        ch: Commander.Handle ~ e.ch;
        buffer: IO.STREAM = NARROW[List.Assoc[bufKey, bch.propertyList]];
        last: LIST OF FileExecutionViewer Ź NIL;
        IF abandon THEN {
            ch.out.PutF["%lAbandoning %g%l\n", [rope["be"]], [rope[asRope]], [rope["BE"]]];
            MoreIOClasses.SendBuffer[buffer, ch.out, FALSE];
            ch.out.PutRope["\n"];
            }
        ELSE IF long THEN MoreIOClasses.SendBuffer[buffer, ch.out, TRUE]
        ELSE ch.out.PutF["%lDone with %g%l\n", [rope["e"]], [rope[asRope]], [rope["E"]]];
        IF AuxBoxDestroyed[] THEN {
            auxBoxOccupancy Ź 0;
            }
        ELSE FOR cur: LIST OF FileExecutionViewer Ź auxBox, cur.rest WHILE cur # NIL DO
            IF cur.first = exView THEN {
                IF last # NIL THEN last.rest Ź cur.rest ELSE auxBox Ź cur.rest;
                cur.first.logStream.Close[];
                auxBoxOccupancy Ź auxBoxOccupancy - 1;
                EXIT;
                };
            last Ź cur;
            ENDLOOP;
        };

        MakeDoBasics.RegisterReporter[$FILES, reporterOnFiles];
    END.