
    <<BringDAToolsImpl.mesa>>
        <<Copyright Ó 1986, 1987 by Xerox Corporation.  All rights reserved.>>
        <<Created by Bertrand Serlet, October 21, 1986 10:11:12 pm PDT>>
        <<Bertrand Serlet January 23, 1987 12:01:18 pm PST>>
        <<>>
    DIRECTORY
        BasicTime, Commander, CommandTool, DFClosure, DFUtilities, FileNames, FS, IO, MessageWindow, ProcessProps, Rope, SystemVersion;

    BringDAToolsImpl: CEDAR PROGRAM
        IMPORTS Commander, CommandTool, DFClosure, DFUtilities, FileNames, FS, IO, MessageWindow, ProcessProps, Rope, SystemVersion
        ~ BEGIN 

        ROPE: TYPE ~ Rope.ROPE;
        ROPES: TYPE ~ LIST OF ROPE;
        STREAM: TYPE = IO.STREAM;

        Switches: TYPE = PACKED ARRAY CHAR['a..'z] OF BOOL;

    CmdData: TYPE = REF CmdDataRec; -- for user feedback
    CmdDataRec: TYPE = RECORD [
    out: STREAM,
    considered: INT _ 0,
    attached: INT _ 0,
    switches: Switches _ ALL [FALSE],
    failed: BOOL _ FALSE
    ];

    File: DFClosure.FileProc = {
    cmdData: CmdData = NARROW [data];
        zap: BOOL = cmdData.switches['z] OR (cmdData.switches['y] AND DFUtilities.ClassifyFileExtension[name]=derived);
        localName: ROPE = DFUtilities.RemoveVersionNumber[name]; 
        serverName: ROPE = Rope.Cat[from, name];
        BEGIN
        attachedTo: ROPE;
        created: BasicTime.GMT;
        cmdData.considered _ cmdData.considered + 1;
        [attachedTo: attachedTo, created: created] _ FS.FileInfo[name: localName, remoteCheck: FALSE ! FS.Error => GOTO Copy]; -- if the 
        file is inexistent, we copy it!
        IF attachedTo=NIL AND NOT zap THEN {cmdData.out.PutF["%g not copied: local version exists.\n", IO.rope[serverName]]; RETURN};
        IF created=date.gmt THEN RETURN; -- already there
        IF LOOPHOLE [created, INT]>LOOPHOLE [date.gmt, INT] AND NOT zap THEN {cmdData.out.PutF["%g not copied: local version is more 
        recent.\n", IO.rope[serverName]]; RETURN};
        GOTO Copy;
        EXITS
            Copy => {
                IF cmdData.switches['v] AND NOT cmdData.switches['w] THEN cmdData.out.PutF["Attaching %g.\n", IO.rope[serverName]];
                IF cmdData.switches['w] 
                    THEN cmdData.out.PutF["%g would have been attached.\n", IO.rope[serverName]]
                    ELSE {
                        [] _ FS.Copy[
                            to: localName, from: serverName, wantedCreatedTime: date.gmt, attach: TRUE
                            ! FS.Error => cmdData.out.PutF["%g can not be copied: %g.\n", IO.rope[serverName], IO.rope[error.explanation]]; 
                            ];
                        cmdData.attached _ cmdData.attached + 1;
                        };
                };
    END;
    };

    cedarTop: ROPE = IO.PutFR["/Cedar/Cedar%g.%g/Top/*.df", IO.int[SystemVersion.release.major], IO.int[SystemVersion.release.minor]];
    daTop: ROPE = IO.PutFR["/DATools/DATools%g.%g/Top/*.df", IO.int[SystemVersion.release.major], IO.int[SystemVersion.release.minor]];
    daMap: ROPE = IO.PutFR["/DATools/DATools%g.%g/Top/DATools.df", IO.int[SystemVersion.release.major], 
    IO.int[SystemVersion.release.minor]];

    Import: DFClosure.ImportProc = {
    cmdData: CmdData = NARROW [data];
    dfName _ FileNames.ConvertToSlashFormat[dfName];
    RETURN [SELECT TRUE FROM
    Rope.Match[daTop, dfName, FALSE]                                            => all,
    NOT cmdData.switches['c] AND Rope.Match[cedarTop, dfName, FALSE]    => none, -- those are already running
    ENDCASE                                                                            => public];
    };

        Error: DFClosure.ErrorProc = {
        cmdData: CmdData = NARROW [data];
        cmdData.out.PutF[message];
        cmdData.out.PutF["\n"];
        cmdData.failed _ kind=aborted;
        };

    Message: DFClosure.MessageProc = {MessageWindow.Append[message, TRUE]};

    BringDATools: Commander.CommandProc = {
    out: STREAM = NARROW [ProcessProps.GetProp[$CommanderHandle], Commander.Handle].out;
    cmdData: CmdData = NEW [CmdDataRec _ [out: out]];
        argv: CommandTool.ArgumentVector _ CommandTool.Parse[cmd: cmd, starExpand: FALSE
            ! CommandTool.Failed => {msg _ errorMsg; GO TO failed}];
        FOR i: NAT IN [1..argv.argc) DO
            sense: BOOL _ TRUE;
            arg: ROPE = argv[i];
            IF Rope.Length[arg] = 0 THEN LOOP;
            IF Rope.Fetch[arg, 0] # '- THEN {msg _ "Incorrect Syntax"; GO TO failed};
            FOR index: INT IN [0..Rope.Length[arg]) DO
                char: CHAR _ Rope.Fetch[arg, index];
                SELECT char FROM
                    '- => LOOP;
                    '~ => {sense _ NOT sense; LOOP};
                    IN ['a..'z] => cmdData.switches[char] _ sense;
                    IN ['A..'Z] => cmdData.switches[char + ('a-'A)] _ sense;
                    ENDCASE    => {msg _ "Incorrect Syntax"; GO TO failed};
                sense _ TRUE;
                ENDLOOP;
            ENDLOOP;
    [] _ DFClosure.EnumerateClosure[daMap, TRUE, File, Import, Error, Message, cmdData];
    IF cmdData.failed 
    THEN result _ $Failure 
    ELSE {
    MessageWindow.Append["BringDATools done!", TRUE];
    out.PutF["BringDATools: %g files considered, %g files attached.\n", IO.int[cmdData.considered], IO.int[cmdData.attached]];
    };
        EXITS
            failed => {result _ $Failure};
    };

        doc: ROPE = "Brings in the current directory enough to be able to run all released DATools
          -c: also bring public part of Cedar imports
          -v: verbose (list files to be attached)
          -w: warning only (no files attached)
          -y: zap derived files regardless of date and local version
          -z: zap files regardless of date and local version
          ";

        <<We register the command in ///Commands/ so that it can be used from several directories (for the release software for example)>>
        Commander.Register["///Commands/BringDATools", BringDATools, doc];

    END.