
<<[Indigo]<Rosemary>Ž>Rosemary.DF=>SwitchNumConvertImpl.Mesa>>
<<Last Edited by: Spreitzer, May 1, 1985 4:44:45 pm PDT>>

    DIRECTORY Basics, NumTypes, RoseTypes, SwitchNumConvert, SwitchTypes;

    SwitchNumConvertImpl: CEDAR PROGRAM
        IMPORTS NumTypes, SwitchTypes
        EXPORTS SwitchNumConvert =

    BEGIN OPEN NumTypes, SwitchTypes, RoseTypes;

    Transduce: PUBLIC PROC [fromS: Strength, fromT, toT: NodeType, fromP, toP: Ptr] = {
        SELECT TRUE FROM
            Numeric[fromT] => SELECT TRUE FROM
                Numeric[toT] => ERROR;
                IsSwitchType[toT] => NumToSwitch[fromS, fromT, toT, fromP, toP];
                ENDCASE => ERROR;
            IsSwitchType[fromT] => SELECT TRUE FROM
                Numeric[toT] => SwitchToNum[fromS, fromT, toT, fromP, toP];
                IsSwitchType[toT] => ERROR;
                ENDCASE => ERROR;
            ENDCASE => ERROR;
        };

    Switches: TYPE = LONG POINTER TO PACKED ARRAY CARDINAL OF SwitchVal;
    Nums: TYPE = RECORD [
        o: [0 .. Basics.bitsPerWord),
        p: LONG POINTER TO PACKED ARRAY CARDINAL OF BOOLEAN];

    SwitchToNum: PROC [fromS: Strength, fromT, toT: NodeType, fromP, toP: Ptr] = {
        ss: Switches _ PtrToSwitches[fromP];
        ns: Nums _ PtrToNums[toP];
        WITH fromT SELECT FROM
            fromA: ArrayNodeType => {
                FOR i: NAT IN [0 .. fromA.length) DO
                    TRUSTED {SELECT ss[i].val FROM
                        L => ns.p[i+ns.o] _ FALSE;
                        H => ns.p[i+ns.o] _ TRUE;
                        X => ERROR;
                        ENDCASE => ERROR};
                    ENDLOOP;
                };
            fromA: AtomNodeType => {
                TRUSTED {SELECT ss[0].val FROM
                    L => ns.p[ns.o] _ FALSE;
                    H => ns.p[ns.o] _ TRUE;
                    X => ERROR;
                    ENDCASE => ERROR};
                };
            ENDCASE => ERROR;
        };

    NumToSwitch: PROC [fromS: Strength, fromT, toT: NodeType, fromP, toP: Ptr] = {
        ns: Nums _ PtrToNums[fromP];
        ss: Switches _ PtrToSwitches[toP];
        WITH fromT SELECT FROM
            fromA: ArrayNodeType => {
                FOR i: NAT IN [0 .. fromA.length) DO
                    TRUSTED {
                        ss[i].s[q] _ fromS;
                        IF ns.p[i+ns.o]
                            THEN {ss[i].s[u] _ fromS; ss[i].s[d] _ none; ss[i].val _ H}
                            ELSE {ss[i].s[u] _ none; ss[i].s[d] _ fromS; ss[i].val _ L};
                        };
                    ENDLOOP;
                };
            fromA: AtomNodeType => {
                TRUSTED {
                    ss[0].s[q] _ fromS;
                    IF ns.p[ns.o]
                        THEN {ss[0].s[u] _ fromS; ss[0].s[d] _ none; ss[0].val _ H}
                        ELSE {ss[0].s[u] _ none; ss[0].s[d] _ fromS; ss[0].val _ L};
                    };
                };
            ENDCASE => ERROR;
        };

    PtrToSwitches: PROC [p: Ptr] RETURNS [ss: Switches] = {
        IF p.bit # 0 THEN ERROR;
        TRUSTED {ss _ LOOPHOLE[p.word]}};

    PtrToNums: PROC [p: Ptr] RETURNS [ns: Nums] = TRUSTED
        {ns _ [o: p.bit, p: LOOPHOLE[p.word]]};

    END.