--Cells6.mesa

--The example for naming wires is in ppprocs2.mesa, PROC=enterText:

DIRECTORY
  IODefs: FROM "IODefs",
  InlineDefs,
  ppdddefs,
  ppddefs,
  ppdefs,
  CellsDefs: FROM "CellsDefs";

Cells6:PROGRAM
 IMPORTS IODefs, InlineDefs, CellsDefs, ppdefs, ppddefs, ppdddefs
 EXPORTS CellsDefs=BEGIN OPEN CellsDefs;

Error:SIGNAL=CODE;
int:INTEGER=1;

max:INTEGER=13;
Everything:TYPE=RECORD[col,row,realName:INTEGER,term:ARRAY [0..max) OF Term];
nullEverything:Everything=[-1,-1,-1,ALL[[none,0,0,0]]];
Term:TYPE=RECORD[kind:Kind,r,g:Signal,off:INTEGER];
Kind:TYPE={none,nUp,nDn,pGn,pRd}; --labels what I am
Signal:TYPE=INTEGER;
dataType:TYPE=ARRAY [0..signalMax) OF Everything;
data:LONG POINTER TO dataType;
trueColumnType:TYPE=ARRAY [0..signalMax) OF INTEGER;
trueColumn:LONG POINTER TO trueColumnType;

SetEverything:PROCEDURE=BEGIN
npu:INTEGER;
data^_ALL[nullEverything];
FOR s:INTEGER IN [0..signalMax) DO data[s].realName_s; ENDLOOP;
FOR s:INTEGER IN [8..signalMax) DO
  npu_-1;
  FOR z:TList_sig[s].def, z.next UNTIL z=NIL DO
    IF z.s.type = wire THEN
       {IF z.s.e#int THEN npu_z.s.e ELSE
              IF npu=-1 THEN Error ELSE data[z.s.d].realName_npu};
      ENDLOOP;
  ENDLOOP;
FOR s:INTEGER IN [8..signalMax) DO
  npu_-1;
  FOR z:TList_sig[s].def, z.next UNTIL z=NIL DO
    SELECT z.s.type FROM
        norPullUp=>npu_z.s.e;
        norPullDown=>{Set[npu,nUp,z.s.d,0]; Set[z.s.d,nDn,npu,0]};
        pass1=>{Set[z.s.e,pGn,z.s.d,z.s.g]; Set[z.s.d,pRd,z.s.e,z.s.g];
                Set[z.s.g,pGn,z.s.d,z.s.e]};
        ENDCASE;
      ENDLOOP;
  ENDLOOP;
EnumerateColumns[MarkIt];
FOR s:INTEGER IN [8..signalMax) DO
  ok:BOOLEAN_FALSE;
  c:INTEGER_sig[s].columnNum;
  IF data[s].col=-1 OR c=-1 THEN LOOP;
  FOR j:INTEGER IN Track DO IF track[c][j]='S THEN data[s].row_j; ENDLOOP;
  IF data[s].row=-1 THEN LOOP;
  FOR k:INTEGER IN [0..max) DO
    SELECT data[s].term[k].kind FROM none=>EXIT; pGn,nUp=>ok_TRUE; ENDCASE;
    ENDLOOP;
  IF ~ok THEN {--IF stop THEN Error;-- data[s].row_-1};
  ENDLOOP;
columnEnd_topTrack_0;
FOR s:INTEGER IN [8..signalMax) DO
  IF data[s].col=-1 THEN LOOP;
  columnEnd_MAX[columnEnd,data[s].col];
  topTrack_MAX[topTrack,data[s].row];
  ENDLOOP;
FOR s:INTEGER IN [8..signalMax) DO
  IF data[s].col=-1 THEN LOOP;
  FOR k:INTEGER IN [0..max) DO
    t:Term=data[s].term[k];
    SELECT t.kind FROM
      none=>EXIT;
      nUp,nDn=>data[s].term[k].r_ data[t.r].realName;
      pGn,pRd=>data[s].term[k]
                  _[t.kind,data[t.r].realName,data[t.g].realName,0];
      ENDCASE=>Error;
    ENDLOOP;
  ENDLOOP;
trueColumn^_ALL[-1];
FOR s:INTEGER IN [8..signalMax)
  DO c:INTEGER_data[s].col; IF c#-1 THEN trueColumn[c]_s; ENDLOOP;
FOR c:INTEGER IN [0..columnEnd] DO IF c=-1 THEN Error; ENDLOOP;
END;

MarkIt:PROCEDURE[c,s,z:INTEGER]=
  {IF data[s].realName#s THEN Error; data[s].col_z};

Set:PROCEDURE[i:INTEGER,z:Kind,j,k:INTEGER]=BEGIN
i_data[i].realName; j_data[j].realName; k_data[k].realName;
FOR t:INTEGER IN [0..max) DO
  IF data[i].term[t].kind=none THEN {data[i].term[t]_[z,j,k,0]; RETURN};
  ENDLOOP;
Error;--parameter "max" too small
END;

Showtrack:PUBLIC PROCEDURE=BEGIN
done_second_FALSE;
SetEverything[];
SortTerms[];
MakeOff[];
Fudge[];
topX_topTrack*7+base+4+4;
IF chip THEN BEGIN
  ok: BOOLEAN;
  ULAName: STRING _ NIL;
  [ok, ULAName, ] _ ppdefs.typeIn[""L, ""L, "Name of completed ULA cell:"L];
  ShowASection[0,0];
  DrawCell[MakeNewCell[ULAName, lpp].ob];
  ULAName _ NIL;  -- we gave the name to the cell
  RETURN;
  END;
FOR j:INTEGER_0, j+yMax UNTIL j>=colly[columnEnd]+16 DO ShowASection[4,j]; ENDLOOP;
END;

ShowASection:PROCEDURE[x,y:INTEGER]=BEGIN
grid_ALL[ALL[EmptyGrid]];
lowerLeftX_x; lowerLeftY_y;
BlueWires[];
RedWires[];
Transistors[];
GroundWires[];
Pullups[];
Contacts[];
PrintGrid[];
PowerAndGround[];
END;

colly:ARRAY [0..columnMax) OF INTEGER;

--Fudge:PROCEDURE=BEGIN
--FOR i:INTEGER IN [0..columnMax) DO colly[i]_8*i; ENDLOOP;
--END;


Fudge:PROCEDURE=BEGIN
second:BOOLEAN_FALSE;
colly[0]_0;
FOR i:INTEGER IN [0..columnEnd-1] DO
  found,foundP:BOOLEAN_FALSE;
  s:INTEGER_trueColumn[i];
  ss:INTEGER_trueColumn[i+1];
  w:INTEGER_1;
  FOR k:INTEGER IN [0..max) DO
    SELECT data[s].term[k].kind FROM none=>EXIT; nUp=>found_TRUE; ENDCASE;
    ENDLOOP;
  FOR k:INTEGER IN [0..max) DO
    SELECT data[ss].term[k].kind FROM none=>EXIT; nUp=>foundP_TRUE; ENDCASE;
    ENDLOOP;
  SELECT TRUE FROM
     ~found => second_FALSE;
     ~second => second_TRUE;
     ~foundP=> NULL;
     ENDCASE=>{w_2; second_FALSE};
  IF i MOD 2 =0 THEN FOR k:INTEGER IN [0..max) DO
    t:Term_data[s].term[k];
    gnd:BOOLEAN_t.kind=nDn;
    r,z:INTEGER;
    SELECT t.kind FROM
      nDn=>{r_data[t.r].row; z_10000};
      pRd=>{r_MIN[data[t.r].row,data[t.g].row]; z_MAX[data[t.r].row,data[t.g].row]};
      ENDCASE=>EXIT;
    w_MAX[w,t.off];
    FOR l:INTEGER IN [0..max) DO
      tt:Term=data[ss].term[l];
      SELECT tt.kind FROM
        nDn=>IF gnd OR z<data[tt.r].row THEN LOOP;
        pRd=>IF z<MIN[data[tt.r].row,data[tt.g].row]
             OR r>MAX[data[tt.r].row,data[tt.g].row] THEN  LOOP;
        ENDCASE=>EXIT;
        w_MAX[w,t.off+tt.off];
      ENDLOOP;
    ENDLOOP;
  colly[i+1]_colly[i]+8*w;
  ENDLOOP;
END;

SortTerms:PROCEDURE=BEGIN
FOR s:INTEGER IN [8..signalMax) DO
  IF data[s].col=-1 THEN LOOP;
  FOR k:INTEGER IN [0..max) DO
    t:Term_data[s].term[k];
    r:INTEGER;
    SELECT t.kind FROM
      none=>EXIT;
      nDn=>r_data[t.r].row;
      pRd=>r_MIN[data[t.r].row,data[t.g].row];
      ENDCASE=>r_-1;
    FOR l:INTEGER IN (k..max) DO
      tt:Term=data[s].term[l];
      rr:INTEGER;
      SELECT tt.kind FROM
        none=>EXIT;
        nDn=>rr_data[tt.r].row;
        pRd=>rr_MIN[data[tt.r].row,data[tt.g].row];
        ENDCASE=>rr_-1;
      IF rr>r THEN {data[s].term[l]_t; data[s].term[k]_t_tt; r_rr};
      ENDLOOP;
    ENDLOOP;
  ENDLOOP;
END;

MakeOff:PROCEDURE=BEGIN
FOR s:INTEGER IN [8..signalMax) DO
  IF data[s].col=-1 THEN LOOP;
  FOR k:INTEGER IN [0..max) DO
    t:Term=data[s].term[k];
    off:INTEGER_1;
    r:INTEGER;
    SELECT t.kind FROM
      nDn=>r_10000;
      pRd=>r_MAX[data[t.r].row,data[t.g].row];
      ENDCASE=>EXIT;
    FOR l:INTEGER IN [0..k) DO
      tt:Term=data[s].term[l];
      rr:INTEGER;
      SELECT tt.kind FROM
        nDn=>rr_data[tt.r].row;
        pRd=>rr_MIN[data[tt.r].row,data[tt.g].row];
        ENDCASE=>EXIT;
      IF r<rr THEN EXIT;
      IF r=10000 AND tt.kind=nDn THEN off_MAX[off,tt.off]
                    ELSE off_MAX[off,tt.off+1];
      ENDLOOP;
    data[s].term[k].off_off;
    ENDLOOP;
  ENDLOOP;
FOR s:INTEGER IN [8..signalMax) DO
  IF data[s].col=-1 THEN LOOP;
  FOR k:INTEGER IN [0..max) DO t:Term=data[s].term[k];
    ss:INTEGER_t.r;
    SELECT t.kind FROM
      nDn=>FOR j:INTEGER IN [0..max) DO tt:Term=data[ss].term[j];
          IF tt.kind=nUp AND tt.r=s THEN {data[ss].term[j].off_t.off; EXIT};
          ENDLOOP;
      pRd=>BEGIN
        FOR j:INTEGER IN [0..max) DO tt:Term=data[ss].term[j];
          IF tt.kind=pGn AND tt.r=s THEN {data[ss].term[j].off_t.off; EXIT};
          ENDLOOP;
        ss_t.g;
        FOR j:INTEGER IN [0..max) DO tt:Term=data[ss].term[j];
          IF tt.kind=pGn AND tt.r=s THEN {data[ss].term[j].off_t.off; EXIT};
          ENDLOOP;
        END;
      ENDCASE=>EXIT;
    ENDLOOP;
  ENDLOOP;
END;

PowerAndGround:PROCEDURE=BEGIN
BlueWire[0,0,4,colly[columnEnd]+10];
AssignName[savedThis,"VDD"];
BlueWire[topX,0,topX+4,colly[columnEnd]+10];
AssignName[savedThis,"GND"];
END;

BlueWires:PROCEDURE=BEGIN
c,x,yLo,yHi,qy:INTEGER;
FOR i:INTEGER IN [8..signalMax) DO
  wierd:BOOLEAN_FALSE;
  IF data[i].col=-1 THEN LOOP;
  c_data[i].col;
  yHi_yLo_colly[c]+1;
  FOR k:INTEGER IN [0..max) DO
    t:Term=data[i].term[k];
    q:INTEGER_data[t.r].col;
    qEven:BOOLEAN= q MOD 2 = 0;
    up:BOOLEAN;
    SELECT t.kind FROM
      none=>EXIT;
      nDn,pRd=>LOOP;
      nUp=>up_ ~qEven;
      pGn=>up_ SELECT data[i].row-data[t.g].row FROM
           >0=>qEven, 0=>c>q, ENDCASE=>~qEven;
      ENDCASE=>Error;
    qy_colly[q]+(IF up THEN 7 ELSE -1);
    IF up=qEven THEN
      {qy_IF up THEN qy+8*(t.off-1) ELSE qy-8*(t.off-1); wierd_TRUE};
    yHi_MAX[yHi,qy-4];
    yLo_MIN[yLo,qy];
    ENDLOOP;
  x_base+data[i].row*7+1;
  IF wierd OR yHi-yLo>4 THEN BlueWire[x,yLo,x+3,yHi]
  ENDLOOP;
END;

signalName:INTEGER_-1;

RedWires:PROCEDURE=BEGIN
q,maxR,minR:INTEGER;
y,xLo,xHi:INTEGER;
pull:BOOLEAN;
FOR i:INTEGER IN [8..signalMax) DO
  c:INTEGER=data[i].col;  r:INTEGER=data[i].row;
  IF c=-1 THEN LOOP;
  signalName_i;
  y_colly[c];
  IF r=-1 THEN {RedWire[0,y,topX+4,y+2]; LOOP};
  q_maxR_minR_r;
  pull_FALSE;
  FOR k:INTEGER IN [0..max) DO
    t:Term=data[i].term[k];
    SELECT t.kind FROM
      none=>EXIT;
      nUp=>{pull_TRUE; LOOP};
      nDn=>q_data[t.r].row;
      pGn=>LOOP;
      pRd=>q_MIN[data[t.r].row,data[t.g].row];
      ENDCASE=>Error;
    IF q<0 THEN Error;
    maxR_MAX[maxR,q];
    minR_MIN[minR,q];
    ENDLOOP;
  xHi_base+maxR*7+4;
  xLo_IF pull THEN base-2 ELSE base+minR*7;
  IF xHi-xLo<=4 THEN RedWire[0,y,topX+4,y+2] ELSE RedWire[xLo,y,xHi,y+2]
  ENDLOOP;
END;

Transistors:PROCEDURE=BEGIN
q:INTEGER;
y:INTEGER;
FOR i:INTEGER IN [8..signalMax) DO
  c:INTEGER=data[i].col;  r:INTEGER=data[i].row;
  IF c=-1 THEN LOOP;
  y_colly[c];
  FOR k:INTEGER IN [0..max) DO
    t:Term=data[i].term[k];
    SELECT t.kind FROM
      none=>EXIT;
      nUp=>LOOP;
      nDn=>q_data[t.r].row;
      pGn=>LOOP;
      pRd=>q_MIN[data[t.r].row,data[t.g].row];
      ENDCASE=>Error;
    IF q<0 THEN Error;
    Transistor[base+q*7,y];
    ENDLOOP;
  ENDLOOP;
END;

GroundWires:PROCEDURE=BEGIN
y:INTEGER;
FOR c:INTEGER IN [0..columnMax) DO
  i:INTEGER_trueColumn[c];
  IF i<8 THEN LOOP;
  y_colly[c]+(IF c MOD 2 = 0 THEN 3 ELSE -5);
  FOR k:INTEGER IN [0..max) DO
    t:Term=data[i].term[k];
    yy:INTEGER_y+8*(IF c MOD 2 = 0 THEN t.off-1 ELSE -t.off+1);
    r1:INTEGER_data[t.r].row;
    r2:INTEGER_data[t.g].row;
    minX,maxX:INTEGER;
    SELECT t.kind FROM
      none=>EXIT;
      nUp=>LOOP;
      nDn=>{minX_base+r1*7; maxX_topX};
      pGn=>LOOP;
      pRd=>{minX_base+MIN[r1,r2]*7; maxX_base+MAX[r1,r2]*7};
      ENDCASE=>Error;
    GreenWire[minX,yy,maxX,yy+4];
    GreenBlueContact[maxX,yy];
    IF t.off=1 THEN LOOP;
    IF c MOD 2 = 0 THEN GreenWire[minX,y,minX+4,yy]
                   ELSE GreenWire[minX,yy+4,minX+4,y+4];
    ENDLOOP;
  ENDLOOP;
END;

Pullups:PROCEDURE=BEGIN
edge:INTEGER_5;
second:BOOLEAN_FALSE;
FOR c:INTEGER IN [0..columnMax) DO
  found:BOOLEAN_FALSE;
  i:INTEGER_trueColumn[c];
  y:INTEGER_colly[c];
  IF i<8 THEN LOOP;
  FOR k:INTEGER IN [0..max) DO
    SELECT data[i].term[k].kind FROM
      none=>EXIT;
      nUp=>{found_TRUE; EXIT};
      ENDCASE;
    ENDLOOP;
  IF found AND  second THEN Pullup2[edge,y];
  IF found AND ~second THEN
    {Pullup1[edge,y]; GreenWire[0,y+4,edge+5,y+6]; GreenBlueContact[0,y+3]};
  second_found AND ~second;
  ENDLOOP;
END;

Contacts:PROCEDURE=BEGIN
FOR i:INTEGER IN [8..signalMax) DO
  c:INTEGER=data[i].col;  r:INTEGER=data[i].row;
  IF ~(c=-1 OR r=-1) THEN BEGIN
  even:BOOLEAN=c MOD 2 = 0;
  done:BOOLEAN_FALSE;
  y:INTEGER=colly[c];
  x:INTEGER=base+r*7;
  FOR k:INTEGER IN [0..max) DO
    t:Term=data[i].term[k];
    q:INTEGER=data[t.r].col;
    qEven:BOOLEAN=q MOD 2 = 0;
    yk:INTEGER=IF q=-1 THEN 0 ELSE colly[q];
    rowOffset:INTEGER=data[i].row-data[t.g].row;
    SignalChannel:PROCEDURE=BEGIN
       IF ~qEven AND q#c-1 THEN {GreenBlueContact[x,yk+3]; RETURN};
       IF  qEven AND q#c+1 THEN {GreenBlueContact[x,yk-5]; RETURN};
       IF even THEN ThreeWay2[x,y-5] ELSE ThreeWay1[x,y+1];
       IF even
         THEN {IF y#colly[c-1]+8 THEN GreenWire[x,colly[c-1]+3,x+4,y-5]}
         ELSE {IF y#colly[c+1]-8 THEN GreenWire[x,y+7,x+4,colly[c+1]-1]};
       done_TRUE;
       END;
    FindOffset:PROCEDURE RETURNS[off:INTEGER]=BEGIN
      FOR kk:INTEGER IN [0..max) DO
        tTerm:Term_data[t.r].term[kk];
        SELECT tTerm.kind FROM
                 nUp,pGn,none=>EXIT;
                 pRd=>IF tTerm.r=t.g AND tTerm.g=i
                         OR tTerm.r=i AND tTerm.g=t.g
                         THEN {off_tTerm.off; RETURN};
                 ENDCASE;
        ENDLOOP;
      RETURN[1];
      END;
    SELECT t.kind FROM
      none=>EXIT;
      nUp=>SignalChannel[];
      nDn=>NULL;
      pGn=>IF rowOffset>0 OR rowOffset=0 AND (c>q)=qEven
          THEN BEGIN
             offY:INTEGER_8*(FindOffset[]-1);
             yy:INTEGER=IF qEven THEN 3+offY ELSE -5-offY;
             GreenBlueContact[x,yk+yy];
             END
          ELSE SignalChannel[];
      pRd=>NULL;
      ENDCASE=>Error;
    ENDLOOP;
  IF ~done THEN RedBlueContact[x,y-(IF even THEN 2 ELSE 0)];
  END; ENDLOOP;
END;



lowerLeftX,lowerLeftY:INTEGER;
yMax:INTEGER=40;
xMax:INTEGER=64;
grid:ARRAY [0..yMax) OF PACKED ARRAY [0..xMax) OF Grid;
Grid:TYPE=RECORD [r,b,g,x:YesNo];
EmptyGrid:Grid=[n,n,n,n];
YesNo:TYPE={y,n};
done,second:BOOLEAN;
base:INTEGER=14;
topX,topTrack,columnEnd:INTEGER; 

Pullup1:PROCEDURE[x,y:INTEGER]=BEGIN
IF chip THEN
   lpp _ ppddefs.insertList[lpp, ppdddefs.makeList[ppdddefs.makePullup[4,8], (x+1)*2, (y-5)*2, 4, 0]];
ShowRecD[red,x,y-2,8,4];
ShowRecD[green,x+2,y-5,4,3];
ShowRecD[x,x+3,y-4,2,4];
ShowRecD[green,x+3,y+2,2,2];
END;

Pullup2:PROCEDURE[x,y:INTEGER]=BEGIN
IF chip THEN
  lpp _ ppddefs.insertList[lpp, ppdddefs.makeList[ppdddefs.makePullup[4,8], (x+1)*2, (y-2)*2, 0, 0]];
ShowRecD[red,x,y,8,4];
ShowRecD[green,x+2,y+4,4,3];
ShowRecD[x,x+3,y+2,2,4];
ShowRecD[green,x+3,y-2,2,2];
END;

ThreeWay1:PROCEDURE[x,y:INTEGER]=BEGIN
IF chip THEN
  lpp _ ppddefs.insertList[lpp, ppdddefs.makeList[ppdddefs.makeButcon[], x*2, (y)*2, 0, 0]];
ShowRecD[blue,x,y,4,6];
ShowRecD[red,x,y,4,3];
ShowRecD[green,x,y+3,4,3];
ShowRecD[x,x+1,y+1,2,4];
END;

ThreeWay2:PROCEDURE[x,y:INTEGER]=BEGIN
IF chip THEN
  lpp _ ppddefs.insertList[lpp, ppdddefs.makeList[ppdddefs.makeButcon[], x*2, (y)*2, 4, 0]];
ShowRecD[blue,x,y,4,6];
ShowRecD[green,x,y,4,3];
ShowRecD[red,x,y+3,4,3];
ShowRecD[x,x+1,y+1,2,4];
END;

RedBlueContact:PROCEDURE[x,y:INTEGER]=BEGIN
IF chip THEN
  lpp _ ppddefs.insertList[lpp, ppdddefs.makeList[ppdddefs.makePolycon[4], x*2, (y)*2, 0, 0]];
ShowRecD[blue,x,y,4,4];
ShowRecD[red,x,y,4,4];
ShowRecD[x,x+1,y+1,2,2];
END;

GreenBlueContact:PROCEDURE[x,y:INTEGER]=BEGIN
IF chip THEN
  lpp _ ppddefs.insertList[lpp, ppdddefs.makeList[ppdddefs.makeDifcon[4], x*2, (y)*2, 0, 0]];
ShowRecD[blue,x,y,4,4];
ShowRecD[green,x,y,4,4];
ShowRecD[x,x+1,y+1,2,2];
END;

Transistor:PROCEDURE[x,y:INTEGER]=BEGIN
IF chip THEN
  lpp _ ppddefs.insertList[lpp, ppdddefs.makeList[ppdddefs.makeXstr[8,4], (x-2)*2, (y-2)*2, 0, 0]];
ShowRecD[red,x-2,y,8,2];
ShowRecD[green,x,y-2,4,6];
END;
savedThis:LONG POINTER TO ppdefs.list_NIL;

ChipWire:PROCEDURE[c:Color,x1,y1,x2,y2:INTEGER]=BEGIN
OPEN ppdefs, ppddefs, ppdddefs;
IF ~chip THEN RETURN ELSE BEGIN
myLevel:level=SELECT c FROM green=>dif,red=>pol, ENDCASE=>met;
deltaX:INTEGER=ABS[x2-x1];
deltaY:INTEGER=ABS[y2-y1];
orient:INTEGER=IF deltaX > deltaY THEN 2 ELSE 0;
l:INTEGER=2*(IF deltaX > deltaY THEN deltaX ELSE deltaY);
w:INTEGER=2*(IF deltaX > deltaY THEN deltaY ELSE deltaX);
this:LONG POINTER TO list_makeList[makeWire[l,w,myLevel],2*x1,2*y1,orient,0];
savedThis_this;
lpp _ insertList[lpp,this];
IF c=red AND signalName#-1 THEN AssignName[this,Lookup2[signalName]];
END; END;

AssignName:PROCEDURE[this:LONG POINTER TO ppdefs.list,s:STRING]=BEGIN
OPEN ppdefs, ppddefs, ppdddefs;
IF chip THEN BEGIN
putProp[lp:this, attribute:MakeAtom["SIGNAL NAME"L], value:MakeAtom[s]];
END; END;

GreenWire:PROCEDURE[x1,y1,x2,y2:INTEGER]=
     {ChipWire[green,x1,y1,x2,y2]; ShowRec[green,x1,y1,x2,y2]};

RedWire:  PROCEDURE[x1,y1,x2,y2:INTEGER]=
     {ChipWire[red,x1,y1,x2,y2]; ShowRec[red,x1,y1,x2,y2]};

BlueWire: PROCEDURE[x1,y1,x2,y2:INTEGER]=
     {ChipWire[blue,x1,y1,x2,y2]; ShowRec[blue,x1,y1,x2,y2]};


Color:TYPE={red,blue,green,x};

ShowRecD:PROCEDURE[color:Color,x1,y1,x2,y2:INTEGER]=
   {ShowRec[color,x1,y1,x1+x2,y1+y2]};

ShowRec:PROCEDURE[color:Color,x1,y1,x2,y2:INTEGER]=BEGIN
IF chip THEN RETURN;
x1_MAX[x1-lowerLeftX,0]; y1_MAX[y1-lowerLeftY,0];
x2_MIN[x2-lowerLeftX,xMax]; y2_MIN[y2-lowerLeftY,yMax];
IF ~(x1<x2 AND y1<y2) THEN RETURN;
FOR i:INTEGER IN [x1..x2) DO
  FOR j:INTEGER IN [y1..y2) DO
      SELECT color FROM
        blue => grid[j][i].b_y; 
         red => grid[j][i].r_y; 
       green => grid[j][i].g_y; 
       ENDCASE => grid[j][i].x_y; 
    ENDLOOP;
  ENDLOOP;
END;

PrintGrid:PROCEDURE=BEGIN
IF chip OR ~printPlot THEN RETURN;
FOR j:INTEGER IN [0..yMax) DO
IODefs.WriteChar[Ret]; 
  FOR i:INTEGER IN [0..xMax) DO
    IF grid[j][i].x=y THEN IODefs.WriteChar['x]
       ELSE SELECT grid[j][i] FROM
        [n,n,n,n] => IODefs.WriteChar[Space]; 
        [n,n,y,n] => IODefs.WriteChar['g]; 
        [n,y,n,n] => IODefs.WriteChar['B]; 
        [n,y,y,n] => IODefs.WriteChar['G]; 
        [y,n,n,n] => IODefs.WriteChar['r]; 
        [y,n,y,n] => IODefs.WriteChar['t]; 
        [y,y,n,n] => IODefs.WriteChar['R]; 
        [y,y,y,n] => IODefs.WriteChar['T]; 
       ENDCASE => IODefs.WriteChar['?]; 
    ENDLOOP;
  ENDLOOP;
END;

lpp: LONG POINTER TO ppdefs.list _ NIL;  -- list of cells already placed

MakeNewCell: PROCEDURE [name: STRING, lpp: LONG POINTER TO ppdefs.list]
    RETURNS [cp: LONG POINTER TO ppdefs.cList] =
    BEGIN OPEN ppdefs, ppddefs, ppdddefs;
    min: Point _ [LAST[locNum], LAST[locNum]];
    max: Point _ [FIRST[locNum], FIRST[locNum]];
    FOR lp: LONG POINTER TO list _ lpp, lp.nxt WHILE lp # NIL DO
      ii: [0..1] _ IF InlineDefs.BITAND[lp.idx, 4] = 0 THEN 0 ELSE 1;
      min _ [MIN[min.x, lp.lx], MIN[min.y, lp.ly]];
      max _ [
        MAX[max.x, lp.lx + lp.ob.size[ii]], MAX[
        max.y, lp.ly + lp.ob.size[ii + 1]]];
      ENDLOOP;
    FOR lp: LONG POINTER TO list _ lpp, lp.nxt WHILE lp # NIL DO
      lp.lx _ lp.lx - min.x; lp.ly _ lp.ly - min.y; lp.selected _ FALSE; ENDLOOP;
    cp _ alocCList[];
    cp.nxt _ cellList;
    cellList _ cp;
    cp.ob _ makeCell[max.x - min.x, max.y - min.y, 0, lpp];
    cp.name _ name;
    END;  -- of MakeNewCell

  DrawCell: PROCEDURE [obp: LONG POINTER TO ppdefs.object] =
    BEGIN OPEN ppdefs, ppddefs, ppdddefs;
    lp: LONG POINTER TO list _ makeList[obp.p.anotherme[obp], xx, yy, 0, 0];
    obp.returnable _ FALSE;
    masterList _ insertList[masterList, lp];
    anyChanges _ sinceIOchanges _ TRUE;
    selNewThing[masterList, lp, TRUE];
    putMark[xx, yy];
    reDrawRect[getRect[lp], 0, TRUE, TRUE, FALSE];
    END;  -- of DrawCell

InitStorage:PROCEDURE=BEGIN
data_zone.NEW[dataType];
trueColumn_zone.NEW[trueColumnType];
END;

InitStorage;
END..