
<<BiasTypesImpl.Mesa, from [Indigo]<Rosemary>2.6>Rosemary.DF>>
<<Last Edited by: Spreitzer, August 18, 1984 8:59:42 pm PDT>>

    DIRECTORY IO, BiasTypes, RoseCreate, RoseTypes, SignalTypeRegistration, SwitchTypes, VFonts;

    BiasTypesImpl: CEDAR PROGRAM
        IMPORTS IO, RoseCreate, SignalTypeRegistration, SwitchTypes, VFonts
        EXPORTS BiasTypes =

    BEGIN OPEN RoseTypes, BiasTypes;

    biasProcs: NodeProcs _ NEW [NodeProcsRep _ [
        Bits: BiasBits,
        MesaUse: BiasMesaUse,
        UserDescription: BiasUserDescription,
        MesaDescription: BiasMesaDescription,
        ListFormats: BiasListFormats,
        GetFormat: BiasGetFormat,
        MakeTransducer: MakeBiasSwitchTransducer]];

    biasType: PUBLIC NodeType _ NEW [NodeTypeRep[atom] _ [
        procs: biasProcs,
        typeData: NIL,
        simple: TRUE,
        structure: atom[]]];

    onlyBiasFormat: Format _ NEW [FormatRep _ [
        FormatValue: BiasFormatValue,
        ParseValue: BiasParseValue,
        FormatTest: BiasFormatTest,
        ParseTest: BiasParseTest,
        MaxWidth: BiasMaxWidth,
        key: "bias"]];

    ConstructBiasType: PROC [parms: REF ANY --UNION [BindingList, Args]--] RETURNS [type: 
    NodeType]--RoseTranslateTypes.NodeTypeConstructor-- =
        BEGIN
        type _ biasType;
        END;

    BiasBits: PROC [NodeType] RETURNS [INTEGER] = {RETURN [1]};
    BiasMesaUse: PROC [NodeType] RETURNS [m: Mesa] =
        {m _ ["BiasTypes.Bias", LIST["BiasTypes"]]};
    BiasUserDescription: PROC [NodeType] RETURNS [r: ROPE] = {r _ "Bias"};
    BiasMesaDescription: PROC [NodeType] RETURNS [m: Mesa] =
        {m _ [mesa: "BiasTypes.biasType", imports: LIST["BiasTypes"]]};
    BiasListFormats: PROC [NodeType] RETURNS [l: RopeList] = {l _ LIST ["bias"]};
    BiasGetFormat: PROC [NodeType, ROPE] RETURNS [f: Format] =
        {f _ onlyBiasFormat};

    BHP: TYPE = LONG POINTER TO BiasHolder;

    BiasFormatValue: PROC [node: Node, fmt: Format, wp: WordPtr] RETURNS [r: ROPE] = TRUSTED {
        bhp: BHP _ LOOPHOLE[wp];
        r _ Encode[bhp.bias]};

    Encode: PROC [b: Bias] RETURNS [r: ROPE] = {
        r _ SELECT b FROM
            Plus => "+",
            Minus => "-",
            ENDCASE => ERROR Coding};

    Coding: ERROR = CODE;

    BiasParseValue: PROC [node: Node, fmt: Format, wp: WordPtr, s: STREAM] RETURNS [success: BOOLEAN] = {
        b: Bias;
        bhp: BHP _ LOOPHOLE[wp];
        success _ TRUE;
        b _ Decode[s !Coding => {success _ FALSE; CONTINUE}];
        IF NOT success THEN RETURN;
        TRUSTED {bhp.bias _ b};
        };

    Decode: PROC [from: STREAM] RETURNS [b: Bias] = {
        c: CHAR;
        [] _ from.SkipWhitespace[flushComments: FALSE];
        c _ from.GetChar[];
        SELECT c FROM
            '+ => b _ Plus;
            '- => b _ Minus;
            ENDCASE => ERROR Coding};

    BiasFormatTest: PROC [nt: NodeType, fmt: Format, tp: NodeTestProc, td: NodeTestData] RETURNS [r: ROPE] =
        BEGIN
        rb: REF Bias _ NARROW[td];
        r _ Encode[rb^];
        END;

    BiasParseTest: PROC [nt: NodeType, fmt: Format, s: STREAM] RETURNS [success: BOOLEAN, tp: NodeTestProc, td: NodeTestData] =
        BEGIN
        b: Bias;
        success _ TRUE;
        b _ Decode[s !Coding => {success _ FALSE; CONTINUE}];
        IF NOT success THEN RETURN;
        tp _ BiasTest;
        td _ NEW [Bias _ b];
        END;

    BiasTest: NodeTestProc--PROC [where: WordPtr, testData: NodeTestData, nodeType: NodeType] RETURNS [passes: BOOLEAN]-- =
        BEGIN
        rb: REF Bias _ NARROW[testData];
        bhp: BHP _ LOOPHOLE[where];
        TRUSTED {passes _ bhp.bias = rb^};
        END;

    BiasMaxWidth: PROC [nt: NodeType, fmt: Format, font: VFonts.Font] RETURNS [INT] =
        {RETURN [VFonts.StringWidth["+", font]]};

    MakeBiasSwitchTransducer: PROC [myKind, otherKind: Node, within: Cell, writeMine, writeOther: BOOLEAN, for: ExpansionReceiver] 
    RETURNS [t: Cell] = {
        instanceName: ROPE _ IO.PutFR["%g-%g", IO.rope[myKind.name], IO.rope[otherKind.name]];
        interfaceNodes: ROPE _ IO.PutFR["bias: %g, switch: %g", IO.rope[myKind.name], IO.rope[otherKind.name]];
        t _ for.class.CellInstance[erInstance: for.instance, instanceName: instanceName, typeName: BSName[], interfaceNodes: 
        interfaceNodes];
        };

    bsType: CellType _ NIL;

    BSName: PROC RETURNS [name: ROPE] = {
        IF bsType = NIL THEN {
            bsPorts: Ports _ NEW [PortsRep[2]];
            bsPorts[0] _ [0, 1, "bias", biasType, TRUE, TRUE];
            bsPorts[1] _ [1, 1, "switch", SwitchTypes.bitType, TRUE, TRUE];
            bsType _ RoseCreate.RegisterCellType[
                name: "BiasSwitchTransducer",
                ioCreator: CreateBSIO,
                initializer: InitBS,
                evals: [EvalSimple: EvalBS, InitUD: InitBSUD, PropUD: PropBSUD],
                ports: bsPorts];
            };
        name _ bsType.name};

    BSIORep: TYPE = MACHINE DEPENDENT RECORD [
        bhp(0:0..15): BiasHolder,
        switch(1:0..15): SwitchTypes.SwitchVal];

    BSState: TYPE = REF BSStateRep;
    BSStateRep: TYPE = RECORD [firstSwitch, firstSimple: BOOL];

    InitBS: PROC [cell: Cell, leafily: BOOL] = {
        IF leafily THEN cell.realCellStuff.state _ NEW [BSStateRep _ [TRUE, TRUE]]};

    CreateBSIO: PROC [cell: Cell] = {
        cell.realCellStuff.newIO _ NEW [BSIORep];
        cell.realCellStuff.oldIO _ NEW [BSIORep];
        cell.realCellStuff.switchIO _ NEW [BSIORep]};

    EvalBS: PROC [cell: Cell] = {state: BSState _ NARROW[cell.realCellStuff.state];
        IF state.firstSimple THEN state.firstSimple _ FALSE ELSE ERROR};
    InitBSUD: PROC [cell: Cell] = {state: BSState _ NARROW[cell.realCellStuff.state];
        IF state.firstSwitch THEN state.firstSwitch _ FALSE ELSE ERROR};
    PropBSUD: PROC [cell: Cell] = {};

    Setup: PROC =
        BEGIN
        SignalTypeRegistration.RegisterNodeTypeConstructor["BIAS", ConstructBiasType];
        END;

    Setup[];

    END.