DIRECTORY
CD,
CDFrame,
CDPinObjects,
PLAOps,
PW,
IFUPWControl,
IO,
PWPins,
REFBit,
Rope;

IFUPWContStaticPLA: CEDAR PROGRAM
IMPORTS CD, CDFrame, CDPinObjects, IFUPWControl, IO, PLAOps, PW, PWPins, REFBit, Rope
EXPORTS IFUPWControl =
BEGIN
MakeStaticPLASection: PUBLIC PROC
[desc: IFUPWControl.PLADescription] = {
log.PutF["\n Make Static PLA Section %g", IO.rope[desc.drFrame.shell.name]];
GetOuts		[desc];
GetBins		[desc];
MakePla		[desc];
MakeOutDrs	[desc]};

SDesc:	TYPE = RECORD[bins: REF Bins, outs: REF Outs];
Use:	TYPE = RECORD[cols, wt: INT,		seq: SEQUENCE size: CARDINAL OF		BOOL];
SSInt:	TYPE = RECORD[						seq: SEQUENCE size: CARDINAL OF REF	SInt];
SInt:	TYPE = RECORD[						seq: SEQUENCE size: CARDINAL OF		INT];
Bins:	TYPE = RECORD[						seq: SEQUENCE size: CARDINAL OF REF	Use];
Outs:	TYPE = RECORD[ttt: PLAOps.PLA,	seq: SEQUENCE size: CARDINAL OF REF	OUse];
OUse:	TYPE = RECORD[lv: INT,			seq: SEQUENCE size: CARDINAL OF REF	TermUse];
TermUse:		TYPE = RECORD[term: PLAOps.Term, bin: INT, use: REF Use];

NewUse: PROC[size: INT] RETURNS [use: REF Use] = {use _ NEW[Use[size]];
use.cols _ 0; use.wt _ 0; FOR bit: INT IN [0..size) DO use[bit] _ FALSE ENDLOOP};
NewSInt: PROC[size: INT, init: INT _ 0] RETURNS [seq: REF SInt] =
{seq _ NEW[SInt[size]]; FOR ii: INT IN [0..size) DO seq[ii] _ init ENDLOOP};
NewSSInt: PROC[size0, size1: INT] RETURNS [seq: REF SSInt] = {
seq _ NEW[SSInt[size0]];
FOR ii: INT IN [0..size0) DO seq[ii] _ NewSInt[size1] ENDLOOP};
NewBins: PROC[size0, size1: INT] RETURNS [seq: REF Bins] = {
seq _ NEW[Bins[size0]];
FOR ii: INT IN [0..size0) DO seq[ii] _ NewUse[size1] ENDLOOP};

GetOuts: PROC[desc: IFUPWControl.PLADescription]= {
sd:			REF SDesc _ NEW[SDesc];
TListSeq:	TYPE =  RECORD[SEQUENCE size: CARDINAL OF PLAOps.TermList];
nofBins:		INT _ desc.nofTermCols;
nofTerms:	INT _ 0;
iFormat:	REFBit.Format	_ REFBit.Desc[desc.ttt.data].bitForm;
oFormat:	REFBit.Format	_ REFBit.Desc[desc.ttt.out].bitForm;
tListSeq:	REF TListSeq		_ NEW[TListSeq[oFormat.size] ];
sd.outs		_ NEW[Outs[oFormat.size] ];
sd.outs.ttt		_ desc.ttt;
desc.data		_ sd;
IF desc.plaType=decoder THEN desc.nofOrCols _ 0;
FOR out: INT IN [0..desc.smlToBigOut.size) DO
bigOut:		INT _ desc.smlToBigOut[out];
tListSeq[out] _ PLAOps.CopyTermListForField[desc.ttt.termList, oFormat[bigOut].firstBit, 1];
[ ] _ PLAOps.ConvertTermListToCompleteSum[tListSeq[out], TRUE, TRUE, log];
[ ] _ PLAOps.FindAMinimalCover[tListSeq[out], 10, log];
nofTerms _ MAX[nofTerms, tListSeq[out].length];
ENDLOOP;
IF desc.plaType=decoder THEN desc.nofTermCols _ nofBins _ nofTerms;
FOR out: INT IN [0..desc.smlToBigOut.size) DO
term:			PLAOps.Term;
level:			INT;
level			_ IF desc.plaType=decoder
THEN 0 ELSE (tListSeq[out].length+nofBins-2)/nofBins;
nofTerms		_ IF level=0 THEN nofBins ELSE level*nofBins+1;
sd.outs[out]		_ NEW[OUse[nofTerms]];
sd.outs[out].lv	_ level;					-- = number of rows to be ORed with top row
term			_ tListSeq[out].begin;
FOR termIdx: INT IN [0..nofTerms) DO
use:	REF Use		_ NEW[Use[iFormat.size]];
sd.outs[out][termIdx]	_ NEW[TermUse _ [term, -1, use]];
use.wt _ 0;
FOR bit: INT IN [0..use.size) DO
use[bit] _ desc.fullWidthTerms OR
(term#NIL AND PLAOps.GetInQrt[term, iFormat[bit].firstBit]#dontcare);
IF use[bit] THEN use.wt _ use.wt + 1;
ENDLOOP;
IF term#NIL THEN term _ term.next;
ENDLOOP;
ENDLOOP };

GetBins: PROC[desc: IFUPWControl.PLADescription]={
sd:			REF SDesc _ NARROW[desc.data];
useSize:	INT		_ sd.outs[0][0].use.size;
nofBins:	INT		_ desc.nofTermCols;
sd.bins				_ NewBins[nofBins, useSize];
FOR out: INT IN [0..sd.outs.size) DO
nofTerms:	INT		_ sd.outs[out].size;
minTBins:	REF SInt	_ NewSInt[nofTerms];
curTBins:		REF SInt	_ NewSInt[nofTerms, -1];
minTotalWt:	INT		_ useSize*nofTerms+1;
Enum: PROC[left, wt: INT, termBins: REF SInt] = {
tempUse:	REF Use;
bin: INT _ (nofTerms-left) MOD nofBins;
IF wt >= minTotalWt THEN RETURN;
IF left=0 THEN {
FOR tt: INT IN [0..nofTerms) DO minTBins[tt] _ termBins[tt]; ENDLOOP;
minTotalWt _ wt; RETURN};
tempUse	_ NewUse[useSize];
FOR sel: INT DECREASING IN [0..left) DO
cnt, term:	INT _ 0;
cnt _ sel;
FOR term _ 0, term+1 DO
IF termBins[term]>=0 THEN LOOP; IF cnt=0 THEN EXIT; cnt _ cnt-1 ENDLOOP;
UseOr[sd.bins[bin],			sd.bins[bin], tempUse];
UseOr[sd.outs[out][term].use,	sd.bins[bin], sd.bins[bin]];
termBins[term] _ bin;
Enum[left-1, wt + sd.bins[bin].wt - tempUse.wt, termBins];
UseOr[tempUse, 		tempUse, sd.bins[bin]];
termBins[term] _ -1;
ENDLOOP};
IF desc.fullWidthTerms THEN {
FOR term: INT IN [0..nofTerms)
DO sd.outs[out][term].bin _ term MOD nofBins ENDLOOP;
LOOP};
Enum[nofTerms, 0, curTBins];
FOR term: INT IN [0..nofTerms) DO
UseOr[sd.outs[out][term].use, sd.bins[minTBins[term]], sd.bins[minTBins[term]]];
sd.outs[out][term].bin _ minTBins[term] ENDLOOP;
ENDLOOP;
FOR out: INT IN [0..sd.outs.size) DO			-- sd.bins[bin].cols used to determine OR columns/bin
FOR bin: INT IN [0..nofBins) DO
binCnt: INT _ 0;
IF desc.fullWidthTerms THEN {
FOR bit: INT IN [0..useSize) DO sd.bins[bin][bit] _ TRUE ENDLOOP;
sd.bins[bin].wt _ useSize};
FOR level: INT IN [1..sd.outs[out].lv] DO
IF GetTerm[sd.outs, out, level, bin]#NIL THEN binCnt _ binCnt + 1 ENDLOOP;
sd.bins[bin].cols _ MAX[sd.bins[bin].cols, binCnt, desc.nofOrCols] ENDLOOP;
ENDLOOP};

MakePla: PROC[desc: IFUPWControl.PLADescription] = {
sd:				REF SDesc _ NARROW[desc.data];
rowType:		IFUPWControl.RowType _ header;
out:			INT _ 0;
tileRows:		REF StaticTiles	_ GetStaticPLATiles[];
useSize:		INT				_ sd.bins[0].size;
index:			INT _ 0;
iForm:		REFBit.Format	_ REFBit.Desc[sd.outs.ttt.data].bitForm;
tiles:			REF StaticTileRow;
levelRng:		INT;
nofOrTerms:	REF SInt;
v:				Variety _ IF desc.plaType=static THEN s ELSE d;
seg,		row,		sec:					CD.Object _ NIL;
segList,	rowList,	secList,	colList:	PW.ListOb _ NIL;
DO
rowType _ IF out = sd.outs.size THEN header 
ELSE IF rowType=header	THEN footer
ELSE IF rowType=footer	THEN conn
ELSE IF (out MOD desc.termsPerHeader) = 0 THEN header ELSE conn;
levelRng		_ IF rowType = conn THEN sd.outs[out].lv ELSE 0; -- OR sub rows
tiles			_ tileRows[rowType];
nofOrTerms	_ NewSInt[sd.bins.size];
IF rowType = conn THEN FOR tt: INT IN [0..sd.outs[out].size) DO
IF sd.outs[out][tt].term=NIL THEN LOOP;
nofOrTerms[sd.outs[out][tt].bin]_MIN[sd.outs[out].lv,nofOrTerms[sd.outs[out][tt].bin]+1];
ENDLOOP;
FOR level: INT IN [0..levelRng] DO
init:	BOOL _ FALSE;
rowList _ CONS[tiles[v][leftSide], NIL];
FOR bin: INT IN [0..sd.bins.size) DO
term: PLAOps.Term;
IF level#0 THEN init _ FALSE;
term _ IF rowType = conn THEN GetTerm[sd.outs, out, level, bin] ELSE NIL;
IF nofOrTerms[bin] > sd.bins[bin].cols THEN ERROR;
FOR index IN[0..useSize) DO
IF NOT sd.bins[bin][index] THEN LOOP;
segList _ CONS[ IF term=NIL
THEN	IF ~init THEN tiles[v][andFalse] ELSE tiles[v][andPass]
ELSE SELECT PLAOps.GetInQrt[term, iForm[index].firstBit] FROM
zero		=>	IF ~init THEN tiles[v][andIfNot]	ELSE tiles[v][andNot],
one		=>	IF ~init THEN tiles[v][andIf]		ELSE tiles[v][and],
ENDCASE	=>	IF ~init THEN tiles[v][andTrue]	ELSE tiles[v][andPass], segList];
init _ TRUE;
ENDLOOP;
FOR index _ 0, index+1 WHILE index < nofOrTerms[bin] DO
segList _ CONS[	tiles[v][SELECT index+1 FROM
< level	=>	orBlank,
= level	=>	orConn,
> level	=>	IF level=0 THEN or ELSE orPass,
ENDCASE	=> ERROR], segList]; ENDLOOP;
THROUGH [nofOrTerms[bin]..sd.bins[bin].cols) 
DO segList _ CONS[ tiles[v][orBlank] , segList] ENDLOOP;
segList _ CONS[ tiles[v][ IF level#0
THEN	innerRt
ELSE	IF bin+1 < sd.bins.size
THEN	innerPass
ELSE	outerRt ], segList];
seg _ PW.AbutListX[desc.design, PW.Reverse[segList]];
segList _ NIL;
rowList _ CONS[ seg, rowList];
ENDLOOP;
row _ PW.AbutListX[desc.design, PW.Reverse[rowList]];
rowList _ NIL;
secList _ CONS[ row, secList];
ENDLOOP;
sec _ PW.AbutListY[desc.design, PW.Reverse[secList]];
secList _ NIL;
colList _ CONS[ sec, colList];
IF rowType=conn THEN out _ out+1 ELSE IF out = sd.outs.size THEN EXIT;
ENDLOOP;
desc.cell _ PW.AbutListY[desc.design, PW.Reverse[colList]];
ReNameInputPins[desc]};

MakeOutDrs: PROC [desc: IFUPWControl.PLADescription] = {
SetNewOfCnt: PROC
[drRowType: IFUPWControl.RowType, driver: REF IFUPWControl.DriveRec] = {
new[cnt] _ CDFrame.NewObjectFrame[
IFUPWControl.DriverCell[desc.plaType, drRowType, driver, desc.design]];
cnt _ cnt+1};
sd:		REF SDesc _ NARROW[desc.data];
new:	CDFrame.Frame;
cnt:	INT _ 2;
FOR out: INT IN [0..sd.outs.size) DO
IF out IN [1..sd.outs.size-1) AND (out MOD desc.termsPerHeader)=0 THEN cnt _ cnt+2;
cnt _ cnt + sd.outs[out].lv+1 ENDLOOP;
new	_ CDFrame.NewFrame[cnt, y, desc.name.Cat["-OutDr"]];
cnt	_ 0;
SetNewOfCnt[footer, NIL];
FOR out: INT IN [0..sd.outs.size) DO
IF out IN [1..sd.outs.size-1) AND (out MOD desc.termsPerHeader)=0 THEN
{SetNewOfCnt[header, NIL]; SetNewOfCnt[footer, NIL]};
FOR term: INT IN [0..sd.outs[out].lv] DO
SetNewOfCnt[IF term=0 THEN conn ELSE blank, desc.connSeq[out].dr] ENDLOOP;
ENDLOOP;
SetNewOfCnt[header, NIL];
desc.drFrame _ new};

DeleteUnusedStaticInDrs: PUBLIC PROC
[desc: IFUPWControl.PLADescription, drs: CDFrame.Frame] = {
enum: CDFrame.EnumProc = {
IF tempUse[oldIdx] THEN 
{new[newIdx] _ frame; new[newIdx].father _ new; newIdx _ newIdx +1};
oldIdx _ oldIdx+1};
sd:			REF SDesc	_ NARROW[desc.data];
oldIdx:		INT			_ 0;
newIdx:		INT			_ 0;
useSize:	INT			_ sd.bins[0].size;
tempUse:	REF Use		_ NewUse[useSize];
new:		CDFrame.Frame;
FOR bin: INT IN [0..sd.bins.size) DO UseOr[sd.bins[bin],	tempUse, tempUse] ENDLOOP;
IF tempUse.wt=useSize THEN RETURN;
new				_ NEW[CDFrame.FrameSeq[tempUse.wt]];
new.shell			_ drs[1].shell;
new.data			_ drs[1].data;
new.father		_ drs[1].father;
new.xory			_ drs[1].xory;
new.unordered	_ drs[1].unordered;
new.orient		_ drs[1].orient;
CDFrame.EnumFrameBotOnly[drs[1], enum];
drs[1]				_ new};

UseOr: PROC[useArg0, useArg1, useOr: REF Use] = {
IF useArg0.size#useArg1.size OR useArg1.size#useOr.size THEN ERROR;
useOr.wt _ 0;
FOR bit: INT IN [0..useArg0.size) DO
useOr[bit] _ useArg0[bit] OR useArg1[bit];
IF useOr[bit] THEN useOr.wt _ useOr.wt + 1;
ENDLOOP };

GetTerm: PROC[outs: REF Outs, out, level, bin: INT] RETURNS[term: PLAOps.Term] = {
found: INT _ 0;
FOR tt: INT IN [0..outs[out].size) DO
IF outs[out][tt].bin#bin THEN LOOP;
found _ found+1;
term _ outs[out][tt].term;
IF found = level THEN RETURN[term];
ENDLOOP;
IF found=0 THEN ERROR;	-- Just checking, term can be NIL but bin must be represented
IF level#0 THEN ERROR;	-- level 0 => last term
IF outs[out].lv#0 AND bin#0 THEN RETURN[NIL];
RETURN[term]};	-- last term for level 0 when outs[out].lv=0 OR bin=0

ReNameInputPins: PROC[desc: IFUPWControl.PLADescription] = {
sd:				REF SDesc _ NARROW[desc.data];
SSRope:		TYPE = RECORD[SEQUENCE size: CARDINAL OF REF SRope];
SRope:		TYPE = RECORD[SEQUENCE size: CARDINAL OF IO.ROPE];
tiles:			REF StaticTiles _ GetStaticPLATiles[];
format:		REFBit.Format _ REFBit.Desc[sd.outs.ttt.data].bitForm;
inName:		REF SSRope _ NEW[SSRope[sd.bins.size]];
inNameInv:	REF SSRope _ NEW[SSRope[sd.bins.size]];
v:				Variety _ IF desc.plaType=static THEN s ELSE d;
leftSize:		INT _ CD.InterestSize[tiles[header][v][leftSide]].x;
andWidth:	INT _ CD.InterestSize[tiles[header][v][and]].x;
orWidth:		INT _ CD.InterestSize[tiles[header][v][or]].x;
innerSize:	INT _ CD.InterestSize[tiles[header][v][innerRt]].x;
changeProc:	PWPins.ChangePinProc ~ {
pos: INT _ leftSize;
oldRope: Rope.ROPE _ CDPinObjects.GetName[oldPin];
in0:	BOOL	_ Rope.Equal[oldRope, "in0"];
in1:	BOOL	_ Rope.Equal[oldRope, "in1"];
IF NOT(in0 OR in1) THEN RETURN[oldPin];
FOR bin: INT IN [0..sd.bins.size) DO
index: INT _ (oldPin.location.x-pos)/andWidth;
IF index < inName[bin].size THEN {
CDPinObjects.SetName[oldPin,
IF in1 THEN inNameInv[bin][index] ELSE inName[bin][index]];
RETURN[oldPin]};
pos _ pos + inName[bin].size*andWidth + sd.bins[bin].cols*orWidth + innerSize;
REPEAT FINISHED => ERROR ENDLOOP};
FOR bin: INT IN [0..sd.bins.size) DO
list:	LIST OF IO.ROPE _ desc.plaInNames;
in:		INT _ 0;
inName[bin]		_ NEW[SRope[sd.bins[bin].wt]];
inNameInv[bin]	_ NEW[SRope[sd.bins[bin].wt]];
FOR bit: INT IN [0..sd.bins[bin].size) DO
IF sd.bins[bin][bit] THEN {
inName		[bin][in]	_ list.first;
inNameInv	[bin][in]	_ list.rest.first;
in _ in+1};
list _ list.rest.rest;
ENDLOOP;
ENDLOOP;
desc.cell _ PWPins.ChangePins[desc.design, desc.cell, changeProc];
PW.RenameObject[desc.design, desc.cell, desc.name]};
staticTileDesign:	CD.Design;
staticTiles:		REF StaticTiles;
StaticTiles:		TYPE = ARRAY IFUPWControl.RowType OF REF StaticTileRow;
StaticTileRow: 	TYPE = ARRAY Variety OF StaticTileVar;
StaticTileVar: 	TYPE = ARRAY StaticTileType OF CD.Object;
Variety:			TYPE = {s, d};	-- static or decode
StaticTileType :	TYPE = {leftSide, andTrue, andFalse, andIf, andIfNot, and, andNot, andPass, or, orNot, orPass, orBlank, orConn, innerPass, innerRt, outerRt};

GetStaticPLATiles: PROC RETURNS [tiles: REF StaticTiles ] = {
tDesign:	CD.Design;
IF staticTiles#NIL THEN RETURN[staticTiles];
log.PutRope["\n Initialize static pla tiles"];
tDesign _ staticTileDesign _ PW.OpenDesign["IFUPWControl.dale"];
IF tDesign=NIL THEN
ERROR PW.Error[MissingDesign, "TileSet design not found or empty"];
tiles _ staticTiles _ NEW[StaticTiles];
FOR row: IFUPWControl.RowType IN IFUPWControl.RowType DO
tiles[row] _NEW[StaticTileRow] ENDLOOP;

tiles	[header][s][leftSide]		_ PW.Get[design: tDesign, name: "SPlaHLeftSide"	];
tiles	[header][s][andTrue]	_ 
tiles	[header][s][andFalse]	_ 
tiles	[header][s][andIf]		_ 
tiles	[header][s][andIfNot]	_ 
tiles	[header][s][and]			_ 
tiles	[header][s][andNot]		_ 
tiles	[header][s][andPass]	_ PW.Get[design: tDesign, name: "SPlaHAnd"		];
tiles	[header][s][or]			_ 
tiles	[header][s][orNot]		_ 
tiles	[header][s][orPass]		_ 
tiles	[header][s][orBlank]	_ 
tiles	[header][s][orConn]		_ PW.Get[design: tDesign, name: "SPlaHOr" 			];
tiles	[header][s][innerPass]	_
tiles	[header][s][innerRt]	_
tiles	[header][s][outerRt]		_ PW.Get[design: tDesign, name: "SPlaHOuterRt"	];

tiles	[footer][s][leftSide]		_ PW.FlipY[tDesign,	tiles [header][s][leftSide]];
tiles	[footer][s][andTrue]		_ 
tiles	[footer][s][andFalse]	_ 
tiles	[footer][s][andIf]		_ 
tiles	[footer][s][andIfNot]	_ 
tiles	[footer][s][and]			_ 
tiles	[footer][s][andNot]		_ 
tiles	[footer][s][andPass]		_ PW.FlipY[tDesign,	tiles [header][s][andPass]];
tiles	[footer][s][or]			_ 
tiles	[footer][s][orNot]		_ 
tiles	[footer][s][orPass]		_ 
tiles	[footer][s][orBlank]		_ 
tiles	[footer][s][orConn]		_ PW.FlipY[tDesign,	tiles [header][s][orConn]];
tiles	[footer][s][innerPass]	_
tiles	[footer][s][innerRt]		_
tiles	[footer][s][outerRt]		_ PW.FlipY[tDesign,	tiles [header][s][outerRt]];

tiles	[conn][s][leftSide]		_ PW.Get[design: tDesign, name: "SPlaLeftSide"		];
tiles	[conn][s][andTrue]		_ PW.Get[design: tDesign, name: "SPlaAndTrue"	];
tiles	[conn][s][andFalse]		_ PW.Get[design: tDesign, name: "SPlaAndFalse"	];
tiles	[conn][s][andIf]			_ PW.Get[design: tDesign, name: "SPlaAndIf"		];
tiles	[conn][s][andIfNot]		_ PW.Get[design: tDesign, name: "SPlaAndIfNot"	];
tiles	[conn][s][and]			_ PW.Get[design: tDesign, name: "SPlaAnd"			];
tiles	[conn][s][andNot]		_ PW.Get[design: tDesign, name: "SPlaAndNot"		];
tiles	[conn][s][andPass]		_ PW.Get[design: tDesign, name: "SPlaAndPass"		];
tiles	[conn][s][or]				_ PW.Get[design: tDesign, name: "SPlaOr" 			];
tiles	[conn][s][orNot]			_ PW.Get[design: tDesign, name: "SPlaOrNot"		];
tiles	[conn][s][orPass]		_ PW.Get[design: tDesign, name: "SPlaOrPass"		];
tiles	[conn][s][orBlank]		_ PW.Get[design: tDesign, name: "SPlaOrBlank"		];
tiles	[conn][s][orConn]		_ PW.Get[design: tDesign, name: "SPlaOrConn"		];
tiles	[conn][s][innerPass]	_ PW.Get[design: tDesign, name: "SPlaInnerPass"	];
tiles	[conn][s][innerRt]		_ PW.Get[design: tDesign, name: "SPlaInnerRt"		];
tiles	[conn][s][outerRt]		_ PW.Get[design: tDesign, name: "SPlaOuterRt"		];

FOR type: StaticTileType IN StaticTileType DO
tiles[header]	[d][type] _ tiles[header]	[s][type];
tiles[footer]	[d][type] _ tiles[footer]		[s][type] ENDLOOP;

tiles	[header][d][innerPass]	_
tiles	[header][d][innerRt]	_
tiles	[header][d][outerRt]	_ PW.Get[design: tDesign, name: "DPlaHRt"	];

tiles	[footer][d][innerPass]	_
tiles	[footer][d][innerRt]		_
tiles	[footer][d][outerRt]		_ PW.FlipY[tDesign,	tiles [header][d][outerRt]];

tiles	[conn][d][leftSide]		_ PW.Get[design: tDesign, name: "DPlaLeftSide"		];
tiles	[conn][d][andTrue]		_ PW.Get[design: tDesign, name: "DPlaAndTrue"	];
tiles	[conn][d][andFalse]		_ PW.Get[design: tDesign, name: "DPlaAndFalse"	];
tiles	[conn][d][andIf]			_ PW.Get[design: tDesign, name: "DPlaAndIf"		];
tiles	[conn][d][andIfNot]		_ PW.Get[design: tDesign, name: "DPlaAndIfNot"	];
tiles	[conn][d][and]			_ PW.Get[design: tDesign, name: "DPlaAnd"			];
tiles	[conn][d][andNot]		_ PW.Get[design: tDesign, name: "DPlaAndNot"		];
tiles	[conn][d][andPass]		_ PW.Get[design: tDesign, name: "DPlaAndPass"		];
tiles	[conn][d][or]			_
tiles	[conn][d][orNot]			_
tiles	[conn][d][orPass]		_
tiles	[conn][d][orBlank]		_
tiles	[conn][d][orConn]		_ tiles[conn][s][or];
tiles	[conn][d][innerPass]	_
tiles	[conn][d][innerRt]		_
tiles	[conn][d][outerRt]		_ PW.Get[design: tDesign, name: "DPlaRt"			];

};	
log: IO.STREAM _ CDFrame.GetLog[];

END.

–IFUPWContStaticPLA.mesa
Copyright c 1985 by Xerox Corporation.  All rights resersed.
Last Edited by: Curry, January 28, 1986 4:47:16 pm PST




Κ˜š
œ™Jš
œ<™<Icode™6—J˜š
Οk	˜	Jšœ
˜Jš
œ˜Jš
œ
˜
Jš
œ˜Jšœ
˜Jš
œ
˜
Jšœ
˜Jš
œ˜Jš
œ˜Jš
œ˜—J˜šœœ
˜!Jšœ
œ'œ
œ˜UJšœ˜Jš
˜J™šΟnœœ
˜!Jš
œ'˜'Jšœ*œ ˜LJš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜J˜—Jš	œœœœ
œ˜5Jšœœœœœœ
œœ˜JJš
œœœœœ
œ
œ˜EJš
œœœœœ
œœ˜@Jš
œœœœœ
œ
œ˜CJšœœœ
œœœ
œ
œ˜OJšœœœœ	œœ
œ
œ
˜LJš	œ
œœœœ˜CJ˜šžœœœœœœ˜GJš
œœœ
œœœ
œ˜Q—šžœœœœœœ˜AJš
œœœœ
œœœ˜L—š
žœœœœœ˜>Jšœœ˜Jš
œœ
œœœ˜?—š
žœœœœœ
˜<Jšœœ˜Jš
œœ
œœœ˜>—J˜šžœœ&˜3Jšœœ	œ˜Jšœ
œœ
œœ
œ˜EJšœ
œ˜!Jšœ
œ˜Jš
œ<˜<Jš
œ;˜;Jšœ
œ	œ˜7Jšœœ˜$Jš
œ˜Jš
œ˜Jšœœ˜0šœœ
œ˜-Jšœ	œ˜%Jš
œ\˜\Jšœ9œœ˜JJš
œ7˜7Jšœœ!˜/Jšœ
˜—Jšœœ'˜Cšœœ
œ˜-Jš
œ˜Jšœ	œ
˜
šœ
œ˜!Jšœœ*˜5—Jšœœ	œ	œ˜9Jšœœ˜$JšœΟc+˜HJš
œ˜šœ
œ
œ˜$Jšœœœ˜'Jšœœ˜7Jš
œ˜šœœ
œ˜ šœ˜!Jšœœ
œ8˜E—Jšœ
œ˜%Jšœ
˜—Jšœœ
œ˜"Jšœ
˜—Jšœ˜
——J˜šžœœ%˜2Jšœœ	œ˜$Jšœ	œ˜'Jšœ	œ˜!Jš
œ'˜'šœœ
œ˜$Jšœ
œ˜#Jšœ
œ˜'Jšœœ˜,Jšœœ˜&šžœœœœ
˜1Jšœ	œ˜Jšœœœ	˜'Jšœœ
œ
˜ šœœ˜Jš
œœ
œœœ
˜EJšœœ˜—Jš
œ˜š	œœ

œ
œ˜'Jšœœ˜Jš
œ
˜
šœ˜Jšœœ
œœœ
œœ
˜H—Jš
œ-˜-Jš
œ:˜:Jš
œ˜Jš
œ:˜:Jš
œ(˜(Jš
œ˜Jšœ˜	——šœœ˜šœœ
œ˜Jšœœ	œ
˜5—Jšœ˜—Jš
œ˜šœœ
œ˜!Jš
œP˜PJšœ(œ
˜0—Jšœ
˜—š	œœ
œœŸ5˜\šœœ
œ˜Jšœœ˜šœœ˜Jšœœ
œœœ
œ
˜AJš
œ˜—šœœ
œ˜)Jšœ#œ
œœ
˜J—Jšœœ,œ
˜K—Jšœ˜	—J˜—šžœœ'˜4Jšœœ	œ˜%Jš
œ(˜(Jšœœ˜Jšœœ#˜1Jšœ
œ˜#Jšœ	œ˜Jš
œ>˜>Jšœ	œ˜Jšœœ
˜Jšœœ˜Jšœœœœ˜5Jšœœ
œ
˜%Jšœ$œ
œ
˜4š
˜šœ
œœ˜,Jšœ
œœ˜"Jšœ
œœ˜ Jš
œ
œœœœ˜@—JšœœœœŸ˜IJš
œ˜Jš
œ#˜#šœœ
œœ
œ˜?Jšœœ
œ
œ
˜'Jšœ!œ5˜YJšœ
˜—šœœ
œ˜"Jšœœœ
˜Jšœ
œœ˜(šœœ
œ˜$Jš
œ˜Jšœ	œœ
˜Jš	œœœ#œ
œ
˜IJšœ%œ
œ
˜2šœœ
˜Jšœ
œœ
œ
˜%šœ
œœ˜Jšœ
œœœ˜<šœ
œ.˜=Jšœ	œœœ˜@Jšœœœœ˜:Jšœœœœ˜L——Jšœœ
˜Jšœ
˜—šœœ˜7šœ
œœ	˜,Jš
œ˜Jš
œ˜Jšœœ	œœ˜*Jšœœ
œ
˜%——šœ&˜-Jšœœœ
˜8—šœ
œœ˜$Jšœ˜šœ
œ˜Jšœ
˜Jšœ˜——Jšœœœ˜5Jšœ
œ
˜Jšœ
œ˜Jšœ
˜—Jšœœœ˜5Jšœ
œ
˜Jšœ
œ˜Jšœ
˜—Jšœœœ˜5Jšœ
œ
˜Jšœ
œ˜Jšœœ
œ
œœ
œ
˜FJšœ
˜—Jšœœœ˜;Jš
œ˜—J˜šž
œœ(˜8šΠbkœ˜Jšœ*œ˜Hš
œ"˜"Jš
œG˜G—Jš
œ
˜
—Jšœœ	œ˜#Jš
œ˜Jšœœ˜
šœœ
œ˜$Jš
œœœœœ
˜SJšœœ
˜&—Jš
œ8˜8Jš
œ˜Jš œ
Οbœœ˜šœœ
œ˜$š	œœœœ˜FJš
œ
 œ
‘œœ œ
‘œœ˜5—šœœ
œ˜(Jš œ
œœ
‘œ
œ
‘œœ
˜J—Jšœ
˜—Jš œ
‘œœ˜Jš
œ˜—J˜šΠbnœœ
˜$Jš
œ;˜;š
œ˜šœœ
˜Jš
œD˜D—Jš
œ˜—Jšœœ	œ˜$Jšœ	œ˜Jšœ	œ˜Jšœ	œ˜!Jšœ	œ˜$Jš
œ˜Jš
œœ
œœ'œ
˜SJšœœ
œ
˜"Jšœ	œ˜+Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ!˜!Jš
œ˜Jšœžœ˜'Jš
œ˜—J˜šžœœœ	˜1Jšœœœ
œ
˜CJš
œ
˜
šœœ
œ˜$Jšœœ˜*Jšœœ˜+Jšœ˜
——J˜š
žœœœœœ˜RJšœœ˜šœœ
œ˜%Jšœœ
œ
˜#Jš
œ˜Jš
œ˜Jšœœ
œ˜#Jšœ
˜—Jšœ	œ
œŸ=˜TJšœ	œ
œŸ˜.Jš
œœœ
œ
œ˜-Jšœ	Ÿ5˜D—J˜J™šžœœ'˜<Jšœœ	œ˜%Jš
œ	œœ
œœ
œ
œ˜=Jšœœœ
œœ
œ
œ
œ˜:Jšœ	œ#˜/Jš
œ?˜?Jšœ	œ
œ˜0Jšœœ
œ˜2Jšœœœœ˜5Jšœœœ,˜?Jšœ
œœ'˜9Jšœ
œœ&˜8Jšœœœ+˜>š
œ$˜$Jšœœ˜Jšœœ ˜2Jšœœ˜'Jšœœ˜'Jš
œ
œœœ
œ	˜'šœœ
œ˜$Jšœœ$˜.šœœ˜"š
œ˜Jšœœœ˜;—Jšœ
˜—Jš
œN˜NJšœ
œœ
œ˜"——šœœ
œ˜$Jš	œœ
œ
œ
œ˜(Jšœœ˜
Jšœœ˜+Jšœœ˜-šœœ
œ˜)šœœ˜Jš
œ˜Jš
œ&˜&Jš
œ˜—Jš
œ˜Jšœ
˜—Jšœ
˜—Jš
œB˜BJšœ2˜4—J™Jšœœ˜Jšœœ
˜Jš	œœœœ
œ˜EJšœœœ	œ˜6Jš	œœœœ
œ˜9JšœœŸ˜-Jšœœ‰
˜ž
J˜šžœœ
œ	œ˜=Jšœ	œ˜Jšœ
œ
œ
œ˜,Jš
œ.˜.Jšœœ!˜@šœ	œ
˜Jšœ
œ;˜C—Jšœœ˜'šœœ˜8Jšœœœ
˜'—J˜Jšœœ.˜OJš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœœ*˜IJš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœœ+˜JJš
œ˜Jš
œ˜Jšœœ-˜MJ˜Jšœœ-˜NJš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœœ,˜LJš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœœ+˜JJš
œ˜Jš
œ˜Jšœœ,˜LJ˜Jšœœ.˜MJšœœ,˜JJšœœ-˜LJšœœ+˜HJšœœ-˜LJšœœ*˜EJšœœ,˜IJšœœ-˜KJšœœ*˜EJšœœ+˜HJšœœ,˜IJšœœ-˜KJšœœ,˜IJšœœ.˜MJšœœ-˜KJšœœ-˜KJ˜šœœ˜-Jš
œ2˜2Jšœ3œ
˜;—J˜Jš
œ˜Jš
œ˜Jšœœ(˜GJ˜Jš
œ˜Jš
œ˜Jšœœ,˜LJ˜Jšœœ.˜MJšœœ,˜JJšœœ-˜LJšœœ+˜HJšœœ-˜LJšœœ*˜EJšœœ,˜IJšœœ-˜KJš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ.˜.Jš
œ˜Jš
œ˜Jšœœ)˜GJ˜Jš
œ˜—J™Jšœœ
œ˜"J˜Jšœ
˜J˜——…—BŒX<