<<>> <> <> <> <
>
    <<>>
    DIRECTORY BasicTime, CedarProcess, Commander, Convert, EditSpanSupport, PFS, IO, Rope, TextNode, TiogaExtraOps, TiogaOpsDefs, 
    TiogaOps, TiogaIO, TiogaToWalnut;

    TiogaToWalnutImpl: CEDAR PROGRAM
        IMPORTS BasicTime, CedarProcess, Commander, Convert, EditSpanSupport, IO, PFS, Rope, TextNode, TiogaOps, TiogaExtraOps, TiogaIO, 
        TiogaToWalnut
        EXPORTS TiogaToWalnut

    ~ BEGIN
<>
    ROPE: TYPE ~ Rope.ROPE;

    Explanation: ROPE ~ "Write the contents of a file to a walnut archive file.
    \tTiogaToWalnut [-flags] archiveFileName _ tiogaFileName msgSetName
    \twhere flags are interpreted as follows:
    \t\t'a' means append to archive file instead of overwrite.
    \t\t'x' means don't write the archive file at all, just check for wellformed peanut nodes
    \t\t'p' process a peanut file
    \t\t'v' means verbosely announce when done with each file
    ";
<>
    GetContentsOfNodeAndChildren: PUBLIC PROC [node: TextNode.Ref] RETURNS [text, formatting: ROPE] ~ {
        root, endnode, tmpnode: TiogaOps.Ref;
        newspan, span: TextNode.Span;
        level: INT;

        <>
        endnode Ź node;
        level Ź TextNode.Level[node];
        tmpnode Ź TextNode.StepForward[node];
        UNTIL tmpnode = NIL OR TextNode.Level[tmpnode] = level DO 
            CedarProcess.CheckAbort[];
            endnode Ź tmpnode;
            tmpnode Ź TextNode.StepForward[tmpnode];
            ENDLOOP;

        <>
        span Ź TextNode.MakeNodeSpan[node, endnode];
        newspan Ź EditSpanSupport.CopySpan[span];
        root Ź TextNode.Root[newspan.start.node];
        CedarProcess.CheckAbort[];

        [text, formatting] Ź GetContents[root];
        };

    ContentsToArchive: PUBLIC PROC [text, formatting: ROPE, msgSet, msgID: ROPE, outstream: IO.STREAM] ~ {
        length, prefixLength, itemLength, formatLength, textLength: INT;

        <>
        IF msgID = NIL THEN {
            msgID Ź BuildMsgId[msgSet];
            };

        <>
        text Ź Rope.Substr[text, 1]; -- Skip the root node, archive format doesn't want it.
        formatLength Ź Rope.Length[formatting];
        textLength Ź Rope.Length[text] + 1; -- + 1 for newline at end
    <<20 below is the length of the combined fixed parts of everthing between the two @'s: the newlines, the lengths, and the space.>>
        itemLength Ź 20 + Rope.Length[msgID] + Rope.Length[msgSet] + Rope.Length[formatting];
    <<8+15+2 is the length of the stuff before the first @, plus the 2 @'s.>>
        prefixLength Ź 8 + 16 + 2 + itemLength;
        length Ź prefixLength + textLength;
        IO.PutF1[outstream, "%g\n", IO.rope["*start*"]];
        IO.PutF[outstream, "%05g %05g US \n", IO.int[length], IO.int[prefixLength]];
        IO.PutF[outstream, "@%05g 00525 %05g\n", IO.int[itemLength], IO.int[formatLength]];
        IO.PutF1[outstream, "%g\n", IO.rope[msgID]];
        IO.PutF1[outstream, "%g\n", IO.rope[msgSet]];
        IO.PutF1[outstream, "%g\n", IO.rope[formatting]];
        IO.PutF1[outstream, "@%g\n", IO.rope[text]];
        };

<>
    GetContents: PROC [root: TextNode.Ref] RETURNS [text, formatting: ROPE] ~ {
        pair: TiogaIO.Pair Ź TiogaIO.ToPair[root];
        RETURN[
            text: pair.contents,
            formatting: pair.formatting
            ];
        };


    MinLoc: PROC [loc1, loc2: TiogaOps.Location] RETURNS [minloc: TiogaOps.Location] ~ {
        IF loc1.node = NIL THEN minloc Ź loc2
        ELSE IF loc2.node = NIL THEN minloc Ź loc1
        ELSE IF TiogaOps.CompareLocOrder[loc1, loc2] = before THEN minloc Ź loc1 ELSE minloc Ź loc2;
        RETURN [minloc];
        };

    CurrentDate: PROC [] RETURNS [date: ROPE] ~ {
        time: BasicTime.ExtendedGMT Ź BasicTime.ExtendedNow[];
        date Ź Convert.RopeFromTime[from: time.gmt, end: seconds];
        date Ź Rope.Cat[date, ":", Convert.RopeFromInt[time.usecs]];
        };

    BuildMsgId: PROC [uniquifier: ROPE] RETURNS [msgId: ROPE] ~ {
        date: ROPE = CurrentDate[];
        msgId Ź IO.PutFR["$ TiogaToWalnutServer:%g:PARCXerox@%g", IO.rope[uniquifier], IO.rope[date]];
        RETURN [msgId];
        };
<>
    <>
        <>
    TiogaToWalnutCmd: Commander.CommandProc ~ {
        cmdin: IO.STREAM = IO.RIS[cmd.commandLine];
        outstream: IO.STREAM;
        r, startnode: TextNode.Ref;
        count: INT;
        text, formatting, archiveName, tiogaFile, msgSetName, leftArrow, name, msgId, arg, uniquifier, date: ROPE;
        DoCheckOnly: BOOL Ź FALSE;
        PeanutFormat: BOOL Ź FALSE;
        Verbose: BOOL Ź FALSE;
        accessType: PFS.AccessOptions Ź create;
        {
        <>
            arg Ź IO.GetTokenRope[cmdin, IO.IDProc ! IO.Error, IO.EndOfStream => { GOTO formatfailure;}].token;
            WHILE Rope.Fetch[arg,0] = '- DO 
                <>
                flags: ROPE Ź arg;
                l: INT Ź Rope.Length[flags];
                pos: INT;

                CedarProcess.CheckAbort[];

                <>
                WHILE (pos Ź Rope.SkipTo[flags, 0, "~"]) < l DO
                    flags Ź Rope.Replace[flags, pos, 2, NIL];
                    ENDLOOP; 

                <>
                IF Rope.SkipTo[flags, 0, "a"] < l THEN accessType Ź append;
                IF Rope.SkipTo[flags, 0, "x"] < l THEN DoCheckOnly Ź TRUE;
                IF Rope.SkipTo[flags, 0, "p"] < l THEN PeanutFormat Ź TRUE;
                IF Rope.SkipTo[flags, 0, "v"] < l THEN Verbose Ź TRUE;
                arg Ź IO.GetTokenRope[cmdin, IO.IDProc ! IO.Error, IO.EndOfStream => { GOTO formatfailure;}].token;
                ENDLOOP;
            archiveName Ź arg;
            leftArrow Ź IO.GetTokenRope[cmdin, IO.IDProc ! IO.Error, IO.EndOfStream => { GOTO formatfailure;}].token;
            IF NOT Rope.Equal[leftArrow, "_"] THEN GOTO formatfailure;
            tiogaFile Ź IO.GetTokenRope[cmdin, IO.IDProc ! IO.Error, IO.EndOfStream => { GOTO formatfailure;}].token;
            msgSetName Ź IO.GetTokenRope[cmdin, IO.IDProc ! IO.Error, IO.EndOfStream => { GOTO formatfailure;}].token;

            <>
            IF DoCheckOnly 
                THEN {
                    outstream Ź IO.noWhereStream;
                    }
                ELSE {
                    outstream Ź PFS.StreamOpen[PFS.PathFromRope[archiveName], accessType ! PFS.Error =>
                        IF error.group = user THEN {IO.PutF1[cmd.out, "%g\n", IO.rope[error.explanation]]; name Ź archiveName; GOTO iofailure;}];
                    };
            startnode Ź TiogaExtraOps.GetFile[tiogaFile ! PFS.Error, IO.Error, IO.EndOfStream => { name Ź tiogaFile; GOTO iofailure;}];

            <>
            IF PeanutFormat THEN startnode Ź TextNode.Forward[startnode].nx;
        <<>>
        <>
            count Ź 0;
            WHILE startnode # NIL DO
                CedarProcess.CheckAbort[];
                uniquifier Ź IO.PutR[IO.rope[tiogaFile], IO.int[count]];
                msgId Ź BuildMsgId[uniquifier];
                [text, formatting] Ź TiogaToWalnut.GetContentsOfNodeAndChildren[startnode];
                TiogaToWalnut.ContentsToArchive[text, formatting, msgSetName, msgId, outstream];
                startnode Ź TextNode.ForwardClipped[startnode, 1, 1].nx;
                count Ź count + 1;
                IF Verbose AND (count MOD 10) = 0 THEN {
                    IF (count MOD 100) = 0
                        THEN IO.Put1[cmd.out, IO.int[count]]
                        ELSE IO.Put1[cmd.out, IO.rope["~"]];
                        };
                ENDLOOP;
            TiogaExtraOps.FreeTree[r];
            IO.Close[outstream];
            IF Verbose THEN IO.PutF[cmd.out, "Finished %g msgs in %g.\n", IO.int[count], IO.rope[tiogaFile]];

            EXITS
                iofailure =>  IO.PutF1[cmd.err, "Could not open file named '%g'.\n", IO.rope[name]];
                formatfailure =>  IO.PutF1[cmd.err, "%g\n", IO.rope[Explanation]];
            }
        };
<>
    Commander.Register["TiogaToWalnut", TiogaToWalnutCmd, Explanation];

    END.