
    <<CMosImpl.mesa>>
        <<Copyright © 1983, 1985 by Xerox Corporation.  All rights reserved.>>
        <<by Ch. Jacobi, August 11, 1983 3:56 pm>>
        <<last edited Christian Jacobi, March 25, 1986 4:33:10 pm PST>>

    DIRECTORY
        CD,
        CDColors,
        CDLayers,
        CDEvents,
        CDIO,
        CDOps,
        CDPanel,
        CDSequencer,
        CDTipEtc,
        CDViewer,
        CMos,
        ColorMaps,
        Commander USING [CommandProc, Register],
        FileNames,
        IO,
        Rope,
        TerminalIO,
        TokenIO;

    CMosImpl: CEDAR PROGRAM
        IMPORTS CD, CDColors, CDLayers, CDEvents, CDIO, CDOps, CDPanel, CDSequencer, CDTipEtc, CDViewer, ColorMaps, Commander, FileNames, 
        IO, TerminalIO, TokenIO 
        EXPORTS CMos
        SHARES CDLayers = 
    BEGIN

        cmos: PUBLIC CD.Technology;
    lambda: CD.Number = CMos.lambda;

        ndif: PUBLIC CD.Layer;
        pdif: PUBLIC CD.Layer;

        wndif: PUBLIC CD.Layer;
        wpdif: PUBLIC CD.Layer;

        pwell: PUBLIC CD.Layer;
        nwell: PUBLIC CD.Layer;
        pwellCont: PUBLIC CD.Layer;
        nwellCont: PUBLIC CD.Layer;

        pol: PUBLIC CD.Layer;
        met: PUBLIC CD.Layer;
        met2: PUBLIC CD.Layer;

        imp: PUBLIC CD.Layer;
        bur: PUBLIC CD.Layer;
        ovg: PUBLIC CD.Layer;
        cut: PUBLIC CD.Layer;
        cut2: PUBLIC CD.Layer;


    CurrentDiffusion: PUBLIC PROC [design: CD.Design] RETURNS [CD.Layer] =
        BEGIN
        lev: CD.Layer _ CDLayers.CurrentLayer[design];
        IF lev=wpdif THEN RETURN [pdif];
        IF lev=wndif THEN RETURN [ndif];
        IF lev=ndif OR lev=pdif OR lev=pwellCont OR lev=nwellCont THEN RETURN [lev] ELSE RETURN [CD.undefLayer]
        END;

    SetLayerNWell: PROC [comm: CDSequencer.Command] =
        BEGIN
        TerminalIO.WriteRope["NWell for default\n"];
        CDLayers.SetCurrentLayer[comm.design, nwell]
        END;

    SetLayerPWell: PROC [comm: CDSequencer.Command] =
        BEGIN
        TerminalIO.WriteRope["PWell for default\n"];
        CDLayers.SetCurrentLayer[comm.design, pwell];
        END;

    SetLayerDif: PROC [comm: CDSequencer.Command] =
        BEGIN
        TerminalIO.WriteRope["diffusion for default\n"];
        CDLayers.SetCurrentLayer[comm.design, ndif]
        END;

    SetLayerPol: PROC [comm: CDSequencer.Command] =
        BEGIN
        TerminalIO.WriteRope["poly for default\n"];
        CDLayers.SetCurrentLayer[comm.design, pol]
        END;

    SetLayerMet2: PROC [comm: CDSequencer.Command] =
        BEGIN
        TerminalIO.WriteRope["metal-2 for default\n"];
        CDLayers.SetCurrentLayer[comm.design, met2]
        END;

    SetLayerMet: PROC [comm: CDSequencer.Command] =
        BEGIN
        TerminalIO.WriteRope["metal for default\n"];
        CDLayers.SetCurrentLayer[comm.design, met]
        END;

    SetLayerPDif: PROC [comm: CDSequencer.Command] =
        BEGIN
        TerminalIO.WriteRope["p-diff for default\n"];
        CDLayers.SetCurrentLayer[comm.design, wpdif]
        END;

    SetLayerNWCnt: PROC [comm: CDSequencer.Command] =
        BEGIN
        TerminalIO.WriteRope["N-Well Cnt for default\n"];
        CDLayers.SetCurrentLayer[comm.design, nwellCont]
        END;

    SetLayerPWCnt: PROC [comm: CDSequencer.Command] =
        BEGIN
        TerminalIO.WriteRope["P-Well Cnt for default\n"];
        CDLayers.SetCurrentLayer[comm.design, pwellCont]
        END;

    DiffToPWorld: PROC [comm: CDSequencer.Command] =
        BEGIN
        layer: CD.Layer = CDLayers.CurrentLayer[comm.design];
        TerminalIO.WriteRope["Switch diffusion to P type"];
        SELECT layer FROM
            ndif => CDLayers.SetCurrentLayer[comm.design, wpdif];
            pwellCont => CDLayers.SetCurrentLayer[comm.design, nwellCont];
            ENDCASE => TerminalIO.WriteRope["  not done"];
        TerminalIO.WriteLn[];
        END;

    DiffToNWorld: PROC [comm: CDSequencer.Command] =
        BEGIN
        layer: CD.Layer = CDLayers.CurrentLayer[comm.design];
        TerminalIO.WriteRope["Switch diffusion to N type"];
        SELECT layer FROM
            pdif => CDLayers.SetCurrentLayer[comm.design, ndif];
            wpdif => CDLayers.SetCurrentLayer[comm.design, ndif];
            nwellCont => CDLayers.SetCurrentLayer[comm.design, pwellCont];
            ENDCASE => TerminalIO.WriteRope["  not done"];
        TerminalIO.WriteLn[];
        END;

    RegisterObjectClass: PUBLIC PROC [a: ATOM] RETURNS [CD.ObjectClass] =
        BEGIN
        RETURN [ CD.RegisterObjectClass[a, [technology: cmos]] ];
        END; 

    Load: Commander.CommandProc = 
        BEGIN
        cmd.out.PutRope["cmos loaded\n"];
        END;

    NewCWorld: Commander.CommandProc = 
        BEGIN
        design: CD.Design _ CDOps.CreateDesign[cmos];
        [] _ CDViewer.CreateViewer[design];
        END;

    WriteTechnologyKey: CDEvents.EventProc =
        BEGIN
        TokenIO.WriteAtom[$CMos]; 
        TokenIO.WriteInt[1];
        END;   

    ReadTechnologyKey: CDEvents.EventProc =
        BEGIN
        dont _ TRUE;
        IF TokenIO.ReadAtom[]=$CMos THEN { 
            version: INT = TokenIO.ReadInt[];
            IF version=1 THEN dont_FALSE
            ELSE IF version=0 THEN {
                TerminalIO.WriteRope["***********************\n"];
                TerminalIO.WriteRope["WARNING: objects using p-diffusion\n"];
                TerminalIO.WriteRope["may be displaced; chat with Christian\n"];
                TerminalIO.WriteRope["***********************\n"];
                dont_FALSE
                }; 
            };
        IF dont THEN TerminalIO.WriteRope["CMos version miss-match\n"];
        END;   


    InitBricks: PROC [] =
        BEGIN
        <<--8bit colors-->>
        nDiffColor: CARDINAL = 1;
        pDiffColor: CARDINAL = 2;
        met1Color: CARDINAL = 4;
        met2Color: CARDINAL = 8;
        polyColor: CARDINAL = 16;
        nWellColor: CARDINAL = 32;
        pWellColor: CARDINAL = 64;
        black: CARDINAL = 127;

        Checker8: PROC[col1, col2: CARDINAL] RETURNS[REF CDColors.Brick] = 
            BEGIN 
            RETURN[NEW[CDColors.Brick _ [col1*256+col2, col2*256+col1, col1*256+col2, col2*256+col1]]]
            END;

        DefineDimmer8: PROC[lev: CD.Layer, color: CARDINAL] = 
            BEGIN 
            CDColors.DefineColor[lev, Checker8[color, 0], bit8, pushedOut];
            END;

        Full8: PROC[color: CARDINAL] RETURNS [b: REF CDColors.Brick] = 
            BEGIN
            RETURN[Checker8[color, color]]
            END;

        s1: CARDINAL = 1;
        s2: CARDINAL = 16;
        s3: CARDINAL = 16*16;
        s4: CARDINAL = 16*16*16;
        ss: CARDINAL = s1+s2+s3+s4;

        <<--4bit colors-->>
        green: CARDINAL = 1;
        blue: CARDINAL = 2;
        red: CARDINAL = 4;
        yellow: CARDINAL = 14;

        CDColors.DefineColor[cut, NEW[CDColors.Brick_[7*ss, 11*ss, 7*ss, 11*ss]], bit4];
        CDColors.DefineColor[cut, NEW[CDColors.Brick_[7*ss, 11*ss, 7*ss, 11*ss]], bw];

        CDColors.DefineColor[ndif, NEW[CDColors.Brick_[green*ss, green*ss, green*ss, green*ss]], bit4];
        CDColors.DefineColor[ndif, NEW[CDColors.Brick_[4*ss, ss, 4*ss, ss]], bw];

        CDColors.DefineColor[pdif, NEW[CDColors.Brick_[1*ss, 3*ss, 1*ss, 1*ss]], bit4];
        CDColors.DefineColor[pdif, NEW[CDColors.Brick_[5*ss, ss, 4*ss, ss]], bw];

        CDColors.DefineColor[pwellCont, NEW[CDColors.Brick_[1*ss, 1*ss, 0*ss, 1*ss]], bit4];
        CDColors.DefineColor[pwellCont, NEW[CDColors.Brick_[0*ss, ss, 4*ss, ss]], bw];

        CDColors.DefineColor[nwellCont, NEW[CDColors.Brick_[1*ss, 1*ss, 2*ss, 1*ss]], bit4];
        CDColors.DefineColor[nwellCont, NEW[CDColors.Brick_[2*ss, ss, 4*ss, ss]], bw];

        CDColors.DefineColor[pol, NEW[CDColors.Brick_[red*ss, red*ss, red*ss, red*ss]], bit4];
        CDColors.DefineColor[pol, NEW[CDColors.Brick_[8*ss, 4*ss, 2*ss, 1*ss]], bw];

        CDColors.DefineColor[met, NEW[CDColors.Brick_[blue*ss, blue*ss, blue*ss, blue*ss]], bit4];
        CDColors.DefineColor[met, NEW[CDColors.Brick_[8*ss, 2*ss, 0, 0]], bw];

        CDColors.DefineColor[imp, NEW[CDColors.Brick_[yellow*ss, yellow*ss, yellow*ss, yellow*ss]], bit4];
        CDColors.DefineColor[imp, NEW[CDColors.Brick_[2*ss, 0, 2*ss, 0]], bw];

        CDColors.DefineColor[met2, NEW[CDColors.Brick_[2*(s1+s2+s3), 2*ss, 2*(s1+s2+s3)+15*s4, 2*ss]], bit4];
        CDColors.DefineColor[met2, NEW[CDColors.Brick_[8*ss, 8*ss, 2*ss, 2*ss]], bw];

        CDColors.DefineColor[nwell, NEW[CDColors.Brick_[8*s1, 0, 0, 0]], bit4];
        CDColors.DefineColor[nwell, NEW[CDColors.Brick_[4*ss, 0, 0, 0]], bw];

        CDColors.DefineColor[pwell, NEW[CDColors.Brick_[4*s1, 0, 0, 0]], bit4];
        CDColors.DefineColor[pwell, NEW[CDColors.Brick_[2*ss, 0, 0, 0]], bw];

        CDColors.DefineColor[bur, NEW[CDColors.Brick_[11*ss, 11*ss, 11*ss, 11*ss]], bit4];
        CDColors.DefineColor[bur, NEW[CDColors.Brick_[4*ss, 14*ss, 4*ss, 0*ss]], bw];

        CDColors.DefineColor[ovg, NEW[CDColors.Brick_[8*ss, 8*ss, 8*ss, 8*ss]], bit4];
        CDColors.DefineColor[ovg, NEW[CDColors.Brick_[4*ss, 14*ss, 4*ss, 0*ss]], bw];

        CDColors.DefineColor[cut2, NEW[CDColors.Brick_[3*ss, 14*ss, 3*ss, 14*ss]], bit4];
        CDColors.DefineColor[cut2, NEW[CDColors.Brick_[3*ss, 14*ss, 3*ss, 14*ss]], bw];

        <<--wpdif should never be drawn>>
        CDColors.DefineColor[wpdif, NEW[CDColors.Brick_[3*ss, 14*ss, 3*ss, 14*ss]], bit4];
        CDColors.DefineColor[wpdif, NEW[CDColors.Brick_[3*ss, 14*ss, 3*ss, 14*ss]], bw];

        CDColors.DefineColor[ndif, Full8[nDiffColor], bit8];
        CDColors.DefineColor[pdif, Full8[pDiffColor], bit8];
        CDColors.DefineColor[met, Full8[met1Color], bit8];
        CDColors.DefineColor[met2, Full8[met2Color], bit8]; 
        CDColors.DefineColor[pol, Full8[polyColor], bit8];
        CDColors.DefineColor[nwell, Full8[nWellColor], bit8];
        CDColors.DefineColor[pwell, Full8[pWellColor], bit8];
        CDColors.DefineColor[cut, Full8[black], bit8];

        CDColors.DefineColor[cut2, Checker8[black, met1Color], bit8];
        CDColors.DefineColor[bur, Checker8[black, 0], bit8];
        CDColors.DefineColor[nwellCont, Checker8[pDiffColor, met1Color], bit8];
        CDColors.DefineColor[pwellCont, Checker8[nDiffColor, met1Color], bit8];
        CDColors.DefineColor[ovg, Checker8[met1Color, met2Color], bit8];

        CDColors.DefineColor[imp, NEW[CDColors.Brick_[14, 14, 0, 0]], bit8];

        CDColors.DefineColor[CD.backgroundLayer, NEW[CDColors.Brick _ [8, 0, 256*8, 0]], bit8];
        CDColors.DefineColor[CD.errorLayer, NEW[CDColors.Brick _ [255, 0, 0, 0]], bit8];
        CDColors.DefineColor[CD.shadeLayer, NEW[CDColors.Brick_[0, 255,0 , 255]], bit8];

        DefineDimmer8[ndif, nDiffColor];
        DefineDimmer8[pdif, pDiffColor];
        DefineDimmer8[met, met1Color];
        DefineDimmer8[met2, met2Color];
        DefineDimmer8[pol, polyColor];
        DefineDimmer8[nwell, nWellColor];
        DefineDimmer8[cut, black];
        DefineDimmer8[cut2, black];
        <<-- no change for bur, nwelCont, pwelCont, and ovgc for this background>>

        END;

    Init: PROC [] =
        BEGIN
        cmos _ CD.RegisterTechnology[$cmos, "cmos", 2];

        ndif _ CD.NewLayer[cmos, $ndif];
        pdif _ CD.NewLayer[cmos, $pdif];
        wndif _ CD.NewLayer[cmos, $wndif];
        wpdif _ CD.NewLayer[cmos, $wpdif];
        pwell _ CD.NewLayer[cmos, $pwel];
        nwell _ CD.NewLayer[cmos, $nwel];
        pwellCont _ CD.NewLayer[cmos, $pwelCont];
        nwellCont _ CD.NewLayer[cmos, $nwelCont];

        pol _ CD.NewLayer[cmos, $pol];
        met _ CD.NewLayer[cmos, $met];
        met2 _ CD.NewLayer[cmos, $met2];

        imp _ CD.NewLayer[cmos, $imp];
        bur _ CD.NewLayer[cmos, $bur];
        ovg _ CD.NewLayer[cmos, $ovg];
        cut _ CD.NewLayer[cmos, $cut];
        cut2 _ CD.NewLayer[cmos, $cut2];

        CDLayers.MakeAbstract[abstract: wpdif, represents: pdif];
        CDLayers.MakeAbstract[abstract: wndif, represents: ndif];

        InitBricks[];

        ColorMaps.RegisterMenu["cmos-a", CDIO.MakeName["cmosa", "ColorMap", FileNames.CurrentWorkingDirectory[]]];

        CDPanel.DefineLayerEntry[cmos, ndif, "ndif", 0, 2*lambda];
        CDPanel.DefineLayerEntry[cmos, wpdif, "wpdif", 0, 2*lambda];
        CDPanel.DefineLayerEntry[cmos, pol, "pol", 0, 2*lambda];
        CDPanel.DefineLayerEntry[cmos, met, "met", 0, 3*lambda];
        CDPanel.DefineLayerEntry[cmos, pwellCont, "p-wCnt", 0, 2*lambda];
        CDPanel.DefineLayerEntry[cmos, nwellCont, "n-wCnt", 0, 2*lambda];
        CDPanel.DefineLayerEntry[cmos, nwell, "nwell", 0, 0];
        CDPanel.DefineLayerEntry[cmos, met2, "met2", 0, 4*lambda];
        CDPanel.DefineLayerEntry[cmos, cut, "cut", 0, 0];
        CDPanel.DefineLayerEntry[cmos, cut2, "cut2", 0, 0];
        CDPanel.DefineLayerEntry[cmos, ovg, "ovg", 0, 0];
        CDPanel.DefineLayerEntry[cmos, bur, "bur", 0, 0];
        CDPanel.DefineLayerEntry[cmos, pwell, "(pwell)", 0, 0];
        CDPanel.DefineLayerEntry[cmos, pdif, "(pdif)", 0, 2*lambda];
        CDPanel.DefineLayerEntry[cmos, wndif, "(wndif)", 0, 2*lambda];

        CDPanel.DefineIntEntry[cdValueKey: $CDxSelectNewMode, tech: cmos,
            text: "select new:", min: 0, max: 1, default: 1];
        CDPanel.DefineNewLine[cmos];
        CDPanel.DefineIntEntry[cdValueKey: $CDxStepValue, tech: cmos, text: "step moves   size:", min: 1, default: lambda];
        CDPanel.DefineNewLine[cmos];

        CDSequencer.ImplementCommand[$SetLayerNWell, SetLayerNWell, cmos, doQueue];
        CDSequencer.ImplementCommand[$SetLayerNDif, SetLayerDif, cmos, doQueue];
        CDSequencer.ImplementCommand[$SetLayerPol, SetLayerPol, cmos, doQueue];
        CDSequencer.ImplementCommand[$SetLayerMet, SetLayerMet, cmos, doQueue];
        CDSequencer.ImplementCommand[$SetLayerMet2, SetLayerMet2, cmos, doQueue];
        CDSequencer.ImplementCommand[$SetLayerPDif, SetLayerPDif, cmos, doQueue];
        CDSequencer.ImplementCommand[$SetLayerNWCnt, SetLayerNWCnt, cmos, doQueue];
        CDSequencer.ImplementCommand[$SetLayerPWCnt, SetLayerPWCnt, cmos, doQueue];

        CDSequencer.ImplementCommand[$TestDifFlipToPWorld, DiffToPWorld, cmos, doQueue];
        CDSequencer.ImplementCommand[$TestDifFlipToNWorld, DiffToNWorld, cmos, doQueue];
        CDSequencer.ImplementCommand[$DiffToPWorld, DiffToPWorld, cmos, doQueue];
        CDSequencer.ImplementCommand[$DiffToNWorld, DiffToNWorld, cmos, doQueue];

        CDEvents.RegisterEventProc[$WriteTechnologyPrivate, WriteTechnologyKey, cmos];
        CDEvents.RegisterEventProc[$ReadTechnologyPrivate, ReadTechnologyKey, cmos];

        CDTipEtc.SetIcon[cmos, "Chipndale.icons", 3];
        CDTipEtc.SetPanelIcon[cmos, "Chipndale.icons", 4];

        CDTipEtc.SetTipTable[cmos, "Standard"];

        Commander.Register[  
            key: "CDNewCMosA", 
            proc: NewCWorld,
            doc: "Creates new cmos-A design"
            ];
        Commander.Register[  
            key: "CDCMosA", 
            proc: Load,
            doc: "loads cmos-A ChipNDale"
            ];
        Commander.Register[  
            key: "CDNewCMos", 
            proc: NewCWorld,
            doc: "Creates new cmos design"
            ];
        Commander.Register[  
            key: "CDCMos", 
            proc: Load,
            doc: "loads cmos ChipNDale"
            ];
        TerminalIO.WriteRope["cmos-A impl\n"];
        END;

    Init[];
    END.