-- subroutines for command interpreter part of silicon (pretty picture) program
-- modified by E. McCreight, January 4, 1983  3:28 PM
-- modified by  Petit, September 22, 1981  5:44 PM

DIRECTORY
  ChipUserInt,
  InlineDefs,
  StringDefs,
  ppoutdefs,
  ppdddefs,ppddefs,
  ppdefs,
  ppMainDefs;

ppmain2: PROGRAM
  IMPORTS ChipUserInt, ppdefs, ppddefs, ppdddefs,ppoutdefs,
    StringDefs, InlineDefs, ppMainDefs
  EXPORTS ppMainDefs = PUBLIC
  BEGIN
  OPEN ppdefs, ppddefs, ppdddefs,ppoutdefs, StringDefs, InlineDefs,
    ChipUserInt, ppMainDefs;


rotCompensate:PROCEDURE[p:listPtr] RETURNS[w,l,dw,dl:INTEGER] =
    BEGIN
	switchXY:PROCEDURE=BEGIN t:INTEGER_l;l_w;w_t;t_dl;dl_dw;dw_t;END;
	reflW:PROCEDURE=BEGIN w_p.ob.size[0]-w;dw_-dw;END;
	reflL:PROCEDURE=BEGIN l_p.ob.size[1]-l;dl_-dl;END;
	l_markPnt.y-p.ly;dl_yy-markPnt.y;
	w_markPnt.x-p.lx;dw_xx-markPnt.x;
	SELECT p.idx FROM
	0,2 => BEGIN RETURN;END;
	1,3 => BEGIN reflW[];END;
	4,6 => BEGIN switchXY[];reflL[];END;
	5,7 => BEGIN switchXY[];END;
	8,10 => BEGIN reflW[];reflL[];END;
	9,11 => BEGIN reflL[];END;
	12,14 => BEGIN switchXY[];reflW[];END;
	13,15 => BEGIN switchXY[];reflW[];reflL[];END;
	ENDCASE;
    END;
findWhichWire:PUBLIC PROCEDURE [lp:listPtr] RETURNS[wNum:INTEGER,
	onTheWire:BOOLEAN,wl1,wl2,w,l,dw,dl:INTEGER] =
    BEGIN
	ob:LONG POINTER TO bus object_LOOPHOLE[lp.ob];
	[w,l,dw,dl]_rotCompensate[lp];
	onTheWire_FALSE;
	wNum_0;
	IF lp.ob.otyp#bus THEN RETURN;
	IF w>=0 THEN
	    BEGIN
		wNum_w/ob.wspace;
		IF wNum>=ob.wCnt THEN wNum_ob.wCnt-1;
	    END;
	wl1_ob.offsetFirst+wNum*ob.topIncr;
	wl2_wl1+ob.firstLength+ob.lenIncr*wNum;
	IF w>= wNum*ob.wspace AND w<= wNum*ob.wspace+ob.wwidth
		AND l >= wl1 AND l<= wl2 THEN onTheWire_TRUE;
    END;

  convToBus: cmdProc =
    BEGIN
	makeBusCmd[k,FALSE];
    END;
  convToBusDamnit: cmdProc =
    BEGIN
	makeBusCmd[k,TRUE];
    END;

makeBusCmd:PROCEDURE[k:keyEvent,damnit:BOOLEAN] =
    BEGIN
    fstl,fstw,scnd,tp,ttp: listPtr;
    fLen,wid,spc,cnt,tinc,linc,binc,i,j,fx,fy:INTEGER;
    vert,maxok:BOOLEAN_FALSE;
    l:level;
    tp_masterList;
    cnt_0;
    WHILE tp#NIL DO
	IF tp.selected THEN
	    BEGIN
		IF tp.ob.otyp#wire THEN BEGIN tp.selected_FALSE;LOOP;END;
		cnt_cnt+1;
		IF cnt=1 THEN
		    BEGIN
			fstl_tp;
			fstw_tp;
			vert_BITAND[tp.idx,4]=0;
		    END;
		IF cnt=2 THEN scnd_tp;
		IF cnt>1 THEN
		    BEGIN
			IF vert THEN
			    BEGIN
				IF BITAND[tp.idx,4]#0 THEN RETURN;
				IF tp.lx<scnd.lx THEN scnd_tp;
				IF scnd.lx<fstw.lx THEN BEGIN ttp_fstw;
					fstw_scnd;scnd_ttp;END;
			    END
			 ELSE
			    BEGIN
				IF BITAND[tp.idx,4]=0 THEN RETURN;
				IF tp.ly<scnd.ly THEN scnd_tp;
				IF scnd.ly<fstw.ly THEN BEGIN ttp_fstw;
					fstw_scnd;scnd_ttp;END;
			    END;
		    END;
	    END;
	tp_tp.nxt;
    ENDLOOP;
    IF cnt<2 THEN RETURN;
    fLen_fstw.ob.size[1];
    wid_fstw.ob.size[0];
    linc_scnd.ob.size[1]-fLen;
    fx_fstw.lx;
    fy_fstw.ly;
    l_fstw.ob.l;
    IF vert THEN
      BEGIN
	spc_scnd.lx-fx;
	tinc_scnd.ly-fy;
	binc_scnd.ly+scnd.ob.size[1]-fLen-fy;
      END
    ELSE
      BEGIN
	spc_scnd.ly-fy;
	tinc_scnd.lx-fx;
	binc_scnd.lx+scnd.ob.size[1]-fLen-fx;
      END;
    tp_fstl;
    i_0;
    IF NOT damnit THEN
      BEGIN
    WHILE i<cnt DO
	IF tp.selected THEN
	    BEGIN
		i_i+1;
		IF tp.ob.l#l THEN RETURN;
		IF tp.ob.size[0]#wid THEN RETURN;
		IF vert THEN
		    BEGIN
			j_(tp.lx-fx)/spc;
			IF j=cnt-1 THEN maxok_TRUE;
			SELECT j FROM
			0 => IF tp#fstw THEN RETURN;
			1 => IF tp#scnd THEN RETURN;
			ENDCASE => BEGIN
				IF j*spc+fx#tp.lx THEN RETURN;
				IF j*tinc#tp.ly-fy THEN RETURN;
			    END;
		    END
		 ELSE
		    BEGIN
			j_(tp.ly-fy)/spc;
			IF j=cnt-1 THEN maxok_TRUE;
			SELECT j FROM
			0 => IF tp#fstw THEN RETURN;
			1 => IF tp#scnd THEN RETURN;
			ENDCASE => BEGIN
				IF j*spc+fy#tp.ly THEN RETURN;
				IF j*tinc#tp.lx-fx THEN RETURN;
			    END;
		    END;
		IF j*linc#tp.ob.size[1]-fLen THEN RETURN;
	    END;
	tp_tp.nxt;
    ENDLOOP;
    IF NOT maxok THEN RETURN;
      END;
    flushDelSel[]; -- delete all selected things (the wires);
    IF vert THEN BEGIN IF tinc<0 THEN fy_fy+(cnt-1)*tinc;i_tinc;j_binc;END
	ELSE BEGIN IF tinc<0 THEN fx_fx+(cnt-1)*tinc;j_-tinc;i_-binc;END;
    lp _ makeList[makeBus[fLen,wid,l,cnt,spc,i,j], fx, fy, IF vert THEN 0 ELSE 2, 0];
    masterList _ insertList[masterList, lp];
    IF createSel THEN BEGIN selNewThing[masterList, lp, TRUE]; END;
    reDrawRect[getRect[lp], 1, TRUE, TRUE, FALSE];
    END;

  modParam: cmdProc =
    BEGIN
	qqq:BOOLEAN_FALSE;
	sgn:INTEGER;
	apply:PROCEDURE[pt:parmType] =
	    BEGIN
		lp_masterList;
		WHILE lp#NIL DO
		  IF lp.selected THEN []_lp.ob.p.setParm[lp,pt,sgn,1,FALSE];
		  lp_lp.nxt;
		ENDLOOP;
	    END;
	IF k.ctl=1 THEN sgn_1 ELSE sgn_-1;
	UNTIL qqq DO
	  ke_getchr[];
	  SELECT ke.k FROM
		9 => IF ke.ctl=1 THEN sgn_1 ELSE sgn_-1;-- 9
		26 => qqq_TRUE;-- Q
		12 => apply[count];-- C
		29 => apply[lSpace];-- T
		11 => apply[bSpace];-- B
		28 => apply[wSpace];-- S
	  ENDCASE;
          reDrawRect[[0, 0, 0, 0], 2, TRUE, TRUE, TRUE];
	ENDLOOP;
    dChange _ TRUE;
    END;

  doInput: cmdProc =
    BEGIN
    sss: STRING _ [40];
    ok: BOOLEAN;
    [ok, ss, ke] _ typeIn["", "Type File Name:", ""];
    IF NOT ok THEN RETURN;
    dChange _ TRUE;
    IF ss.length > 0 THEN fileName _ ss;
    sss.length _ 0;
    FOR i: CARDINAL IN [0..fileName.length) DO
      IF fileName[i] = '. THEN BEGIN fileName.length _ i; EXIT; END; ENDLOOP;
    AppendString[sss, fileName];
    AppendString[sss, ".chip"];
    IF NOT openIfile[sss] THEN RETURN;
    typeOut["", "Reading File:", sss];
    [lp, cp] _ readAll[];
    closeFile[];
    anyChanges _ TRUE;
    sinceIOchanges _ masterList # NIL;
    lpp _ lp;
    WHILE lpp # NIL DO
      lp _ lpp.nxt; masterList _ insertList[masterList, lpp]; lpp _ lp; ENDLOOP;
    cpp _ cp;
    WHILE cpp # NIL AND cpp.nxt # NIL DO cpp _ cpp.nxt; ENDLOOP;
    IF cpp # NIL THEN BEGIN cpp.nxt _ cellList; cellList _ cp; END;
    refreshTypeInScreen[];
    END;

  doOutput: cmdProc =
    BEGIN ENABLE Punt => GOTO ForgetOutput;
    sss: STRING;
    topMasterList: listPtr _ masterList;
    lp: listPtr _ masterList;
    cp: cellSEPtr _ cellStack;
    IF cellStack#NIL THEN
      BEGIN
      cp: cellSEPtr _ cellStack;
      WHILE cp.nxt#NIL DO cp _ cp.nxt ENDLOOP;
      topMasterList _ cp.lp;
      IF HeSaysYes["You're pushed down in a cell now.  Do you want the whole",
        "design anyway? (It will include perhaps some but perhaps not all of the",
        "changes you've made since pushing from the top level. (Y/N)"] THEN
          lp _ topMasterList
      ELSE IF HeSaysYes["We'll just write the current cell as the top level",
        "design, and all the named cells as well, OK?"] THEN NULL
      ELSE RETURN;
      END;
    ss _ RequestString["Enter File Name:"];
    IF ss=NIL THEN RETURN;
    IF ss.length > 0 THEN fileName _ ss;
    sss _ FixExtension[newString[fileName], ".chip"];
    IF NOT openOfile[sss, FALSE] THEN
      BEGIN
      IF NOT HeSaysYes["File Already Exists", sss, "OK to Overwrite?(Y/N):"] OR
        NOT openOfile[sss, TRUE] THEN RETURN;
      END;
    typeOut["", "Writing File:", sss];
    writeAll[lp, cellList];
    closeFile[];
    IF cellStack=NIL THEN sinceIOchanges _ FALSE;
    FreeString[sss];
    refreshTypeInScreen[];
    EXITS
      ForgetOutput => NULL;
    END;

  makeCif: cmdProc =
    BEGIN
    ok: BOOLEAN;
    [ok, ss, ke] _ typeIn["", "Type Cif File Name:", "Without extension"];
    IF NOT ok THEN RETURN;
    cifOutDrawing[ss, masterList];
    refreshTypeInScreen[];
    END;

  defCell: cmdProc =
    BEGIN
    mix, max, miy, may: INTEGER;
    backPnt: LONG POINTER TO listPtr;
    obp: obPtr;
    ok,reDef: BOOLEAN_FALSE;
    cpp:cListPtr;
    sqs:STRING_[200];
    cob:cellPtr;

    DO
      [ok, ss, ke] _ typeIn["", "Type Cell Name:", "<CR> for none"];
      IF NOT ok THEN {refreshTypeInScreen[];RETURN;};
      IF ss.length=0 OR (cpp_FindNamedCell[ss]) = NIL THEN EXIT;
	sqs.length_0;
	AppendString[sqs,"There is already a cell named "];
	AppendString[sqs,ss];
      ke _ typeInC[sqs,"Type M to make multiple cells with same name,",
		"R to redefine old one, N to try another name"];
	IF ke.k = 26B THEN EXIT;  -- M
	IF ke.k = 33B THEN {reDef_TRUE;EXIT};  -- R
    ENDLOOP;

    selCount _ 0;
    lpp _ NIL;
    lp _ masterList;
    backPnt _ @masterList;
    WHILE lp # NIL DO
      IF lp.selected THEN
        BEGIN
        ii _ IF BITAND[lp.idx, 4] = 0 THEN 0 ELSE 1;
        IF lpp = NIL THEN
          BEGIN
          mix _ lp.lx;
          max _ lp.lx + lp.ob.size[ii];
          miy _ lp.ly;
          may _ lp.ly + lp.ob.size[ii + 1];
          END
        ELSE
          BEGIN
          mix _ MIN[mix, lp.lx];
          max _ MAX[max, lp.lx + lp.ob.size[ii]];
          miy _ MIN[miy, lp.ly];
          may _ MAX[may, lp.ly + lp.ob.size[ii + 1]];
          END;
        backPnt^ _ lqp _ lp.nxt;
        lp.nxt _ lpp;
        lpp _ lp;
        lp _ lqp;
        END
      ELSE BEGIN backPnt _ @lp.nxt; lp _ lp.nxt; END;
      ENDLOOP;
    IF lpp # NIL THEN
      BEGIN
      anyChanges _ sinceIOchanges _ TRUE;
	IF reDef THEN
	    BEGIN
		obp_cob_LOOPHOLE[cpp.ob];
		flushDel[cob.ptr];
		cob.ptr _ lpp;
	    END
	 ELSE
	    BEGIN
		lqp _ makeList[obp _ makeCell
			[max - mix, may - miy, 0, lpp], mix, miy, 0, 0];
		masterList _ insertList[masterList, lqp];
		cob_LOOPHOLE[obp]
	    END;
      lqp _ lpp;
      WHILE lpp # NIL DO
        lpp.lx _ lpp.lx - mix;
        lpp.ly _ lpp.ly - miy;
        lpp.selected _ FALSE;
        lpp _ lpp.nxt;
        ENDLOOP;
      IF ss.length>0 AND NOT reDef THEN
        BEGIN
        cp _ alocCList[];
        cp.nxt _ cellList;
        cellList _ cp;
        cp.ob _ obp.p.anotherme[obp];
        obp.returnable _ FALSE;
        cp.name _ ss;
        END;
      dChange _ TRUE;
	IF reDef THEN
	    BEGIN
		cob.size[0] _ cob.size[2] _ max - mix;
		cob.size[1] _ may - miy;
		AdjustCallersBBoxes[cob];
	    END;
      END;
    END;

  getCell: cmdProc =
    BEGIN
    ok: BOOLEAN;
    [ok, ss, ke] _ typeIn["", "Type Cell Name:", ""];
    IF NOT ok THEN BEGIN refreshTypeInScreen[];RETURN;END;
    cp _ cellList;
    WHILE cp # NIL DO
      IF EqualString[cp.name, ss] THEN
        BEGIN
        anyChanges _ sinceIOchanges _ TRUE;
        lp _ makeList[cp.ob.p.anotherme[cp.ob], xx, yy, 0, 0];
        masterList _ insertList[masterList, lp];
        IF createSel THEN
          BEGIN selNewThing[masterList, lp, TRUE]; putMark[xx, yy]; END;
        reDrawRect[getRect[lp], 0, TRUE, TRUE, FALSE];
        refreshTypeInScreen[];
        EXIT;
        END;
      cp _ cp.nxt;
      ENDLOOP;
    FreeString[ss];
    END;

  selLayer: cmdProc = BEGIN favLev _ SELECT k.k FROM 1 => dif , 2 => pol , 3 => met , 4 => pdif , ENDCASE => met2; END;

  makCont: cmdProc =
    BEGIN
    anyChanges _ sinceIOchanges _ TRUE;
    IF BITAND[k.ctl,10B]=0 THEN -- no TAB held down
      BEGIN
    SELECT k.k FROM
      1 =>
        BEGIN
        lp _ makeList[makeDifcon[0], xx, yy, 0, 0];
        masterList _ insertList[masterList, lp];
        END;
      2 =>
        BEGIN
        lp _ makeList[makePolycon[0], xx, yy, 0, 0];
        masterList _ insertList[masterList, lp];
        END;
      3 =>
        BEGIN
        lp _ makeList[makeButcon[], xx, yy, basicOrientation, 0];
        masterList _ insertList[masterList, lp];
        END;
      4 =>
        BEGIN
	IF cMos THEN
	    BEGIN
        	lp_makeList[makePDifcon[0],xx,
			yy,basicOrientation,0];
        	masterList _ insertList[masterList, lp];
	    END
	  ELSE
	    BEGIN
        	lp_makeList[makeBuCont[10,8,4,2],xx,yy,basicOrientation,0];
        	masterList _ insertList[masterList, lp];
	    END;
        END;
      5 =>
        BEGIN
        lp _ makeList[makeMmCont[0,4,2], xx, yy, basicOrientation, 0];
        masterList _ insertList[masterList, lp];
        END;
      ENDCASE;

      END
     ELSE
      BEGIN
    SELECT k.k FROM
      1 =>
        BEGIN
        lp _ makeList[makeMmDifcon[0], xx, yy, 0, 0];
        masterList _ insertList[masterList, lp];
        END;
      2 =>
        BEGIN
        lp _ makeList[makeMmPolcon[0], xx, yy, 0, 0];
        masterList _ insertList[masterList, lp];
        END;
      3 =>
        BEGIN
	RETURN;-- for now
--        lp _ makeList[makeButcon[], xx, yy, basicOrientation, 0];
--        masterList _ insertList[masterList, lp];
        END;
      4 =>
        BEGIN
     	lp_makeList[makeMPDifcon[0],xx,
			yy,basicOrientation,0];
     	masterList _ insertList[masterList, lp];
        END;
      5 =>
        BEGIN
        lp _ makeList[makeMmCont[0,4,2], xx, yy, basicOrientation, 0];
        masterList _ insertList[masterList, lp];
        END;
      ENDCASE;
      END;
    IF createSel THEN
      BEGIN selNewThing[masterList, lp, TRUE]; putMark[xx, yy]; END;
    reDrawRect[getRect[lp], 0, TRUE, TRUE, FALSE];
    END;
  makWCont: cmdProc =
    BEGIN
        lp _ makeList[makeNwellcon[0], xx, yy, 0, 0];
        masterList _ insertList[masterList, lp];
    IF createSel THEN
      BEGIN selNewThing[masterList, lp, TRUE]; putMark[xx, yy]; END;
    reDrawRect[getRect[lp], 0, TRUE, TRUE, FALSE];
    END;

  doOvg: cmdProc =
    BEGIN
    sx, sy: INTEGER;
    ii: CARDINAL;
    IF NOT bb THEN RETURN;
    lp _ masterList;
    WHILE lp # NIL DO
      IF lp.ob.otyp = wire AND (lp.ob.l = met OR lp.ob.l=met2)
        AND lp.ob.p.inMe[lp.ob, xx - lp.lx, yy - lp.ly, lp.idx] THEN
        BEGIN
        ii _ IF BITAND[lp.idx, 4] = 0 THEN 0 ELSE 1;
        sx _ lp.ob.size[ii] - 16;
        sy _ lp.ob.size[ii + 1] - 16;
        IF sx < 1 OR sy < 1 THEN RETURN;
        lp _ makeList[makeRect[sx, sy, ovg], lp.lx + 8, lp.ly + 8, 0, 0];
        masterList _ insertList[masterList, lp];
        --		lp^.nxt_masterList;
        --		masterList_lp;
        reDrawRect[getRect[lp], 0, TRUE, TRUE, FALSE];
        RETURN;
        END;
      lp _ lp.nxt;
      ENDLOOP;
    END;

  doTub: cmdProc =
    BEGIN
    sx, sy: INTEGER;
    IF NOT bb THEN RETURN;
    sx_ABS[markPnt.x-xx];sy_ABS[markPnt.y-yy];
    lp _ makeList[makeRect[sx, sy, nwel],
	 MIN[markPnt.x,xx], MIN[markPnt.y,yy], 0, 0];
    masterList _ insertList[masterList, lp];
    reDrawRect[getRect[lp], 0, TRUE, TRUE, FALSE];
    END;
  doOvgR: cmdProc =
    BEGIN
    sx, sy: INTEGER;
    IF NOT bb THEN RETURN;
    sx_ABS[markPnt.x-xx];sy_ABS[markPnt.y-yy];
    lp _ makeList[makeRect[sx, sy, ovg],
	 MIN[markPnt.x,xx], MIN[markPnt.y,yy], 0, 0];
    masterList _ insertList[masterList, lp];
    reDrawRect[getRect[lp], 0, TRUE, TRUE, FALSE];
    END;
  doRectangle: cmdProc =
    BEGIN
    sx, sy: INTEGER;
    IF rectangleMode THEN
	    BEGIN
		IF NOT bb THEN RETURN;
		sx_ABS[markPnt.x-xx];sy_ABS[markPnt.y-yy];
		lp _ makeList[makeRect[sx, sy, rectLev],
			MIN[markPnt.x,xx], MIN[markPnt.y,yy], 0, 0];
		masterList _ insertList[masterList, lp];
		reDrawRect[getRect[lp], 0, TRUE, TRUE, FALSE];
	    END;
    END;
  doRepeatOb: cmdProc =
    BEGIN
	lp:listPtr_masterList;
	slp:listPtr_NIL;
	ox,oy:INTEGER;
	ok: BOOLEAN;
	x,y,cnt:INTEGER;
	ke:keyEvent;
	ob:obPtr;
	mirror:BOOLEAN;
	checkMark:keCheckProc =
	    BEGIN
		return_FALSE;
		execute_(k.k=64B OR k.k=65B OR k.k=73B);
		IF (k.k=77B AND BITAND[15,k.ctl]=1) OR k.k=56B THEN
		    {return_TRUE;execute_FALSE};
	    END;
	WHILE lp#NIL DO
	  IF lp.selected THEN {IF slp#NIL THEN --error-- RETURN;slp_lp;};
	  lp_lp.nxt;
	ENDLOOP;
	IF slp=NIL THEN RETURN;
	ox_slp.lx;
	oy_slp.ly;
	ke_CmdTwerpMess["","Mark Origin of Second Copy",
			"(upper left corner)",checkMark];
	IF ke.k=56B THEN RETURN;
        [ok, x, y] _ deScaledCursor[ke.mx, ke.my];
	IF NOT ok THEN RETURN;
	x_x-ox;
	y_y-oy;
	[ok,cnt,]_typeInNum["","Type Number of Copies",""];
	IF NOT ok THEN RETURN;
	anyChanges _ sinceIOchanges _ TRUE;
	mirror_(x<0 AND y>=0) OR (x>=0 AND y<0);
	IF x<0 THEN {ox_ox+x*(cnt-1);x_-x;};
	IF y<0 THEN {oy_oy+y*(cnt-1);y_-y;};
  	ob_makeRep[slp.ob,0,0,x,y,cnt,
		(IF mirror THEN BITXOR[slp.idx,1] ELSE slp.idx)];
	slp.lx_ox;slp.ly_oy;
	slp.ob_ob;
	slp.idx_IF mirror THEN 1 ELSE 0;
	slp.ridx_BITXOR[slp.idx,1];
	reDrawRect[getRect[slp], 1, TRUE, TRUE, FALSE];
    END;

  doBurr: cmdProc =
    BEGIN
    sx, sy, dx, dy: INTEGER;
    dw, pw: listPtr _ NIL;
    di, pi: CARDINAL _ 0;
    overFlg: BOOLEAN _ FALSE;
    IF NOT bb THEN RETURN;
    lp _ masterList;
    WHILE lp # NIL DO
      IF lp.ob.otyp = wire AND lp.ob.l = pol
        AND lp.ob.p.inMe[lp.ob, xx - lp.lx, yy - lp.ly, lp.idx] THEN
        BEGIN IF pw = NIL THEN pw _ lp ELSE overFlg _ TRUE; END;
      IF lp.ob.otyp = wire AND lp.ob.l = dif
        AND lp.ob.p.inMe[lp.ob, xx - lp.lx, yy - lp.ly, lp.idx] THEN
        BEGIN IF dw = NIL THEN dw _ lp ELSE overFlg _ TRUE; END;
      lp _ lp.nxt;
      ENDLOOP;
    IF dw = NIL OR pw = NIL THEN overFlg _ TRUE;
    IF NOT overFlg THEN
      BEGIN
      di _ IF BITAND[dw.idx, 4] = 0 THEN 0 ELSE 1;
      pi _ IF BITAND[pw.idx, 4] = 0 THEN 0 ELSE 1;
      IF di = pi THEN overFlg _ TRUE
      ELSE
        BEGIN
        IF di = 0 THEN
          BEGIN
          dx _ dw.lx - 2;
          dy _ pw.ly - 2;
          sx _ dw.ob.size[0] + 4;
          sy _ pw.ob.size[0] + 6;
          IF dy > dw.ly THEN
            BEGIN
            dy _ dy - 2;
            IF dw.ly + dw.ob.size[1] > dy + 10 THEN sy _ sy + 2;
            END;
          END
        ELSE
          BEGIN
          dx _ pw.lx - 2;
          dy _ dw.ly - 2;
          sx _ pw.ob.size[0] + 6;
          sy _ dw.ob.size[0] + 4;
          IF dx > dw.lx THEN
            BEGIN
            dx _ dx - 2;
            IF dw.lx + dw.ob.size[1] > dx + 10 THEN sx _ sx + 2;
            END;
          END;
        END;
      END;
    IF overFlg THEN BEGIN dx _ xx - 4; dy _ yy - 4; sx _ sy _ 8; END;
    lp _ makeList[makeRect[sx, sy, bur], dx, dy, 0, 0];
    masterList _ insertList[masterList, lp];
    --	lp^.nxt_masterList;
    --	masterList_lp;
    reDrawRect[getRect[lp], 0, TRUE, TRUE, FALSE];
    END;

  flushDelSel: PROCEDURE =
    BEGIN
    backPnt: LONG POINTER TO listPtr;
    lpp _ NIL;
    lp _ masterList;
    backPnt _ @masterList;
    WHILE lp # NIL DO
      IF lp.selected THEN
        BEGIN
        lp.deleted _ TRUE;
        backPnt^ _ lqp _ lp.nxt;
        lp.nxt _ lpp;
        lpp _ lp;
        lp _ lqp;
        END
      ELSE BEGIN backPnt _ @lp.nxt; lp _ lp.nxt; END;
      ENDLOOP;
    IF lpp # NIL THEN flushDel[lpp];
    END;

  delSel: cmdProc =
    BEGIN
    backPnt: LONG POINTER TO listPtr;
    lpp _ NIL;
    lp _ masterList;
    backPnt _ @masterList;
    WHILE lp # NIL DO
      IF lp.selected THEN
        BEGIN
        lp.deleted _ TRUE;
        backPnt^ _ lqp _ lp.nxt;
        lp.nxt _ lpp;
        lpp _ lp;
        lp _ lqp;
        END
      ELSE BEGIN backPnt _ @lp.nxt; lp _ lp.nxt; END;
      ENDLOOP;
    IF lpp # NIL THEN doTheDelete[lpp];
    END;

  delPnt: cmdProc =
    BEGIN
    backPnt: LONG POINTER TO listPtr;
    lpp _ NIL;
    lp _ masterList;
    backPnt _ @masterList;
    WHILE lp # NIL DO
      IF lp.ob.p.inMe[lp.ob, xx - lp.lx, yy - lp.ly, lp.idx] THEN
        BEGIN
        lp.deleted _ TRUE;
        backPnt^ _ lqp _ lp.nxt;
        lp.nxt _ lpp;
        lpp _ lp;
        lp _ lqp;
        EXIT;
        END
      ELSE BEGIN backPnt _ @lp.nxt; lp _ lp.nxt; END;
      ENDLOOP;
    IF lpp # NIL THEN doTheDelete[lpp];
    END;

  doTheDelete: PROCEDURE [lpp: listPtr] =
    BEGIN
    jj,ii:INTEGER;
    anyChanges _ sinceIOchanges _ TRUE;
    IF (unDelGrpCnt >= unDelGrpMax AND unDelItemCnt >= unDelItemMin)
      OR unDelItemCnt >= unDelItemMax THEN flushOne[];
    jj _ 0;
    ii _ IF unDelPnt = NIL THEN 0 ELSE 1 - unDelPnt.mark;
    lp _ lpp;
    WHILE lp.nxt # NIL DO
      lp.mark _ ii;
      reDrawRect[getRect[lp], 3, TRUE, TRUE, FALSE];
      IF lp.selected THEN selCount _ selCount - 1;
      lp _ lp.nxt;
      jj _ jj + 1;
      ENDLOOP;
    reDrawRect[getRect[lp], 3, TRUE, TRUE, FALSE];
    IF lp.selected THEN selCount _ selCount - 1;
    lp.mark _ ii;
    lp.nxt _ unDelPnt;
    unDelPnt _ lpp;
    unDelGrpCnt _ unDelGrpCnt + 1;
    unDelItemCnt _ unDelItemCnt + jj + 1;
    IF unDelItemCnt >= unDelItemMax THEN flushOne[];
    END;
  flushOne: PROCEDURE =
    BEGIN
    jj:INTEGER;
    ii:CARDINAL;
    jj _ 0;
    lp _ unDelPnt;
    IF lp = NIL THEN BEGIN unDelGrpCnt _ unDelItemCnt _ 0; RETURN; END;
    FOR ii IN [2..unDelGrpCnt] DO
      WHILE lp.nxt # NIL AND lp.mark = lp.nxt.mark DO
        lp _ lp.nxt; jj _ jj + 1; ENDLOOP;
      IF ii # unDelGrpCnt AND lp.nxt # NIL THEN
        BEGIN lp _ lp.nxt; jj _ jj + 1; END;
      ENDLOOP;
    flushDel[lp.nxt];
    lp.nxt _ NIL;
    unDelGrpCnt _ unDelGrpCnt - 1;
    unDelItemCnt _ jj + 1;
    END;


  doWidenSel: cmdProc = BEGIN doParmSel[width, FALSE, TRUE, lambdaGrid, 1]; END;
  doWidenPnt: cmdProc =
    BEGIN
    IF NOT bb THEN RETURN;
    doParmPnt[width, FALSE, TRUE, lambdaGrid, 1];
    END;
  doNarwSel: cmdProc = BEGIN doParmSel[width, TRUE, FALSE, -lambdaGrid, 1]; END;
  doNarwPnt: cmdProc =
    BEGIN
    IF NOT bb THEN RETURN;
    doParmPnt[width, TRUE, FALSE, -lambdaGrid, 1];
    END;
  doDefaultSel: cmdProc = BEGIN doParmSel[default, TRUE, TRUE, 0, 0]; END;
  doDefaultPnt: cmdProc =
    BEGIN IF NOT bb THEN RETURN; doParmPnt[default, TRUE, TRUE, 0, 0]; END;
  doLenSel: cmdProc = BEGIN doParmSel[length, FALSE, TRUE, lambdaGrid, 1]; END;
  doLenPnt: cmdProc =
    BEGIN
    IF NOT bb THEN RETURN;
    doParmPnt[length, FALSE, TRUE, lambdaGrid, 1];
    END;
  doShrtSel: cmdProc =
    BEGIN
	IF wiring AND busMaking THEN
	    BEGIN
		bmNews_IF BITAND[k.ctl,20B]=0 THEN bmNews+lambdaGrid ELSE
			MAX[0,bmNews-lambdaGrid];
		setBusParms[FALSE];
		RETURN;
	    END;
	doParmSel[length, TRUE, FALSE, -lambdaGrid, 1];
    END;
  doShrtPnt: cmdProc =
    BEGIN
    IF NOT bb THEN RETURN;
    doParmPnt[length, TRUE, FALSE, -lambdaGrid, 1];
    END;

  doParmSel: PROCEDURE [
    typ: parmType, earlyRect, lateRect: BOOLEAN, dx, dy: INTEGER] =
    BEGIN
    r: Rect;
    lp _ masterList;
    WHILE lp # NIL DO
      IF lp.selected THEN
        BEGIN
        IF earlyRect THEN r _ getRect[lp];
        IF lp.ob.p.setParm[lp, typ, dx, dy, TRUE] THEN
          BEGIN
          anyChanges _ sinceIOchanges _ TRUE;
          IF lateRect THEN
            r _ (IF earlyRect THEN mergeRects[getRect[lp], r] ELSE getRect[lp]);
          reDrawRect[r, 1, TRUE, TRUE, FALSE];
          END;
        END;
      lp _ lp.nxt;
      ENDLOOP;
    END;
  doParmPnt: PROCEDURE [
    typ: parmType, earlyRect, lateRect: BOOLEAN, dx, dy: INTEGER] =
    BEGIN
    r: Rect;
    IF NOT bb THEN RETURN;
    lp _ masterList;
    WHILE lp # NIL DO
      IF lp.ob.p.inMe[lp.ob, xx - lp.lx, yy - lp.ly, lp.idx] THEN
        BEGIN
        IF earlyRect THEN r _ getRect[lp];
        IF lp.ob.p.setParm[lp, typ, dx, dy, TRUE] THEN
          BEGIN
          anyChanges _ sinceIOchanges _ TRUE;
          IF lateRect THEN
            r _ (IF earlyRect THEN mergeRects[getRect[lp], r] ELSE getRect[lp]);
          reDrawRect[r, 1, TRUE, TRUE, FALSE];
          END;
        END;
      lp _ lp.nxt;
      ENDLOOP;
    END;

  setBusParms: PROCEDURE [big: BOOLEAN] =
    BEGIN
    x, y, ww,wd,offs, sx,sy,corn: INTEGER;
    wd _ minWidthAr[wiringLev];
    ww _ (wd*cScaleN)/cScaleD;
    offs_((wd+lambdaGrid)/(2*lambdaGrid))*lambdaGrid;
    offs _ (offs*cScaleN)/cScaleD;
--    [, x, y, , ] _ cscaleRect[wclNx, wclNy, cClipx2 - 2, cClipy2 - 2];
    x_((cxoff+wclNx)*cScaleN)/cScaleD;
    y_((cyoff+wclNy)*cScaleN)/cScaleD;
    sx_(bm2dx*cScaleN)/cScaleD;
    sy_(bm2dy*cScaleN)/cScaleD;
    corn_(bmNews*cScaleN)/cScaleD;
    setupTempBus[[x,y],wiringOrn,wiringLev,ww,offs,big,sx,sy,corn,bmCount];
    END;


  END.