
    <<RadioStates.mesa>>
        <<Copyright Ó 1987 by Xerox Corporation.  All rights reserved.>>
        <<Barth, October 26, 1989 3:20:49 pm PDT>>
        <<>>
    DIRECTORY  
        Basics, IO, Process, TerminalIO;

    RadioStates: CEDAR PROGRAM
        IMPORTS Basics, IO, Process, TerminalIO = BEGIN

    stateCount: CARDINAL = 8;
    log2stateCount: CARDINAL = 3;
    StateRange: TYPE = [0..stateCount);
    states: ARRAY StateRange OF WORD _ ALL[0];
    adjacent: ARRAY StateRange OF ARRAY StateRange OF BOOL;

    ScanHack: PROC = {
        DO
            DO
                stateIndex: INT;
                FOR stateIndex IN StateRange DO
                    IF states[stateIndex]=stateCount-1 THEN states[stateIndex] _ 0
                    ELSE {
                        states[stateIndex] _ states[stateIndex] + 1;
                        EXIT;
                        };
                    REPEAT FINISHED => GOTO noneFound;
                    ENDLOOP;
                FOR stateIndex IN StateRange DO
                    FOR scanIndex: CARDINAL IN StateRange DO
                        IF states[stateIndex]=states[scanIndex] AND stateIndex#scanIndex THEN GOTO notDistinct;
                        ENDLOOP;
                    REPEAT
                        notDistinct => LOOP;
                    ENDLOOP;
                EXIT;
                ENDLOOP;
            Process.CheckForAbort[];
            IF states[0]=7 THEN {
                TerminalIO.PutRope["\n Current state assignments: "];
                FOR stateIndex: INT IN StateRange DO
                    TerminalIO.PutF[" %g", IO.card[states[stateIndex]]];
                    ENDLOOP;
                };
            FOR stateIndex: CARDINAL IN StateRange DO
                FOR scanIndex: CARDINAL IN [0..stateIndex) DO
                    IF adjacent[stateIndex][scanIndex] THEN {
                        foundOne: BOOL _ FALSE;
                        compatible: WORD _ Basics.BITXOR[states[stateIndex], states[scanIndex]];
                        FOR bitIndex: CARDINAL IN [0..log2stateCount) DO
                            one: BOOL _ Basics.BITAND[compatible, 1]#0;
                            compatible _ Basics.BITSHIFT[compatible, -1];
                            IF NOT one THEN LOOP;
                            IF foundOne THEN GOTO incompatible;
                            foundOne _ TRUE;
                            ENDLOOP;
                        };
                    ENDLOOP;
                REPEAT
                    incompatible => NULL;
                    FINISHED => {
                        TerminalIO.PutRope["\n Compatible state assignments: "];
                        FOR stateIndex: INT IN StateRange DO
                            TerminalIO.PutF[" %g", IO.card[states[stateIndex]]];
                            ENDLOOP;
                        };
                ENDLOOP;
            REPEAT noneFound => TerminalIO.PutRope["\nNo compatible assignments"];
            ENDLOOP;
        };

    A: PROC [a, b: INT] = {
        adjacent[a][b] _ TRUE;
        adjacent[b][a] _ TRUE;
        };

    FOR stateIndex: INT IN StateRange DO
        FOR scanIndex: CARDINAL IN StateRange DO
            adjacent[stateIndex][scanIndex] _ FALSE;
            ENDLOOP;
        ENDLOOP;
    A[0, 1];
    A[0, 2];
    A[0, 5];
    A[0, 3];
    A[1, 2];
    A[1, 5];
    A[2, 3];
    A[2, 5];
    A[3, 4];
    A[3, 6];
    A[3, 7];
    A[4, 5];
    A[4, 6];
    A[4, 7];
    A[5, 6];
    A[6, 7];

    machine: BoolEx.Expression _ NIL;
resetTrue:        IO.ROPE        _ "Reset";
resetFalse:        IO.ROPE        _ "NOTReset";
resetFalseExpr:    LIST OF REF    _ LIST[BoolEx.OpNm[not], resetTrue];
resetFalseDef:    LIST OF REF    _ LIST[BoolEx.OpNm[var], resetFalse, resetFalseExpr];
machine _ CONS[resetFalseDef, machine];

machine _ CONS[BoolEx.OpNm[machine], CONS["SlipClock", machine]];
    machine _ PLAOps.CompressExpression[machine, TRUE];
    machine _ PLAOps.FactorExpression[machine];
    END.