<<>>
    <<StdCorpse3.mesa>>
        <<Copyright Ó 1991, 1992 by Xerox Corporation.  All rights reserved.>>
        <<Michael Plass, June 3, 1991 12:32 pm PDT>>
        <<Spreitze, January 10, 1992 7:00 am PST>>
        <<Laurie Horton, February 10, 1992 2:50 pm PST>>
        <<>>
    DIRECTORY Atom, Basics, Commander, CommanderOps, Convert, ImagerState, IO, Rope;

    StdCorpse3: CEDAR PROGRAM
    IMPORTS Atom, Commander, CommanderOps, Convert, ImagerState
    ~ BEGIN

        ROPE: TYPE ~ Rope.ROPE;

        doc: ROPE ~ "Options:
            singlet <a>
            pair <a> <b>
            triple <a> <b> <c>
            quad <a> <b> <c> <d>
            array <a0> <a1> <a2>
            sequence <a0> <a1> ...
            sequence2 <a0> <a1> ...
            ";

        DebugMe: SIGNAL [ref: REF, p, w: CARD] ~ CODE;

        state: ImagerState.State _ ImagerState.CreateState[];

        ESub: TYPE ~ Basics.PartialComparison;

        TagdVRT: TYPE ~ RECORD [SELECT tag: ESub FROM
            greater => [i: INT],
            incomparable => [c: CHAR]
            ENDCASE];
        BoundTagdVRT: TYPE ~ TagdVRT[greater];
        tvr: TagdVRT _ [greater[12]];
        btvr: BoundTagdVRT _ [greater[13]];

        CmpdVRT: TYPE ~ RECORD [SELECT COMPUTED ESub FROM
            greater => [i: INT],
            incomparable => [c: CHAR]
            ENDCASE];
        BoundCmpdVRT: TYPE ~ CmpdVRT[greater];
        cvr: CmpdVRT _ [greater[12]];
        bcvr: BoundCmpdVRT _ [greater[13]];

        OvldVRT: TYPE ~ RECORD [SELECT OVERLAID ESub FROM
            greater => [i: INT],
            incomparable => [c: CHAR]
            ENDCASE];
        BoundOvldVRT: TYPE ~ OvldVRT[greater];
        ovr: OvldVRT _ [greater[12]];
        bovr: BoundOvldVRT _ [greater[13]];

        NestedTagdVRT: TYPE ~ RECORD [SELECT tag: ESub FROM
            greater => [i: INT],
            incomparable => [c: CHAR],
            equal => [nest: TagdVRT],
            less => [s: REF Sequence]
            ENDCASE];
        BoundNestedTagdVRT: TYPE ~ NestedTagdVRT[equal];
        ntvr: NestedTagdVRT _ [equal[[greater[14]]]];
        bntvr: BoundNestedTagdVRT _ [equal[[greater[15]]]];
        bntvr2: NestedTagdVRT _ [less[NEW [Sequence[4]]]];

        NestedCmpdVRT: TYPE ~ RECORD [SELECT COMPUTED ESub FROM
            greater => [i: INT],
            incomparable => [c: CHAR],
            equal => [nest: CmpdVRT],
            less => [s: REF Sequence]
            ENDCASE];
        BoundNestedCmpdVRT: TYPE ~ NestedCmpdVRT[equal];
        ncvr: NestedCmpdVRT _ [equal[[greater[14]]]];
        bncvr: BoundNestedCmpdVRT _ [equal[[greater[15]]]];
        bncvr2: NestedCmpdVRT _ [less[NEW [Sequence[4]]]];

        NestedOvldVRT: TYPE ~ RECORD [SELECT OVERLAID ESub FROM
            greater => [i: INT],
            incomparable => [c: CHAR],
            equal => [nest: OvldVRT],
            less => [s: REF Sequence]
            ENDCASE];
        BoundNestedOvldVRT: TYPE ~ NestedOvldVRT[equal];
        novr: NestedOvldVRT _ [equal[[greater[14]]]];
        bnovr: BoundNestedOvldVRT _ [equal[[greater[15]]]];
        bnovr2: NestedOvldVRT _ [less[NEW [Sequence[4]]]];

        Singlet: TYPE ~ MACHINE DEPENDENT RECORD [a: [0..1024)];
        TestSinglet: PROC [a: CARD, si: Singlet] ~ {
            s: Singlet ~ [a];
            r: REF Singlet ~ NEW[Singlet _ s];
            p: CARD ~ LOOPHOLE[r];
            w: CARD ~ LOOPHOLE[s];
            DebugMe[r, p, w];
            };

        Pair: TYPE ~ MACHINE DEPENDENT RECORD [a: [0..1024), b: [0..4096)];
        TestPair: PROC [a, b: CARD, pi: Pair] ~ {
            s: Pair ~ [a, b];
            r: REF Pair ~ NEW[Pair _ s];
            p: CARD ~ LOOPHOLE[r];
            w: CARD ~ LOOPHOLE[s];
            DebugMe[r, p, w];
            };

        Triple: TYPE ~ MACHINE DEPENDENT RECORD [a: [0..2**10), b: [0..2**12), c: [0..2**10)];
        TestTriple: PROC [a, b, c: CARD, ti: Triple] ~ {
            s: Triple ~ [a, b, c];
            r: REF Triple ~ NEW[Triple _ s];
            p: CARD ~ LOOPHOLE[r];
            w: CARD ~ LOOPHOLE[s];
            DebugMe[r, p, w];
            };

        Quad: TYPE ~ MACHINE DEPENDENT RECORD [a: [0..2**10), b: [0..2**12), c, d: [0..2**10)];
        TestQuad: PROC [a, b, c, d: CARD, qi: Quad] ~ TRUSTED {
            s: Quad ~ [a, b, c, d];
            r: REF Quad ~ NEW[Quad _ s];
            p: CARD ~ LOOPHOLE[r];
            es: Quad _ s;
            w: CARD _ LOOPHOLE[@es];
            DebugMe[r, p, w];
            };

        Array: TYPE ~ PACKED ARRAY [0..3) OF Singlet;
        TestArray: PROC [a, b, c: CARD, ai: Array] ~ {
            s: Array ~ [[a], [b], [c]];
            r: REF Array ~ NEW[Array _ s];
            p: CARD ~ LOOPHOLE[r];
            DebugMe[r, p, BITS[Array]];
            };

        Nybble: TYPE ~ MACHINE DEPENDENT RECORD [a: [0..16)];
        Sequence: TYPE ~ MACHINE DEPENDENT RECORD [
            PACKED SEQUENCE size: CARD16 OF Nybble
            ];
        Sequence2: TYPE ~ MACHINE DEPENDENT RECORD [
            PACKED SEQUENCE size: INT OF Nybble
            ];
        TestSequence: PROC [n: INT, list: LIST OF CARD] ~ {
            s: REF Sequence ~ NEW[Sequence[n]];
            r: REF Sequence ~ s;
            p: CARD ~ LOOPHOLE[r];
            i: CARD16 _ 0;
            FOR tail: LIST OF CARD _ list, tail.rest UNTIL tail = NIL DO
                s[i] _ [tail.first];
                i _ i + 1;
                ENDLOOP;
            DebugMe[r, p, n];
            };

        TestSequence2: PROC [n: INT, list: LIST OF CARD] ~ {
            s: REF Sequence2 ~ NEW[Sequence2[n]];
            r: REF Sequence2 ~ s;
            p: CARD ~ LOOPHOLE[r];
            i: CARD16 _ 0;
            FOR tail: LIST OF CARD _ list, tail.rest UNTIL tail = NIL DO
                s[i] _ [tail.first];
                i _ i + 1;
                ENDLOOP;
            DebugMe[r, p, n];
            };

        Cmd: Commander.CommandProc ~ {
            ENABLE Convert.Error => CommanderOps.Failed[cmd.procData.doc];
            arg0: ROPE _ CommanderOps.NextArgument[cmd];
            Get: PROC RETURNS [CARD] ~ { RETURN [Convert.CardFromRope[CommanderOps.NextArgument[cmd]]] };
            IF arg0 = NIL THEN CommanderOps.Failed[cmd.procData.doc] ELSE {
                FOR arg: ROPE _ arg0, CommanderOps.NextArgument[cmd] UNTIL arg = NIL DO
                    SELECT Atom.MakeAtom[arg] FROM
                        $singlet => { a: CARD ~ Get[]; TestSinglet[a, [a]] };
                        $pair => { a: CARD ~ Get[]; b: CARD ~ Get[]; TestPair[a, b, [a, b]] };
                        $triple => { a: CARD ~ Get[]; b: CARD ~ Get[]; c: CARD ~ Get[]; TestTriple[a, b, c, [a, b, c]] };
                        $quad => { a: CARD ~ Get[]; b: CARD ~ Get[]; c: CARD ~ Get[]; d: CARD ~ Get[]; TestQuad[a, b, c, d, [a, b, c, d]] };
                        $array => { a: CARD ~ Get[]; b: CARD ~ Get[]; c: CARD ~ Get[]; TestArray[a, b, c, [[a], [b], [c]]] };
                        $sequence => {
                            head: LIST OF CARD ~ LIST[0];
                            last: LIST OF CARD _ head;
                            n: INT _ 0;
                            FOR num: ROPE _ CommanderOps.NextArgument[cmd], CommanderOps.NextArgument[cmd] UNTIL num = NIL DO
                                last _ last.rest _ LIST[Convert.CardFromRope[num]];
                                n _ n + 1;
                                ENDLOOP;
                            TestSequence[n, head.rest];
                            };
                        $sequence2 => {
                            head: LIST OF CARD ~ LIST[0];
                            last: LIST OF CARD _ head;
                            n: INT _ 0;
                            FOR num: ROPE _ CommanderOps.NextArgument[cmd], CommanderOps.NextArgument[cmd] UNTIL num = NIL DO
                                last _ last.rest _ LIST[Convert.CardFromRope[num]];
                                n _ n + 1;
                                ENDLOOP;
                            TestSequence2[n, head.rest];
                            };
                        ENDCASE => CommanderOps.Failed[cmd.procData.doc];
                    ENDLOOP;
                };
            };

        Commander.Register["CirioMachineDependentRecordsTest", Cmd, doc];

    END.