<<>>
    <<CcCommandsImpl.Mesa>>
        <<Copyright Ó 1988, 1991 by Xerox Corporation.  All rights reserved.>>
        <<Eduardo Pelegri-Llopart, February 7, 1990 9:34:12 am PST>>
        <<Carl Hauser, May 23, 1988 2:42:05 pm PDT>>
        <<Bill Jackson (bj) July 5, 1988 8:36:20 pm PDT>>
        <<>>
        <<The module should be reorganized to be more rational.>>
        <<Spreitze, March 13, 1990 1:17 pm PST>>
        <<>>
    DIRECTORY
        Args USING [ Arg, ArgRope, Error, GetRope, NArgs ],
        Ascii,
        BasicTime USING [ GMT ],
        Commander USING [ CommandProc, Register ],
        CommandTool USING [ CurrentWorkingDirectory ],
        Convert,
        ExtendADotOut USING [ ActionID, ActionIDFromAction, DependencyInfo, DependencyInfoRep, ObjectClassFromFileName, ObjectIDFromFile, 
        ObjectID, PutDependencyInfo, StampFromIDs, VersionStamp ],
        FS USING [ ComponentPositions, Delete, Error, ExpandName, Rename, StreamOpen ],
        IO USING [ card, Close, Flush, GetRope, int, PutF, PutFR, PutRope, rope, STREAM ],
        PBasics USING [LowHalf, LowByte, HighByte, BITAND, endianBitsInBytes],
        PFS, PFSNames, PFSPrefixMap,
        Process USING [ CheckForAbort, EnableAborts, InitializeCondition, SecondsToTicks ],
        Rope USING [ Cat, Concat, Equal, Fetch, FindBackward, Flatten, Length, ROPE, Substr, Translate],
        SymTab,
        SystemVersion USING [machineType, MachineType],
        ThisMachine USING [ ProcessorID ],
        UnixErrno,
        UnixStat,
        UnixSysCalls USING [ GetPID, SymLink, Unlink ],
        UnixSysCallExtensions USING [Spawn],
        UnixTypes USING [CHARPtr, SysCallResult],
        UserProfile USING [Token],
        UXStrings;

    CcCommandsImpl: CEDAR MONITOR
        IMPORTS Args, Ascii, Commander, CommandTool, Convert, ExtendADotOut, FS, IO, PBasics, PFS, PFSNames, PFSPrefixMap, Process, Rope, 
        SymTab, SystemVersion, ThisMachine, UnixErrno, UnixSysCalls, UnixSysCallExtensions, UserProfile, UXStrings ~ {
        ROPE: TYPE ~ Rope.ROPE;
        LOR: TYPE ~ LIST OF ROPE;

        ShouldNotHappen: ERROR [message: ROPE] ~ CODE;
        ForkTrouble: ERROR ~ CODE;
        NYI: ERROR ~ CODE;

        DeleteFiles: BOOL ~ TRUE;

        <<Temporarily until I change SystemVersion.MachineType;>>
        <<mot88000: SystemVersion.MachineType ~ LOOPHOLE[SystemVersion.MachineType[14]];>>
        amd29000: SystemVersion.MachineType ~ LOOPHOLE[20, SystemVersion.MachineType];
        <<r2000: SystemVersion.MachineType ~ LOOPHOLE[SystemVersion.MachineType[30]];>>
        <<r3000: SystemVersion.MachineType ~ LOOPHOLE[SystemVersion.MachineType[31]];>>
        <<i386: SystemVersion.MachineType ~ LOOPHOLE[SystemVersion.MachineType[40]];>>
        <<i486: SystemVersion.MachineType ~ LOOPHOLE[SystemVersion.MachineType[41]];>>
        <<i860: SystemVersion.MachineType ~ LOOPHOLE[SystemVersion.MachineType[42]];>>
        <<i960: SystemVersion.MachineType ~ LOOPHOLE[SystemVersion.MachineType[43]];>>
    <<Unique names for temporary (unix-host) files>>
        uid: CARD32 Ź 0;
        processID: INT ~ UnixSysCalls.GetPID[];
        processorID: ROPE ~ ThisMachine.ProcessorID[$Octal];
        CshCommandString: UXStrings.UnixString ~ UXStrings.Create[from: "/bin/csh -s"];
        MACHINECLASS: ROPE ~ "ComplexCc.MachineClass";

        NewName: ENTRY PROC [suffix: ROPE Ź ".o", wDir: ROPE] RETURNS [ fName: ROPE ] ~ {
            ENABLE { UNWIND => NULL };
            fName Ź IO.PutFR["cedarCc%gFrom%g%g", IO.card[uid], IO.int[processID], IO.rope[processorID], IO.rope[suffix]];
            IF NOT Rope.Equal[wDir, NIL] THEN {
                IF wDir.Fetch[wDir.Length[]-1] # '/ THEN wDir Ź wDir.Cat["/"];
                fName Ź wDir.Cat[fName];
                };
            uid Ź uid.SUCC;
            };

    <<Making filenames acceptable to UNIX>>
        ViewFix: PROC [cedar, insert: ROPE, isDir, simpleExt, create: BOOL, otherUnlink: LOR] RETURNS [unix: ROPE Ź NIL, unlink: LOR Ź NIL] 
        ~ {
            ENABLE PFS.Error => ERROR ShouldNotHappen[IO.PutFR["Got PFS.Error[%g, %g] while UXifying %g", [atom[error.code]], 
            [rope[error.explanation]], [rope[cedar]] ]];
            given: PFS.PATH ~ PFS.PathFromRope[cedar];
            translated: PFS.PATH ~ PFSPrefixMap.Translate[ PFS.AbsoluteName[given]];
            cedarPath: PFS.PATH ~ IF isDir THEN PFSNames.EnsureDirectory[translated] ELSE translated; --EnsureDirectory only required because 
            Translate bogusly drops that bit (MJS March 13, 1990)
            rawRope: ROPE ~ PFS.RopeFromPath[cedarPath].Flatten[]; --for debugging
            viewComp: PFSNames.Component ~ cedarPath.Fetch[0];
            view: ROPE ~ viewComp.ComponentRope[];
            IF isDir # given.IsADirectory[] THEN ERROR ShouldNotHappen[IO.PutFR[IF isDir THEN "%g not a directory" ELSE "%g is a directory", 
            [rope[cedar]] ]];
            IF isDir AND (insert#NIL OR create OR simpleExt) THEN ERROR--not implemented because not needed--;
            SELECT TRUE FROM
                view.Equal["-ux", FALSE] => {
                    viewless: PFS.PATH ~ cedarPath.ReplaceComponent[0, emptyComponent];
                    parent: PFS.PATH ~ viewless.Parent[];
                    parentRope: ROPE ~ PFS.RopeFromPath[parent];
                    last: PFSNames.Component ~ viewless.ShortName[];
                    lastRope: ROPE ~ last.ComponentRope[--PFS doesn't put in version info--];
                    original: ROPE ~ parentRope.Concat[lastRope];
                    IF insert#NIL THEN {
                        new: ROPE ~ parentRope.Cat[insert, lastRope];
                        GetLink[original, new];
                        RETURN [new, CONS[new, otherUnlink]]};
                    RETURN [original, otherUnlink]};
                view.Equal["-vux", FALSE] => {
                    full, parent: PFS.PATH;
                    fullLast: PFSNames.Component;
                    fullRope, parentRope, verfulLast, verlessLast, vuxrepRope, uxishRope: ROPE;
                    IF create THEN {
                        out: IO.STREAM ~ PFS.StreamOpen[fileName: cedarPath, accessOptions: create];
                        file: PFS.OpenFile ~ PFS.OpenFileFromStream[out];
                        modeProp: ROPE;
                        dm: UnixStat.Mode;
                        full Ź PFS.GetInfo[file].fullFName;
                        modeProp Ź PFS.GetClientProperty[file, "UnixMode"];
                        dm Ź LOOPHOLE[Convert.CardFromRope[modeProp]];
                        dm.owner.write Ź true;
                        PFS.SetClientProperty[file, "UnixMode", Convert.RopeFromCard[LOOPHOLE[dm, CARD16], 8]];
                        out.Close[]}
                    ELSE IF isDir THEN {
                        full Ź cedarPath.ReplaceComponent[0, emptyComponent];
                        unix Ź PFS.RopeFromPath[full].Translate[translator: Lower];
                        RETURN [unix, otherUnlink]}
                    ELSE full Ź PFS.FileInfo[cedarPath].fullFName;
                    fullRope Ź PFS.RopeFromPath[full].Flatten[]; --for debugging
                    fullLast Ź full.ShortName[];
                    parent Ź full.Parent[].ReplaceComponent[0, emptyComponent];
                    parentRope Ź PFS.RopeFromPath[parent].Translate[translator: Lower];
                    IF NOT parent.IsADirectory[] THEN ERROR ShouldNotHappen["PFS shouldn't be crocky!"];
                    IF fullLast.version.versionKind # numeric THEN ERROR ShouldNotHappen[
                        IO.PutFR["Didn't expect to find %g in file system (note version!)",
                        [rope[PFS.RopeFromPath[full]]] ]];
                    verlessLast Ź fullLast.ComponentRope[--PFS doesn't put in version info--];
                    verfulLast Ź IO.PutFR["%g.~%g~", [rope[verlessLast.Translate[translator: Lower]]], [integer[fullLast.version.version]]];
                    vuxrepRope Ź parentRope.Cat[verfulLast];
                    IF simpleExt OR insert#NIL THEN {
                        uxishRope Ź parentRope.Cat[insert, verlessLast];
                        GetLink[vuxrepRope, uxishRope];
                        RETURN [uxishRope, CONS[uxishRope, otherUnlink]]}
                    ELSE RETURN [vuxrepRope, otherUnlink];
                    };
                ENDCASE => ERROR ShouldNotHappen[
                    IO.PutFR["Can't apply UNIX tools to %g because of its view",
                    IO.rope[PFS.RopeFromPath[cedarPath]] ]];
            };
            emptyComponent: PFSNames.Component ~ [];

        Lower: PROC [old: CHAR] RETURNS [CHAR] ~ {RETURN Ascii.Lower[old]};

        LinkData: TYPE ~ REF LinkDataRec;
        LinkDataRec: TYPE ~ RECORD [
            from: ROPE,
            count: NAT,
            toCP: UnixTypes.CHARPtr Ź [],
            change: CONDITION];

        GetLink: ENTRY PROC [from, to: ROPE] ~ {
            ENABLE UNWIND => NULL;
            ld: LinkData Ź NARROW[linkTab.Fetch[to].val];
            IF ld=NIL THEN {
                ld Ź NEW [LinkDataRec Ź [NIL, 0]];
                TRUSTED {
                    Process.InitializeCondition[@ld.change, Process.SecondsToTicks[10]];
                    Process.EnableAborts[@ld.change]};
                IF NOT linkTab.Insert[to, ld] THEN ERROR};
            DO SELECT TRUE FROM
                ld.count=0 => {
                    fromCP: UnixTypes.CHARPtr ~ UXStrings.Create[from];
                    toCP: UnixTypes.CHARPtr Ź ld.toCP Ź UXStrings.Create[to];
                    res: UnixTypes.SysCallResult Ź UnixSysCalls.SymLink[fromCP, toCP];
                    IF res=failure THEN RETURN WITH ERROR ShouldNotHappen[
                        IO.PutFR["Link from %g to %g failed; errno is %g",
                        IO.rope[from],
                        IO.rope[to],
                        IO.card[LOOPHOLE[UnixErrno.GetErrno[], CARD]]]];
                    ld.count Ź ld.count.SUCC;
                    ld.from Ź ld.from;
                    RETURN};
                ld.from.Equal[from] => {ld.count Ź ld.count.SUCC; RETURN};
                ENDCASE => WAIT ld.change ENDLOOP;
            };
            linkTab: SymTab.Ref ~ SymTab.Create[case: TRUE];

        DropLink: ENTRY PROC [to: ROPE] ~ {
            ENABLE UNWIND => NULL;
            ld: LinkData Ź NARROW[linkTab.Fetch[to].val];
            IF ld=NIL OR ld.count=0 THEN RETURN WITH ERROR ShouldNotHappen[IO.PutFR["Excess dropping of link to %g", [rope[to]] ]];
            ld.count Ź ld.count.PRED;
            BROADCAST ld.change;
            IF ld.count=0 THEN {
                res: UnixTypes.SysCallResult ~ UnixSysCalls.Unlink[ld.toCP];
                IF NOT linkTab.Delete[to] THEN ERROR;
                IF res = failure THEN RETURN WITH ERROR ShouldNotHappen[
                    IO.PutFR["Unlink failed for %g; errno is %g",
                    IO.rope[to],
                    IO.card[LOOPHOLE[UnixErrno.GetErrno[], CARD]]]];
                };
            RETURN};

        UnlinkList: PROC [list: LOR] ~ {
            FOR list Ź list, list.rest WHILE list#NIL DO
                DropLink[list.first];
                ENDLOOP;
            RETURN};

        ConsComponent: PROC [name: ROPE, version: PFSNames.Version] RETURNS [PFSNames.Component] ~ {
            RETURN [[name: [base: name, start: 0, len: name.Length[]], version: version]]};
    <<Auxiliary Execution Procs.>>
        MachineTypeFromMachineClass: PROC [ machineClass: ROPE ]
        RETURNS [ machineType: SystemVersion.MachineType ] ~ {
            SELECT TRUE FROM
                Rope.Equal[machineClass, "sparc", FALSE] => machineType Ź sun4;
                Rope.Equal[machineClass, "mc68020", FALSE] => machineType Ź sun3;
                Rope.Equal[machineClass, "sun4", FALSE] => machineType Ź sun4;
                Rope.Equal[machineClass, "sun3", FALSE] => machineType Ź sun3;
                Rope.Equal[machineClass, "amd29000", FALSE] => machineType Ź amd29000;
                ENDCASE => ERROR;
            };

        MachineClassFromMachineType: PROC [ machineType: SystemVersion.MachineType ]
        RETURNS [ machineClass: ROPE ] ~ {
            SELECT machineType FROM
                sun4 => machineClass Ź "sun4";
                sun3 => machineClass Ź "sun3";
                amd29000 => machineClass Ź "amd29000";
                ENDCASE => machineClass Ź "I don't know";
            };

        GetCommandNames: PROC [host, target: SystemVersion.MachineType] RETURNS [compiler, loader, move, csh: ROPE Ź NIL] ~ {
            CompilerDefault: ROPE ~ "/usr/local/bin/ccc";
            MoveDefault: ROPE ~ "/bin/mv";
            LoadDefault: ROPE ~ "/bin/ld";
            CshDefault: ROPE ~ "/bin/csh -s";
            targetName: ROPE ~ MachineClassFromMachineType[ target ];

            IF host # sun4 THEN ERROR ShouldNotHappen ["host is not a sun4"];
            compiler Ź UserProfile.Token["ComplexCc.cc", CompilerDefault];
            loader Ź UserProfile.Token["ComplexCc.ld", LoadDefault];
            move Ź UserProfile.Token["ComplexCc.mv", MoveDefault];
            csh Ź UserProfile.Token["ComplexCc.csh", CshDefault];

            compiler Ź UserProfile.Token[Rope.Cat["ComplexCc.", targetName, ".cc"], compiler];
            loader Ź UserProfile.Token[Rope.Cat["ComplexCc.", targetName, ".ld"], loader];
            move Ź UserProfile.Token[Rope.Cat["ComplexCc.", targetName, ".mv"], move];
            csh Ź UserProfile.Token[Rope.Cat["ComplexCc.", targetName, ".csh"], csh];
            };

        UnixNil: UnixTypes.CHARPtr ~ LOOPHOLE[NIL];

        MsgFromExitError: PROC [status: INT, command: ROPE] RETURNS [msg: ROPE] ~ {
            lowHalf: CARD16 ~ PBasics.LowHalf[LOOPHOLE[status, CARD32]];
            lowByte: BYTE ~ PBasics.LowByte[lowHalf];
            nextLowByte: BYTE ~ PBasics.HighByte[lowHalf];
            low7: BYTE;
            IF lowByte = 177B THEN {
                msg Ź IO.PutFR["execution of %g stopped by signal %g\n", IO.rope[command], IO.int[nextLowByte]];
                RETURN [msg];
                };
            IF lowByte = 0 THEN {
                msg Ź IO.PutFR["execution of %g exited with %g\n", IO.rope[command], IO.int[nextLowByte]];
                RETURN [msg];
                };
            SELECT PBasics.endianBitsInBytes FROM
                big => low7 Ź PBasics.BITAND[lowByte, 077B];
                little => low7 Ź PBasics.BITAND[lowByte, 176B];
                ENDCASE => ERROR;
            msg Ź IO.PutFR["execution of %g terminated due to signal %g\n", IO.rope[command], IO.int[low7]];
            };

        MsgFromFile: PROC [fileName: ROPE, delete: BOOL Ź TRUE] RETURNS [msg: ROPE] ~ {
            stream: IO.STREAM;
            stream Ź FS.StreamOpen[fileName: fileName !FS.Error => { stream Ź NIL; CONTINUE }];
            IF stream # NIL THEN {
                msg Ź stream.GetRope[];
                stream.Close[];
                IF delete THEN FS.Delete[name: fileName !FS.Error => CONTINUE];
                };
            };

        <<HideNamesThroughLink: PROC [dir: ROPE, files: LIST OF ROPE] ~ {
            <<Strictly speaking this operation should be monitored against other concurrent operations;  in practice, the problem should never 
            arise>>
            FOR list: LIST OF ROPE Ź files, list.rest WHILE list # NIL DO
                file: ROPE ~ list.first;
                sourceRope: ROPE ~ Rope.Cat[dir, file];
                destinationRope: ROPE ~ Rope.Cat[dir, "FILE-", file];
                source: UnixTypes.CHARPtr ~ UXStrings.Create[sourceRope];
                destination: UnixTypes.CHARPtr ~ UXStrings.Create[destinationRope];
                res: UnixTypes.SysCallResult ~ UnixSysCalls.SymLink[source, destination];
                IF res = failure THEN
                    ERROR ShouldNotHappen[
                        IO.PutFR["Link from %g to %g failed; errno is %g",
                        IO.rope[destinationRope],
                        IO.rope[sourceRope],
                        IO.card[LOOPHOLE[UnixErrno.GetErrno[], CARD]]]];
                ENDLOOP;
            };

        UnlinkNames: PROC [dir: ROPE, files: LIST OF ROPE] ~ {
            FOR list: LIST OF ROPE Ź files, list.rest WHILE list # NIL DO
                file: ROPE ~ list.first;
                sourceRope: ROPE ~ Rope.Cat[dir, "FILE-", file];
                source: UnixTypes.CHARPtr ~ UXStrings.Create[sourceRope];
                res: UnixTypes.SysCallResult ~ UnixSysCalls.Unlink[source];
                IF res = failure THEN
                    ERROR ShouldNotHappen[
                        IO.PutFR["Unlink failed for %g; errno is %g",
                        IO.rope[sourceRope],
                        IO.card[LOOPHOLE[UnixErrno.GetErrno[], CARD]]]];
                ENDLOOP;

            };>>

        Execute: PROC [command: ROPE, wDir: ROPE Ź NIL] RETURNS [status: INT, msg: ROPE Ź NIL] ~ {
            newCommand: ROPE ~ IF wDir.Equal[NIL] THEN command ELSE Rope.Cat["cd ", wDir, " ; ", command];
            string: UXStrings.UnixString ~ UXStrings.Create[from: newCommand];
            ropeStdErr: ROPE ~ NewName[".stderr", wDir];
            stringStdErr: UXStrings.UnixString ~ UXStrings.Create[from: ropeStdErr];
            ropeStdOut: ROPE ~ NewName[".stdout",wDir];
            stringStdOut: UXStrings.UnixString ~ UXStrings.Create[from: ropeStdOut];

            status Ź UnixSysCallExtensions.Spawn[string, UnixNil, stringStdOut, stringStdErr];
            IF status # 0 THEN msg Ź MsgFromExitError[status: status, command: command];
            msg Ź Rope.Cat[msg, MsgFromFile[fileName: ropeStdErr, delete: DeleteFiles]];
            msg Ź Rope.Cat[msg, MsgFromFile[fileName: ropeStdOut, delete: DeleteFiles]];
            };

        ExecuteCsh: PROC [hostType, targetType: SystemVersion.MachineType, commandLines: ROPE, wDir: ROPE Ź NIL] RETURNS [status: INT, msg: 
        ROPE Ź NIL] ~ {
            cshCommandRope: ROPE ~ GetCommandNames[ host: hostType, target: targetType].csh;
            cshCommandString: UnixTypes.CHARPtr ~ UXStrings.Create[cshCommandRope].string;
            IF cshCommandRope = NIL
                THEN ERROR ShouldNotHappen[IO.PutFR[
                "Cshell execution on target of class %g cannot be done from host of class %g", 
                IO.rope[MachineClassFromMachineType[targetType]],
                IO.rope[MachineClassFromMachineType[hostType]],
                ]];
            {
                ropeStdIn: ROPE ~ NewName[".stdin", wDir];
                stringStdIn: UXStrings.UnixString ~ UXStrings.Create[from: ropeStdIn];
                ropeStdErr: ROPE ~ NewName[".stderr", wDir];
                stringStdErr: UXStrings.UnixString ~ UXStrings.Create[from: ropeStdErr];
                ropeStdOut: ROPE ~ NewName[".stdout", wDir];
                stringStdOut: UXStrings.UnixString ~ UXStrings.Create[from: ropeStdOut];
                streamIn: IO.STREAM ~ FS.StreamOpen[fileName: ropeStdIn, accessOptions: $create];

                IF NOT wDir.Equal[NIL]
                    THEN streamIn.PutF["cd %g\n", IO.rope[wDir]];
                streamIn.PutF["%g\n", IO.rope[commandLines]];
                streamIn.Close[];
                status Ź UnixSysCallExtensions.Spawn[cshCommandString, stringStdIn, stringStdOut, stringStdErr];
                IF status # 0 THEN msg Ź MsgFromExitError[status: status, command: cshCommandRope];
                msg Ź Rope.Cat[msg, MsgFromFile[fileName: ropeStdErr, delete: DeleteFiles]];
                msg Ź Rope.Cat[msg, MsgFromFile[fileName: ropeStdOut, delete: DeleteFiles]];
                FS.Delete[name: ropeStdIn !FS.Error => CONTINUE];
                }
            };

        OutFilename: PROC [ template: ROPE ] RETURNS [ name: ROPE ] ~ {
            fullName: ROPE; cp: FS.ComponentPositions;
            [fullFName: fullName, cp: cp] Ź FS.ExpandName[template];
            {
                shortName: ROPE ~ fullName.Substr[cp.base.start, cp.base.length];
                name Ź shortName.Cat[".o"];
                };
            };

        FixPath: PROC [ origName: ROPE ]
        RETURNS [ newName: ROPE Ź NIL ] ~ {
            IF Rope.Equal[origName, NIL] THEN RETURN;
            newName Ź origName.Translate[translator: BrackToSlash];
            };
        BrackToSlash: PROC [old: CHAR] RETURNS [new: CHAR] ~ {
            new Ź IF ( old = '> ) THEN '/ ELSE old};

        FixDirectory: PROC [ origName: ROPE ]
        RETURNS [ newName: ROPE Ź NIL ] ~ {
            length: INT ~ Rope.Length[origName];
            IF length = 0 THEN RETURN;
            newName Ź FixPath[origName];
            IF newName.Fetch[length-1] # '/ THEN newName Ź newName.Cat["/"];
            RETURN [newName];
            };

        GetDirAndFixPath: PROC [ origDir, origName: ROPE ]
        RETURNS [ dir, basename: ROPE Ź NIL ] ~ {
            <<basename is filename portion>>
            <<dir is the directory portion using "/" notation>>
            dir Ź origDir;
            IF Rope.Equal[origName, NIL] THEN RETURN;
            basename Ź FixPath[origName];
            {
                pos: INT32 ~ basename.FindBackward["/"].SUCC;
                IF ( pos # 0 ) THEN  {
                    dir Ź origDir.Concat[basename.Substr[0, pos]];
                    basename Ź basename.Substr[pos];
                    RETURN};
                };
            };
    <<Commander Procs.>>

        CommandSyntaxError: ERROR ~ CODE;

        ComplexCCProc: Commander.CommandProc ~ {
            ENABLE {
                Args.Error => { msg Ź ComplexCCUsage; GOTO Failed };
                ShouldNotHappen => { msg Ź message; GOTO Failed };
                CommandSyntaxError => { msg Ź ComplexCCUsage; GOTO Failed };
                FS.Error => { msg Ź error.explanation; GOTO Failed };
                };
            binDir: ROPE Ź NIL;
            srcDir: ROPE Ź NIL;
            ccSwitches: ROPE;
            ldSwitches: ROPE;
            libSwitches: ROPE;
            doALoad: BOOL Ź FALSE;
            xFlag: BOOL Ź FALSE;
            inFilename: ROPE;
            intFileList: LIST OF ROPE; -- list of file names for intermediate files
            loadFileList: LIST OF ROPE; -- list of file names for loading
            outFilename: ROPE;
            currentDir: ROPE ~ ViewFix[CommandTool.CurrentWorkingDirectory[], NIL, TRUE, FALSE, FALSE, NIL].unix; --a UXIO name

            InnerDoIt: PROC [hostType, targetType: SystemVersion.MachineType] ~ {
                <<Side Effects msg and result in the enclosing procedure.  Host is currently unused.>>
                ENABLE {
                    FS.Error => {
                        msg Ź error.explanation;
                        GOTO Failed;
                        };
                    ABORTED => {
                        msg Ź "-- Aborted!";
                        GOTO Failed;
                        }
                    };
                compilerName: ROPE;
                loaderName: ROPE;
                moveName: ROPE;
                links: LOR Ź NIL;
                ccSrc, ccOut, intFudge, ldOut, ldOutUX: ROPE;
                ldCommand: ROPE Ź NIL;

                [compiler: compilerName, loader: loaderName] Ź GetCommandNames[host: hostType, target: targetType];
                IF compilerName.Equal[NIL] OR loaderName.Equal[NIL] THEN {
                    msg Ź IO.PutFR["Compilation from host type %g to target type %g is not valid", IO.rope[MachineClassFromMachineType[hostType]],
                    IO.rope[MachineClassFromMachineType[targetType]],
                    ];
                    GOTO Failed;
                    };
            <<Step One: tame the file view problems>>
            <<>>
            {ENABLE UNWIND => UnlinkList[links];
                [ccSrc, links] Ź ViewFix[srcDir.Concat[inFilename], NIL, FALSE, TRUE, FALSE, links];
                [ccOut, links] Ź ViewFix[binDir.Cat[outFilename], NIL, FALSE, TRUE, TRUE, links];
                IF doALoad THEN {
                    inputDir: ROPE ~ currentDir.Cat[binDir];
                    ldOut Ź binDir.Concat[NewName[".o", NIL]];
                    [ldOutUX, links] Ź ViewFix[ldOut, NIL, FALSE, FALSE, TRUE, links];
                    FOR tail: LIST OF ROPE Ź loadFileList, tail.rest WHILE ( tail # NIL ) DO
                        renamed: ROPE;
                        [renamed, links] Ź ViewFix[binDir.Concat[tail.first], "FILE-", FALSE, FALSE, FALSE, links];
                        ldCommand Ź ldCommand.Cat[" ", renamed];
                        ENDLOOP;
                    ldCommand Ź ldCommand.Cat[" ", libSwitches];
                    };
            <<Step Two: do a Cc>>
            <<>>
            {
                status: INT;
                localMsg, command: ROPE Ź NIL;

                command Ź IO.PutFR["%g %g -o %g %g -I./%g", IO.rope[compilerName], IO.rope[ccSwitches], IO.rope[ccOut], IO.rope[ccSrc], 
                IO.rope[srcDir]];

                [status: status, msg: localMsg] Ź Execute[command: command, wDir: currentDir];

                IF ( NOT localMsg.Equal[NIL] )
                    THEN {
                        IF ( status # 0 ) THEN {
                            msg Ź IO.PutFR["Compilation failed; error: %g, msg: %g",  IO.int[status], IO.rope[localMsg]];
                            UnlinkList[links];
                            GOTO Failed;
                            };
                        msg Ź IO.PutFR[".\nCompilation warnings: %g\n", IO.rope[localMsg]];
                        }
                    ELSE {
                        msg Ź ".";
                        };
                cmd.err.PutRope[msg];
                cmd.err.Flush[];
                };
                Process.CheckForAbort[];

            <<Step Three: do an Ld (renaming if necessary, after removing links)>>

                IF ( doALoad ) THEN {
                    status: INT;
                    localMsg: ROPE;

                    [intFudge, links] Ź ViewFix[binDir.Cat[outFilename], "FILE-", FALSE, TRUE, FALSE, links];
                    ldCommand Ź IO.PutFR["%g %g -o %g %g %g", IO.rope[loaderName], IO.rope[ldSwitches], IO.rope[ldOutUX], IO.rope[intFudge], 
                    IO.rope[ldCommand] ];

                    [status: status, msg: localMsg] Ź Execute[command: ldCommand, wDir: currentDir];

                    IF ( NOT localMsg.Equal[NIL] )
                        THEN {
                            IF ( status # 0 ) THEN {
                                msg Ź IO.PutFR["Load failed; error: %g, msg: %g",  IO.int[status], IO.rope[localMsg]];
                                UnlinkList[links];
                                GOTO Failed;
                                };
                            msg Ź IO.PutFR[".\nLoad warnings: %g\n", IO.rope[localMsg]];
                            }
                        ELSE {
                            msg Ź ".";
                            };
                    cmd.err.PutRope[msg];
                    cmd.err.Flush[];
                    Process.CheckForAbort[];
                    };

                }; UnlinkList[links];

                IF ( doALoad ) THEN {
                    FS.Rename[from: ldOut, to: binDir.Concat[outFilename] !FS.Error => {
                        msg Ź IO.PutFR["FS.Error[%g, %g] while trying to rename %g to %g", [atom[error.code]], [rope[error.explanation]], [rope[ldOut]], 
                        [rope[binDir.Concat[outFilename]]]];
                        GOTO Failed}];
                    };
                Process.CheckForAbort[];

            <<Step Four: process the file adding extra symbols and dependecy info.>>

                IF ( xFlag ) THEN {
                    self: ExtendADotOut.ObjectID;
                    action: ExtendADotOut.ActionID ~ ExtendADotOut.ActionIDFromAction["CC"];
                    dependList: LIST OF ExtendADotOut.ObjectID Ź NIL;
                    deps: ExtendADotOut.DependencyInfo;
                    depFileList: LIST OF ROPE Ź NIL;

                    depFileList Ź CONS[Rope.Cat[srcDir, inFilename], depFileList];
                    FOR list: LIST OF ROPE Ź intFileList, list.rest WHILE list # NIL DO
                        fileName: ROPE ~ list.first;
                        depFileList Ź CONS[Rope.Cat[srcDir, fileName], depFileList];
                        ENDLOOP;
                    FOR list: LIST OF ROPE Ź loadFileList, list.rest WHILE list # NIL DO
                        fileName: ROPE ~ list.first;
                        depFileList Ź CONS[Rope.Cat[binDir, fileName], depFileList];
                        ENDLOOP;
                    FOR list: LIST OF ROPE Ź depFileList, list.rest WHILE list # NIL DO
                        fileName: ROPE ~ list.first;
                        dependList Ź CONS[ExtendADotOut.ObjectIDFromFile[fileName], dependList];
                        ENDLOOP;

                    self.class Ź ExtendADotOut.ObjectClassFromFileName[outFilename];
                    self.name Ź Rope.Cat[binDir, outFilename];
                    self.stamp Ź ExtendADotOut.StampFromIDs[action, dependList];
                    deps Ź NEW [ExtendADotOut.DependencyInfoRep Ź [
                        self: self,
                        action: action,
                        dependList: dependList
                        ]];

                    ExtendADotOut.PutDependencyInfo[Rope.Cat[binDir, outFilename], deps];
                    };

                msg Ź " no errors.";
            EXITS
            Failed => { result Ź $Failure };
                };

        targetClass: ROPE Ź UserProfile.Token[key: MACHINECLASS, default: "sun4"];
        hostClass: ROPE Ź MachineClassFromMachineType[ SystemVersion.machineType ];
        <<userHost: ROPE _ NIL; -- unused >>

            ProcessCommandLine: PROC ~ {
            nArgs: INT32 ~ Args.NArgs[cmd];
                i: NAT;
                FOR i Ź 0, i.SUCC WHILE ( i < nArgs ) DO
                    NextRope: PROC RETURNS [ r: ROPE ] ~ INLINE {
                        ropeArg: Args.Arg ~ Args.ArgRope[cmd, i.SUCC];
                        r Ź ropeArg.rope;
                        i Ź i.SUCC;
                        };
                    NextList: PROC RETURNS [ l: LIST OF ROPE Ź NIL ] ~ INLINE {
                        FOR j: INT32 Ź i.SUCC, j.SUCC WHILE ( j < nArgs ) DO
                            anArg: ROPE ~ Args.GetRope[cmd, j];
                            IF ( anArg.Fetch[0] = '- ) THEN { i Ź j.PRED; EXIT} ;
                            l Ź CONS[anArg, l];
                            REPEAT
                                FINISHED => { i Ź nArgs }
                            ENDLOOP;
                        };
                    anArg: ROPE ~ Args.GetRope[cmd, i];
                    SELECT TRUE FROM
                        anArg.Equal[s2: "-in", case: FALSE] => { inFilename Ź NextRope[] };
                        anArg.Equal[s2: "-out", case: FALSE] => { outFilename Ź NextRope[] };
                        anArg.Equal[s2: "-binDir", case: FALSE] => { binDir Ź NextRope[] };
                        anArg.Equal[s2: "-srcDir", case: FALSE] => { srcDir Ź NextRope[] };
                        anArg.Equal[s2: "-lSwitch", case: FALSE] => { ldSwitches Ź NextRope[] };
                        anArg.Equal[s2: "-cSwitch", case: FALSE] => { ccSwitches Ź NextRope[] };
                        <<anArg.Equal[s2: "-host", case: FALSE] => { userHost _ NextRope[] };>>
                        anArg.Equal[s2: "-class", case: FALSE] => { targetClass Ź NextRope[] };
                        anArg.Equal[s2: "-lib", case: FALSE] => { libSwitches Ź NextRope[] };
                        anArg.Equal[s2: "-int", case: FALSE] => { intFileList Ź NextList[] };
                        anArg.Equal[s2: "-X", case: FALSE] => { xFlag Ź TRUE };
                        anArg.Equal[s2: "-load", case: FALSE] =>
                        { doALoad Ź TRUE; loadFileList Ź NextList[] };
                        ENDCASE => ERROR CommandSyntaxError;
                    ENDLOOP; 
                    };

            ProcessCommandLine[];

        binDir Ź FixDirectory[binDir];
        srcDir Ź FixDirectory[srcDir];

            inFilename Ź FixPath[inFilename];

            IF ( outFilename = NIL ) THEN outFilename Ź OutFilename[inFilename];

            [binDir, outFilename] Ź GetDirAndFixPath[binDir, outFilename];

            cmd.err.PutF[" [localhost] "];

            cmd.err.PutRope["C compiling "];
            cmd.err.Flush[];
            InnerDoIt[
            hostType: MachineTypeFromMachineClass[hostClass], 
            targetType: MachineTypeFromMachineClass[targetClass]];
        <<That's all!>>
        EXITS
        Failed => { result Ź $Failure };
            };

        ComplexRshProc: Commander.CommandProc ~ {
            ENABLE {
                Args.Error => { msg Ź ComplexRshUsage; GOTO Failed };
                ShouldNotHappen => { msg Ź message; GOTO Failed };
                CommandSyntaxError => { msg Ź ComplexRshUsage; GOTO Failed };
                FS.Error => { msg Ź error.explanation; GOTO Failed };
                };
        xFlag: BOOL Ź FALSE;
        xClassName: ROPE Ź NIL; -- The name of the class for this action
        srcDir: ROPE;
        binDir: ROPE Ź NIL;
        srcInFileList: LIST OF ROPE; -- Source files that will be transfered FROM Cedar
        binInFileList: LIST OF ROPE; -- Binary files that will be transfered FROM Cedar
        srcOutFileList: LIST OF ROPE; -- Source files that will be copied TO Cedar back
        binOutFileList: LIST OF ROPE; -- Binary files that will be copied TO Cedar back
        unlinkList: LOR Ź NIL; --files to unlink later
        rshCmd: ROPE;
        currentDir: ROPE ~ CommandTool.CurrentWorkingDirectory[];

            InnerDoIt: PROC [hostType, targetType: SystemVersion.MachineType] ~ {
                <<Side Effects msg and result in the enclosing procedure.>>
                ENABLE {
                    FS.Error => {
                        msg Ź error.explanation;
                        GOTO Failed;
                        };
                    ABORTED => {
                        msg Ź "-- Aborted!";
                        GOTO Failed;
                        }
                    };

            <<Step One: tame the file view mess>>
                <<What if the command does something (like mv) that would break links?>>
                <<>>
                {ENABLE UNWIND => UnlinkList[unlinkList];

                FOR list: LIST OF ROPE Ź srcInFileList, list.rest WHILE list # NIL DO
                    fileName: ROPE ~ list.first;
                    [, unlinkList] Ź ViewFix[srcDir.Cat[fileName], NIL, FALSE, TRUE, FALSE, unlinkList];
                    ENDLOOP;
                FOR list: LIST OF ROPE Ź binInFileList, list.rest WHILE list # NIL DO
                    fileName: ROPE ~ list.first;
                    [, unlinkList] Ź ViewFix[binDir.Cat[fileName], NIL, FALSE, TRUE, FALSE, unlinkList];
                    ENDLOOP;
                FOR list: LIST OF ROPE Ź srcInFileList, list.rest WHILE list # NIL DO
                    fileName: ROPE ~ list.first;
                    [, unlinkList] Ź ViewFix[srcDir.Cat[fileName], NIL, FALSE, TRUE, TRUE, unlinkList];
                    ENDLOOP;
                FOR list: LIST OF ROPE Ź binInFileList, list.rest WHILE list # NIL DO
                    fileName: ROPE ~ list.first;
                    [, unlinkList] Ź ViewFix[binDir.Cat[fileName], NIL, FALSE, TRUE, TRUE, unlinkList];
                    ENDLOOP;
            <<Step Two: do the Rsh on host>>
            <<>>
                {
                    status: INT;
                    localMsg: ROPE Ź NIL;
                    realDir: ROPE Ź currentDir;

                    IF NOT srcDir.Equal[NIL]
                        THEN
                            IF srcDir.Fetch[0] = '/
                                THEN realDir Ź srcDir
                                ELSE realDir Ź currentDir.Cat["/", srcDir]
                        ELSE
                            realDir Ź currentDir;
                    [status: status, msg: localMsg] Ź ExecuteCsh[hostType: hostType, targetType: targetType, commandLines: rshCmd, wDir: realDir];
                    IF ( NOT localMsg.Equal[NIL] )
                        THEN {
                            IF ( status # 0 ) THEN {
                                msg Ź IO.PutFR["Command failed; error: %g, msg: %g",  IO.int[status], IO.rope[localMsg]];
                                GOTO Failed;
                                };
                            msg Ź IO.PutFR[".\nCommand warnings: %g", IO.rope[localMsg]];
                            }
                        ELSE {
                            msg Ź ".";
                            };
                    cmd.err.PutRope[msg];
                    cmd.err.Flush[];
                    };
                Process.CheckForAbort[];

            <<Step Three: remove the links.>>

                }; UnlinkList[unlinkList];

            <<Step Four: process the file adding extra symbols and dependecy info.>>

                IF ( xFlag ) THEN {
                    self: ExtendADotOut.ObjectID;
                    action: ExtendADotOut.ActionID ~ ExtendADotOut.ActionIDFromAction[xClassName];
                    dependList: LIST OF ExtendADotOut.ObjectID Ź NIL;
                    deps: ExtendADotOut.DependencyInfo;
                    depFileList: LIST OF ROPE Ź NIL;
                    stamp: ExtendADotOut.VersionStamp;

                    FOR list: LIST OF ROPE Ź srcInFileList, list.rest WHILE list # NIL DO
                        fileName: ROPE ~ list.first;
                        depFileList Ź CONS[Rope.Cat[srcDir, fileName], depFileList];
                        ENDLOOP;
                    FOR list: LIST OF ROPE Ź binInFileList, list.rest WHILE list # NIL DO
                        fileName: ROPE ~ list.first;
                        depFileList Ź CONS[Rope.Cat[binDir, fileName], depFileList];
                        ENDLOOP;
                    FOR list: LIST OF ROPE Ź depFileList, list.rest WHILE list # NIL DO
                        fileName: ROPE ~ list.first;
                        dependList Ź CONS[ExtendADotOut.ObjectIDFromFile[fileName], dependList];
                        ENDLOOP;

                    stamp Ź ExtendADotOut.StampFromIDs[action, dependList];

                    FOR list: LIST OF ROPE Ź binOutFileList, list.rest WHILE list # NIL DO
                        outFilename: ROPE ~ list.first;
                        self.class Ź ExtendADotOut.ObjectClassFromFileName[outFilename];
                        self.stamp Ź stamp;
                        self.name Ź Rope.Cat[binDir, outFilename];
                        deps Ź NEW [ExtendADotOut.DependencyInfoRep Ź [
                            self: self,
                            action: action,
                            dependList: dependList
                            ]];

                        ExtendADotOut.PutDependencyInfo[Rope.Cat[binDir, outFilename], deps];
                        ENDLOOP;
                    };

                msg Ź " no errors.";
            EXITS
            Failed => { result Ź $Failure };
                };

        targetClass: ROPE Ź UserProfile.Token[key: MACHINECLASS, default: "sun4"];
        hostClass: ROPE Ź MachineClassFromMachineType[ SystemVersion.machineType ];
        <<userHost: ROPE _ NIL;>>

            ProcessCommandLine: PROC ~ {
            nArgs: INT32 ~ Args.NArgs[cmd];
                i: NAT;
                FOR i Ź 0, i.SUCC WHILE ( i < nArgs ) DO
                    NextRope: PROC RETURNS [ r: ROPE ] ~ INLINE {
                        ropeArg: Args.Arg ~ Args.ArgRope[cmd, i.SUCC];
                        r Ź ropeArg.rope;
                        i Ź i.SUCC;
                        };
                    FixNextList: PROC RETURNS [ l: LIST OF ROPE Ź NIL ] ~ INLINE {
                        <<Warning, Warning!!! create list in reverse order!>>
                        FOR j: INT32 Ź i.SUCC, j.SUCC WHILE ( j < nArgs ) DO
                            anArg: ROPE ~ Args.GetRope[cmd, j];
                            IF ( anArg.Fetch[0] = '- ) THEN { i Ź j.PRED; EXIT} ;
                            l Ź CONS[FixPath[anArg], l];
                            REPEAT
                                FINISHED => { i Ź nArgs }
                            ENDLOOP;
                        };
                    anArg: ROPE ~ Args.GetRope[cmd, i];
                    SELECT TRUE FROM
                        anArg.Equal[s2: "-binIn", case: FALSE] => { binInFileList Ź FixNextList[] };
                        anArg.Equal[s2: "-srcIn", case: FALSE] => { srcInFileList Ź FixNextList[] };
                        anArg.Equal[s2: "-binOut", case: FALSE] => { binOutFileList Ź FixNextList[] };
                        anArg.Equal[s2: "-srcOut", case: FALSE] => { srcOutFileList Ź FixNextList[] };
                        anArg.Equal[s2: "-srcDir", case: FALSE] => { srcDir Ź NextRope[] };
                        anArg.Equal[s2: "-binDir", case: FALSE] => { binDir Ź NextRope[] };
                        <<anArg.Equal[s2: "-host", case: FALSE] => { userHost _ NextRope[] };>>
                        anArg.Equal[s2: "-class", case: FALSE] => { targetClass Ź NextRope[] };
                        anArg.Equal[s2: "-cmd", case: FALSE] => { rshCmd Ź NextRope[] };
                        anArg.Equal[s2: "-XClass", case: FALSE] => { xFlag Ź TRUE; xClassName Ź NextRope[] };
                        ENDCASE => ERROR CommandSyntaxError;
                    ENDLOOP; 
                    IF binDir.Equal[NIL] THEN binDir Ź srcDir;
                    };

            ProcessCommandLine[];

        srcDir Ź FixDirectory[srcDir];
        binDir Ź FixDirectory[binDir];

            cmd.err.PutRope["Starting Rsh"];
            cmd.err.Flush[];
            InnerDoIt[
            hostType: MachineTypeFromMachineClass[hostClass], 
            targetType: MachineTypeFromMachineClass[targetClass]];
        <<That's all!>>
        EXITS
        Failed => { result Ź $Failure };
            };


    <<Documentation>>
        ComplexCC: ROPE ~ "ComplexCC";
        ComplexCCDoc: ROPE ~ " - cc with all the frills.  Switches are:
          -in <file>
          -out <file>
          -class <as in SystemVersion.MachineTypes>
          -host <host>
          -cSwitch <cc switches>
          -load <file list> => load compiled file together with <file list>
          -X => eXtend the resulting binary file with fast symbol and dependecy info
          -lSwitch <ld switches>
          -Lib libstring => string with the libraries to load
          -int <file list> => files to copy to the host before compiling
          -srcDir <dir> => remote source directory
          -binDir <dir> => remote object file directory
            (overridden by directory part specified in -out)
        ";
        ComplexCCUsage: ROPE ~ Rope.Concat["Usage: ComplexCC ", ComplexCCDoc];

        ComplexRsh: ROPE ~ "ComplexRsh";
        ComplexRshDoc: ROPE ~ " - Rsh with all the frills.  Switches are:
          -class <as in SystemVersion.MachineTypes>
          -host <host>
          -srcIn <file list> => source files to copy to the host before doing Rsh
          -binIn <file list> => binary files to copy to the host before doing Rsh
          -srcOut <file list> => source files to copy from the host after doing Rsh
          -binOut <file list> => binary files to copy from the host after doing Rsh
          -srcDir <dir> => remote source directory (command will execute in srcDir)
          -binDir <dir> => remote binary directory (equal to -srcDir by default)
          -XClass <className> => eXtend the resulting binary files with fast symbol and dependency information; use <className> to 
        identify the action performed.
          -cmd <command> => command to execute remotely
         ";
        ComplexRshUsage: ROPE ~ Rope.Concat["Usage: ComplexRsh ", ComplexRshDoc];
        ComplexRshUsageHostMissing: ROPE ~ Rope.Concat["No host has been specified\nUsage: ComplexRsh ", ComplexRshDoc];

        ComplexErrorProc: Commander.CommandProc ~ {ERROR};

        Init: PROC ~ {
            Commander.Register[ComplexCC, ComplexCCProc, ComplexCCDoc];
            Commander.Register[ComplexRsh, ComplexRshProc, ComplexRshDoc];
            Commander.Register["ComplexError", ComplexErrorProc, "raises ERROR, for debugging"];
            };

        Init[];
        }.

<<Changes:>>
<<Added -X and -XClass flags>>
<<Added encoding of dependencies>>
<<Added binDir to ComplexRsh;  note: command still executes in srcDir until I chase clients around.  CC version has not been 
changed yet.>>
<<>>
<<To Change:>>
<<Encoding of boundaries for Howard>>