
    <<CMosBCommands.mesa  (part of ChipNDale)>>
        <<Copyright © 1983, 1986 by Xerox Corporation.  All rights reserved.>>
        <<Created by Christian Jacobi, June 24, 1983 5:03 pm >>
        <<Last edited by: Christian Jacobi, January 28, 1987 2:58:54 pm PST>>

    DIRECTORY
        CD,
        CDAtomicObjects,
        CDLayers,
        CDOps,
        CDCommandOps,
        CDPanel,
        CDPanelFonts,
        CDSequencer,
        CDTexts,
        CDValue,
        CDViewer,
        IO,
        Rope,
        TerminalIO,
        CMosB,
        ViewerClasses,
        ViewerOps;

    CMosBCommands: CEDAR PROGRAM 
        IMPORTS CD, CDAtomicObjects, CDCommandOps, CDLayers, CDOps, CDPanel, CDPanelFonts, CDSequencer, CDTexts, CDValue, CDViewer, 
        TerminalIO, CMosB, ViewerOps = 
    BEGIN

    lambda: CD.Number = CMosB.lambda;
     
    CreateXstr: PROC [comm: CDSequencer.Command] = {
        ob: CD.Object;
        layer: CD.Layer;
        size: CD.Position _ [8*lambda, 8*lambda];
        TerminalIO.PutRope["create transistor "];
        SELECT comm.key FROM
            $DrawNXstr => layer _ CMosB.ndif;
            $DrawWNXstr => layer _ CMosB.wndif;
            $DrawPXstr => layer _ CMosB.pdif;
            $DrawWPXstr => layer _ CMosB.wpdif;
            ENDCASE => layer _ CMosB.ndif;
        TerminalIO.PutRopes[CDOps.LayerRope[layer], "\n"];
        ob _ CDAtomicObjects.CreateAtomicOb[$C2Trans, size, comm.design.technology, layer];
        CDCommandOps.IncludeOb[comm, ob]
        };

    CreateLXstr: PROC [comm: CDSequencer.Command] = {
        ob: CD.Object;
        layer: CD.Layer;
        TerminalIO.PutRope["create L transistor "];
        SELECT comm.key FROM
            $DrawAngleNXstr => layer _ CMosB.ndif;
            $DrawAngleWNXstr => layer _ CMosB.wndif;
            $DrawAnglePXstr => layer _ CMosB.pdif;
            $DrawAngleWPXstr => layer _ CMosB.wpdif;
            ENDCASE => layer _ CMosB.ndif;
        TerminalIO.PutRopes[CDOps.LayerRope[layer], "\n"];
        ob _ CDAtomicObjects.CreateAtomicOb[$C2LTrans, [0, 0], comm.design.technology, layer];
        CDCommandOps.IncludeOb[comm, ob]
        };

    CreateCont: PROC [comm: CDSequencer.Command] = {
        ob: CD.Object;
        layer: CD.Layer;
        TerminalIO.PutRope["create contact "];
        SELECT comm.key FROM
            $DrawNDifCon => layer _ CMosB.ndif;
            $DrawWNDifCon => layer _ CMosB.wndif;
            $DrawPDifCon => layer _ CMosB.pdif;
            $DrawWPDifCon => layer _ CMosB.wpdif;
            $DrawPolCon => layer _ CMosB.pol;
            $DrawNWCntCon => layer _ CMosB.nwellCont;
            $DrawPWCntCon => layer _ CMosB.pwellCont;
            $DrawWNWCntCon => layer _ CMosB.wnwellCont;
            $DrawWPWCntCon => layer _ CMosB.wpwellCont;
            ENDCASE => layer _ CMosB.pol;
        TerminalIO.PutRopes[CDOps.LayerRope[layer], "\n"];
        ob _ CDAtomicObjects.CreateAtomicOb[$C2SimpleCon, [0, 0], comm.design.technology, layer];
        CDCommandOps.IncludeOb[comm, ob]
        };

    CreateLargeCont: PROC [comm: CDSequencer.Command] = {
        ob: CD.Object;
        layer: CD.Layer;
        TerminalIO.PutRope["create large contact "];
        SELECT comm.key FROM
            $DrawLNDifCon => layer _ CMosB.ndif;
            $DrawLWNDifCon => layer _ CMosB.wndif;
            $DrawLPDifCon => layer _ CMosB.pdif;
            $DrawLWPDifCon => layer _ CMosB.wpdif;
            $DrawLPolCon => layer _ CMosB.pol;
            $DrawLNWCntCon => layer _ CMosB.nwellCont;
            $DrawLPWCntCon => layer _ CMosB.pwellCont;
            $DrawWNWCntCon => layer _ CMosB.wnwellCont;
            $DrawWPWCntCon => layer _ CMosB.wpwellCont;
            ENDCASE => layer _ CMosB.pol;
        TerminalIO.PutRopes[CDOps.LayerRope[layer], "\n"];
        ob _ CDAtomicObjects.CreateAtomicOb[$C2LargeSimpleCon, [0, 0], comm.design.technology, layer];
        CDCommandOps.IncludeOb[comm, ob]
        };

    CreateDiffShortCont: PROC [comm: CDSequencer.Command] = {
        ob: CD.Object;
        layer: CD.Layer;
        TerminalIO.PutRope["create diff short contact "];
        SELECT comm.key FROM
            $DrawNDifShortCon => layer _ CMosB.ndif;
            $DrawWNDifShortCon => layer _ CMosB.wndif;
            $DrawPDifShortCon => layer _ CMosB.pdif;
            $DrawWPDifShortCon => layer _ CMosB.wpdif;
            ENDCASE => layer _ CMosB.ndif;
        TerminalIO.PutRopes[CDOps.LayerRope[layer], "\n"];
        ob _ CDAtomicObjects.CreateAtomicOb[$C2DifShortCon, [0, 0], comm.design.technology, layer];
        CDCommandOps.IncludeOb[comm, ob]
        };

    CreateVia: PROC [comm: CDSequencer.Command] = {
        ob: CD.Object;
        TerminalIO.PutRope["create via\n"];
        ob _ CDAtomicObjects.CreateAtomicOb[$C2Via, [0, 0], comm.design.technology];
        CDCommandOps.IncludeOb[comm, ob]
        };

    CreateLargeVia: PROC [comm: CDSequencer.Command] = {
        ob: CD.Object;
        TerminalIO.PutRope["create large via\n"];
        ob _ CDAtomicObjects.CreateAtomicOb[$C2LargeVia, [0, 0], comm.design.technology];
        IF ob=NIL THEN
            TerminalIO.PutRope["not done\n"]
        ELSE
            [] _ CDOps.IncludeObjectI[design: comm.design, ob: ob, location: comm.pos]
        };

    DiffToPWorld: PROC [comm: CDSequencer.Command] = {
        layer: CD.Layer = CDLayers.CurrentLayer[comm.design];
        TerminalIO.PutRope["Switch diffusion to P type"];
        SELECT layer FROM
            CMosB.ndif, CMosB.wndif => CDLayers.SetCurrentLayer[comm.design, CMosB.wpdif];
            CMosB.pwellCont => CDLayers.SetCurrentLayer[comm.design, CMosB.nwellCont];
            ENDCASE => TerminalIO.PutRope["  not done"];
        TerminalIO.PutRope["\n"];
        };

    DiffToNWorld: PROC [comm: CDSequencer.Command] = {
        layer: CD.Layer = CDLayers.CurrentLayer[comm.design];
        TerminalIO.PutRope["Switch diffusion to N type"];
        SELECT layer FROM
            CMosB.pdif, CMosB.wpdif => CDLayers.SetCurrentLayer[comm.design, CMosB.ndif];
            CMosB.nwellCont => CDLayers.SetCurrentLayer[comm.design, CMosB.pwellCont];
            ENDCASE => TerminalIO.PutRope["  not done"];
        TerminalIO.PutRope["\n"];
        };

SchematicModeComm: PROC [comm: CDSequencer.Command] = {
    GetGrid: PROC [viewer: ViewerClasses.Viewer] RETURNS [i: INT _ -1] = {
        WITH ViewerOps.GetViewer[viewer, $Grid] SELECT FROM
            ri: REF INT => i _ ri^;
            ENDCASE => NULL;
        };
    font: CDTexts.CDFont _ CDPanelFonts.CurrentFont[comm.design];
    viewer: ViewerClasses.Viewer _ CDViewer.GetViewer[comm];
IF viewer#NIL THEN { 
is: INT _ GetGrid[viewer];
goal: INT _ MAX[2*CMosB.lambda, is];
IF goal#is THEN ViewerOps.SetViewer[viewer: viewer, data: NEW[INT_goal], op: $Grid];
};
CDValue.StoreInt[comm.design, $PanelLayerMode, 0];
CDValue.StoreInt[comm.design, $CDxStepValue, 0];
[] _ CDPanel.PutUp[comm.design, $CDxStepValue];
CDLayers.SetCurrentLayer[comm.design, CD.commentLayer];
CDLayers.SetLayerWidth[comm.design, CD.commentLayer, CMosB.lambda/2];
[] _ CDPanel.PutUp[comm.design, $PanelLayerMode];
[] _ CDPanelFonts.SetCurrentFont[comm.design, CDTexts.MakeFont[font.supposedName, CMosB.lambda/2]];
    TerminalIO.PutRope["schematics mode\n"];
};

LayoutModeComm: PROC [comm: CDSequencer.Command] = {
    font: CDTexts.CDFont _ CDPanelFonts.CurrentFont[comm.design];
    viewer: ViewerClasses.Viewer _ CDViewer.GetViewer[comm];
IF viewer#NIL THEN 
ViewerOps.SetViewer[viewer: viewer, data: NEW[INT_CMosB.lambda], op: $Grid];
CDValue.StoreInt[comm.design, $PanelLayerMode, 1];
CDValue.StoreInt[comm.design, $CDxStepValue, 0];
[] _ CDPanel.PutUp[comm.design, $CDxStepValue];
IF CD.LayerTechnology[CDLayers.CurrentLayer[comm.design]]=NIL THEN
CDLayers.SetCurrentLayer[comm.design, CD.commentLayer];
[] _ CDPanel.PutUp[comm.design, $PanelLayerMode];
[] _ CDPanelFonts.SetCurrentFont[comm.design, CDTexts.MakeFont[font.supposedName, CMosB.lambda/4]];
    TerminalIO.PutRope["layout mode\n"];
};

    Init: PROC [] = {

        MakeComm: PROC [key: ATOM, p: CDSequencer.CommandProc, qm: CDSequencer.QueueMethod_doQueue] = {
            CDSequencer.ImplementCommand[key, p, CMosB.cmosB, qm];
            };

        fontNames: LIST OF Rope.ROPE = LIST[
            "4 Helvetica8", "4 Helvetica8B", "4 Helvetica12", "4 Helvetica6", "4 Helvetica6B",
            "4 TimesRoman8", "2 Helvetica8", "1 Helvetica8", "8 Helvetica8", "4 Gates32"];

        CDCommandOps.RegisterCurrentLayerCommand[$SetLayerComment, CD.commentLayer, CMosB.cmosB];
        CDCommandOps.RegisterCurrentLayerCommand[$SetLayerNWell, CMosB.nwell, CMosB.cmosB];
        CDCommandOps.RegisterCurrentLayerCommand[$SetLayerPWell, CMosB.pwell, CMosB.cmosB];
        CDCommandOps.RegisterCurrentLayerCommand[$SetLayerNDif, CMosB.ndif, CMosB.cmosB];
        CDCommandOps.RegisterCurrentLayerCommand[$SetLayerPol, CMosB.pol, CMosB.cmosB];
        CDCommandOps.RegisterCurrentLayerCommand[$SetLayerMet2, CMosB.met2, CMosB.cmosB];
        CDCommandOps.RegisterCurrentLayerCommand[$SetLayerMet, CMosB.met, CMosB.cmosB];
        CDCommandOps.RegisterCurrentLayerCommand[$SetLayerPDif, CMosB.wpdif, CMosB.cmosB];
        CDCommandOps.RegisterCurrentLayerCommand[$SetLayerNWCnt, CMosB.nwellCont, CMosB.cmosB];
        CDCommandOps.RegisterCurrentLayerCommand[$SetLayerPWCnt, CMosB.pwellCont, CMosB.cmosB];
        CDCommandOps.RegisterCurrentLayerCommand[$SetLayerWNWCnt, CMosB.wnwellCont, CMosB.cmosB];
        CDCommandOps.RegisterCurrentLayerCommand[$SetLayerWPWCnt, CMosB.wpwellCont, CMosB.cmosB];

        MakeComm[$TestDifFlipToPWorld, DiffToPWorld];
        MakeComm[$TestDifFlipToNWorld, DiffToNWorld];
        MakeComm[$DiffToPWorld, DiffToPWorld];
        MakeComm[$DiffToNWorld, DiffToNWorld];
        MakeComm[$DrawNXstr, CreateXstr, doQueueAndMark];
        MakeComm[$DrawPXstr, CreateXstr, doQueueAndMark];
        MakeComm[$DrawWNXstr, CreateXstr, doQueueAndMark];
        MakeComm[$DrawWPXstr, CreateXstr, doQueueAndMark];

        MakeComm[$DrawAngleNXstr, CreateLXstr, doQueueAndMark];
        MakeComm[$DrawAnglePXstr, CreateLXstr, doQueueAndMark];
        MakeComm[$DrawAngleWNXstr, CreateLXstr, doQueueAndMark];
        MakeComm[$DrawAngleWPXstr, CreateLXstr, doQueueAndMark];

        MakeComm[$DrawNDifCon, CreateCont, doQueueAndMark];
        MakeComm[$DrawWNDifCon, CreateCont, doQueueAndMark];
        MakeComm[$DrawPDifCon, CreateCont, doQueueAndMark];
        MakeComm[$DrawWPDifCon, CreateCont, doQueueAndMark];
        MakeComm[$DrawPolCon, CreateCont, doQueueAndMark];
        MakeComm[$DrawNWCntCon, CreateCont, doQueueAndMark];
        MakeComm[$DrawPWCntCon, CreateCont, doQueueAndMark];
        MakeComm[$DrawWNWCntCon, CreateCont, doQueueAndMark];
        MakeComm[$DrawWPWCntCon, CreateCont, doQueueAndMark];

        MakeComm[$DrawLNDifCon, CreateLargeCont, doQueueAndMark];
        MakeComm[$DrawLWNDifCon, CreateLargeCont, doQueueAndMark];
        MakeComm[$DrawLPDifCon, CreateLargeCont, doQueueAndMark];
        MakeComm[$DrawLWPDifCon, CreateLargeCont, doQueueAndMark];
        MakeComm[$DrawLPolCon, CreateLargeCont, doQueueAndMark];
        MakeComm[$DrawLNWCntCon, CreateLargeCont, doQueueAndMark];
        MakeComm[$DrawLPWCntCon, CreateLargeCont, doQueueAndMark];
        MakeComm[$DrawLWNWCntCon, CreateLargeCont, doQueueAndMark];
        MakeComm[$DrawLWPWCntCon, CreateLargeCont, doQueueAndMark];

        MakeComm[$DrawNDifShortCon, CreateDiffShortCont, doQueueAndMark];
        MakeComm[$DrawWNDifShortCon, CreateDiffShortCont, doQueueAndMark];
        MakeComm[$DrawPDifShortCon, CreateDiffShortCont, doQueueAndMark];
        MakeComm[$DrawWPDifShortCon, CreateDiffShortCont, doQueueAndMark];

        MakeComm[$DrawMm2Con, CreateVia, doQueueAndMark];
        MakeComm[$DrawLVia, CreateLargeVia, doQueueAndMark];

        MakeComm[$SetLayoutMode, LayoutModeComm];
        MakeComm[$SetSchematicMode, SchematicModeComm];

        CDPanelFonts.ImplementIt[tech: CMosB.cmosB, layerProc: CommentLayer, defaultFonts: fontNames];
        <<>>
        CDCommandOps.RegisterCommanderNewDesign[CMosB.cmosB];
        };

    CommentLayer: PROC [CD.Layer] RETURNS [CD.Layer] = {
        RETURN [CD.commentLayer];
        };

    Init[];
    END.