DIRECTORY CD, CDSymbolicObjects, Core, CoreBlock, CoreFrame, CoreLibrary, CoreName, PLAOps, PW, IFUCoreCells, IFUCoreCtl, IFUCoreDrive, IO, PWPins, REFBit, Rope;

IFUCoreCtlStatic: CEDAR PROGRAM
IMPORTS CD, CDSymbolicObjects, CoreBlock, CoreFrame, CoreLibrary, CoreName, PLAOps, PW, IFUCoreCells, IFUCoreDrive, IO, PWPins, REFBit, Rope
EXPORTS IFUCoreCtl =
BEGIN

ROPE:				TYPE	= Core.ROPE;
PLADescription:	TYPE	= IFUCoreCtl.PLADescription;
RowType:		TYPE	= IFUCoreDrive.RowType;
Drive:				TYPE	= IFUCoreDrive.Drive;
Drives:			TYPE	= IFUCoreDrive.Drives;
DriveRec:			TYPE	= IFUCoreDrive.DriveRec;

Signal: SIGNAL = CODE;
MakeStaticPLA: PUBLIC PROC[desc: PLADescription] = {
log.PutF["\n Make Static PLA %g", IO.rope[desc.name]];
GetOuts		[desc];
GetBins		[desc];
MakePla		[desc];
DressInDrs	[desc];
DressOutDrs	[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: 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: 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: PLADescription] = {
name:	ROPE _ CoreName.RopeNm[desc.name.Cat["Body"]];
IF (desc.outBodyCT _ CoreFrame.ReadFrameCache[name])=NIL THEN {
sd:				REF SDesc _ NARROW[desc.data];
cellType:		Core.CellType;
body:			CD.Object;
rowType:		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
rowList _ CONS[tiles[v][leftSide], NIL];
FOR bin: INT IN [0..sd.bins.size) DO
term:	PLAOps.Term;
first:	BOOL _ bin=0  OR level#0 OR desc.plaType=decoder;
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;
IF term=NIL
THEN segList _ CONS[
IF ~first
THEN	tiles[v][andPass]
ELSE	IF levelRng=0 AND desc.plaType#decoder
THEN	tiles[v][andTrue] -- for term at right
ELSE	tiles[v][andFalse] -- for decoder OR gate
, segList ]
ELSE
segList _ CONS[ SELECT PLAOps.GetInQrt[term, iForm[index].firstBit] FROM
zero		=>	IF first THEN tiles[v][andIfNot]	ELSE tiles[v][andNot],
one		=>	IF first THEN tiles[v][andIf]		ELSE tiles[v][and],
ENDCASE	=>	IF first THEN tiles[v][andTrue]	ELSE tiles[v][andPass], segList];
first _ FALSE;
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[PW.Reverse[segList]];
segList _ NIL;
rowList _ CONS[ seg, rowList];
ENDLOOP;
row _ PW.AbutListX[PW.Reverse[rowList]];
rowList _ NIL;
secList _ CONS[ row, secList];
ENDLOOP;
sec _ PW.AbutListY[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;
body	_ PW.AbutListY[PW.Reverse[colList]];
body	_ ApplyNames[body, desc];
cellType _ CoreLibrary.ObjCell[body, name, NIL, 0];
CoreBlock.MarkSides[cellType, desc.capSides];
desc.outBodyCT _ CoreFrame.NewFrameCell[0, name,  [first: left, cell: cellType] ];
CoreFrame.WriteFrameCache[desc.outBodyCT]} };

in0:			ROPE	_ CoreName.RopeNm["in0"];
in1:			ROPE	_ CoreName.RopeNm["in1"];
out0:			ROPE	_ CoreName.RopeNm["out0"];
out1:			ROPE	_ CoreName.RopeNm["out1"];
VDD:			ROPE	_ CoreName.RopeNm["VDD"];
GND:			ROPE	_ CoreName.RopeNm["GND"];

ApplyNames: PROC[oldObj: CD.Object, desc: PLADescription] RETURNS[newObj: CD.Object]= {
sd:				REF SDesc _ NARROW[desc.data];
SSRope:		TYPE = RECORD[SEQUENCE size: CARDINAL OF REF SRope];
SRope:		TYPE = RECORD[SEQUENCE size: CARDINAL OF ROPE];
tiles:			REF StaticTiles _ GetStaticPLATiles[];
drTiles:		REF IFUCoreDrive.DrTileRec _ IFUCoreDrive.GetDriverTiles[];
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;
headHt:		INT _ CD.InterestSize[tiles[header	][v][outerRt]].y;
rowHt:		INT _ CD.InterestSize[tiles[conn	][v][outerRt]].y;
renameProc:	PWPins.ChangePinProc ~ {
old: ROPE _ CoreName.RopeNm[CDSymbolicObjects.GetName[oldPin]];
side:	CoreBlock.Sides;
loc:	INT;
newPin _ oldPin;
[side, loc, ] _ CoreBlock.GetInstSideLocSize[oldObj, newPin];
SELECT old FROM
GND	=> RETURN;
VDD	=> RETURN;
out1	=> RETURN[NIL];
out0	=> {
name: ROPE;
yPos:	INT	_ headHt;
FOR out: INT IN [0..sd.outs.size) DO
IF out IN [1..sd.outs.size-1) AND (out MOD desc.termsPerHeader)=0 THEN yPos _ yPos + 2*headHt;
IF loc IN (yPos..(yPos + rowHt)) THEN {
name _ IFUCoreDrive.DriveName[desc.connSeq[out].dr, in];
CDSymbolicObjects.SetName[newPin, name]; 
RETURN};
yPos _ yPos + (sd.outs[out].lv +1)*rowHt;
ENDLOOP;
Signal[]};
in0,
in1 => {
xpos:	INT	_ leftSize;
FOR bin: INT IN [0..sd.bins.size) DO
index: INT _ (loc-xpos)/andWidth;
IF index < inName[bin].size THEN {
IF old=in0
THEN	CDSymbolicObjects.SetName[newPin, inName		[bin][index]]
ELSE	CDSymbolicObjects.SetName[newPin, inNameInv	[bin][index]];
RETURN};
xpos _ xpos + inName[bin].size*andWidth + sd.bins[bin].cols*orWidth + innerSize;
REPEAT FINISHED => Signal[] ENDLOOP };
ENDCASE => RETURN};
FOR bin: INT IN [0..sd.bins.size) DO
list:	LIST OF 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;
newObj _ PWPins.ChangePins[oldObj, renameProc]};

DressInDrs: PROC [desc: PLADescription] = {
sd:		REF SDesc _ NARROW[desc.data];
DeleteUnusedStaticInDrs [desc];
desc.inDrs _ CONS[ NEW[DriveRec _ [drRowType: xfooter]], desc.inDrs];
FOR list: Drives _ desc.inDrs, list.rest WHILE list.rest#NIL DO REPEAT
FINISHED => list.rest _ CONS [NEW[DriveRec _ [drRowType: xheader]], NIL] ENDLOOP};

DressOutDrs: PROC [desc: PLADescription] = {
sd:		REF SDesc _ NARROW[desc.data];
desc.outDrs _ CONS[ NEW[DriveRec _ [drRowType: 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 {
desc.outDrs	_ CONS[ NEW[DriveRec _ [drRowType: header]],	desc.outDrs];
desc.outDrs	_ CONS[ NEW[DriveRec _ [drRowType: footer]],	desc.outDrs] };
FOR term: INT IN [0..sd.outs[out].lv] DO
desc.outDrs _ CONS[ NEW[DriveRec _ desc.connSeq[out].dr^], desc.outDrs];
desc.outDrs.first.drRowType _ IF term=0 THEN conn ELSE blank
ENDLOOP;
ENDLOOP;
desc.outDrs _ CONS[ NEW[DriveRec _ [drRowType: header]], desc.outDrs];
desc.outDrs _ IFUCoreDrive.ReverseDrives[desc.outDrs]};
DeleteUnusedStaticInDrs: PUBLIC PROC [desc: PLADescription] = {
sd:				REF SDesc	_ NARROW[desc.data];
index:			INT		_ 0;
useSize:		INT		_ sd.bins[0].size;
tempUse:		REF Use	_ NewUse[useSize];
drs:			Drives	_ NIL;
delIns:		Drives	_ NIL;
FOR bin: INT IN [0..sd.bins.size) DO UseOr[sd.bins[bin],	tempUse, tempUse] ENDLOOP;
IF tempUse.wt=useSize THEN RETURN;
FOR temp: Drives _ desc.inDrs, temp.rest WHILE temp#NIL DO
IF tempUse[index] THEN drs _ CONS[temp.first, drs];
index _ index +1 ENDLOOP;
desc.inDrs _ IFUCoreDrive.ReverseDrives[drs]};

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

staticTiles:		REF StaticTiles;
StaticTiles:		TYPE = ARRAY 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 ] = {
Get: PROC[name: ROPE] RETURNS[CD.Object] = 
{RETURN[PW.Get[design: library.design, name: name ]]};
library: CoreLibrary.Library _ IFUCoreCells.library;
IF staticTiles#NIL THEN RETURN[staticTiles];
log.PutRope["\n Initialize static pla tiles"];
tiles _ NEW[StaticTiles];
FOR row: RowType IN RowType DO
tiles[row] _NEW[StaticTileRow] ENDLOOP;

tiles	[header][s][leftSide]		_ Get[	"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]	_ Get[	"SPlaHAnd"		];
tiles	[header][s][or]			_ 
tiles	[header][s][orNot]		_ 
tiles	[header][s][orPass]		_ 
tiles	[header][s][orBlank]	_ 
tiles	[header][s][orConn]		_ Get[	"SPlaHOr" 		];
tiles	[header][s][innerPass]	_
tiles	[header][s][innerRt]	_
tiles	[header][s][outerRt]		_ Get[	"SPlaHOuterRt"	];

tiles	[footer][s][leftSide]		_ PW.FlipY[	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[	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[	tiles [header][s][orConn]];
tiles	[footer][s][innerPass]	_
tiles	[footer][s][innerRt]		_
tiles	[footer][s][outerRt]		_ PW.FlipY[	tiles [header][s][outerRt]];

tiles	[conn][s][leftSide]		_ Get[	"SPlaLeftSide"	];
tiles	[conn][s][andTrue]		_ Get[	"SPlaAndTrue"	];
tiles	[conn][s][andFalse]		_ Get[	"SPlaAndFalse"	];
tiles	[conn][s][andIf]			_ Get[	"SPlaAndIf"		];
tiles	[conn][s][andIfNot]		_ Get[	"SPlaAndIfNot"	];
tiles	[conn][s][and]			_ Get[	"SPlaAnd"		];
tiles	[conn][s][andNot]		_ Get[	"SPlaAndNot"	];
tiles	[conn][s][andPass]		_ Get[	"SPlaAndPass"	];
tiles	[conn][s][or]				_ Get[	"SPlaOr" 			];
tiles	[conn][s][orNot]			_ Get[	"SPlaOrNot"		];
tiles	[conn][s][orPass]		_ Get[	"SPlaOrPass"		];
tiles	[conn][s][orBlank]		_ Get[	"SPlaOrBlank"	];
tiles	[conn][s][orConn]		_ Get[	"SPlaOrConn"	];
tiles	[conn][s][innerPass]	_ Get[	"SPlaInnerPass"	];
tiles	[conn][s][innerRt]		_ Get[	"SPlaInnerRt"	];
tiles	[conn][s][outerRt]		_ Get[	"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]	_ Get[	"DPlaHRt"		];

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

tiles	[conn][d][leftSide]		_ Get[	"DPlaLeftSide"	];
tiles	[conn][d][andTrue]		_ Get[	"DPlaAndTrue"	];
tiles	[conn][d][andFalse]		_ Get[	"DPlaAndFalse"	];
tiles	[conn][d][andIf]			_ Get[	"DPlaAndIf"		];
tiles	[conn][d][andIfNot]		_ Get[	"DPlaAndIfNot"	];
tiles	[conn][d][and]			_ Get[	"DPlaAnd"		];
tiles	[conn][d][andNot]		_ Get[	"DPlaAndNot"	];
tiles	[conn][d][andPass]		_ Get[	"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]		_ Get[	"DPlaRt"			];

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

END.


"IFUCoreCtlStatic.mesa
Copyright c 1985 by Xerox Corporation.  All rights resersed.
Last Edited by: Curry, September 19, 1986 1:40:51 pm PDT

seg _ PW.SharedAbutListX[PW.Reverse[segList]];
row _ PW.SharedAbutListX[PW.Reverse[rowList]];
sec _ PW.SharedAbutListY[PW.Reverse[secList]];


Κ΅˜šΟbœ™Jš
œ<™<Icode™8—J˜JšΟk
œQžœ)žœ˜‘
J˜šœžœ
ž˜JšžœLžœžœ˜Œ
Jšžœ
˜Jš
ž˜J˜Jšžœžœžœ
˜Jšœžœ˜1Jšœ
žœ˜&Jšœ
žœ˜$Jšœ
žœ˜%Jšœžœ˜)J˜Jšœžœžœ
˜J™šΟn
œžœ
žœ˜4Jšœ"žœ˜6Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜J˜—Jš	œžœžœžœ
žœ˜5Jšœžœžœžœžœžœ
žœžœ˜JJš
œžœžœžœžœ
žœ
žœ˜EJš
œžœžœžœžœ
žœžœ˜@Jš
œžœžœžœžœ
žœ
žœ˜CJšœžœžœ
žœžœžœ
žœ
žœ˜OJšœžœžœžœ	žœžœ
žœ
žœ
˜LJš	œ
žœžœžœžœ˜CJ˜šŸœžœžœžœžœžœ˜GJš
œžœžœ
žœžœžœ
žœ˜Q—šŸœžœžœžœžœžœ˜AJš
œžœžœžœ
žœžœžœ˜L—š
Ÿœžœžœžœžœ˜>Jšœžœ˜Jš
žœžœ
žœžœžœ˜?—š
Ÿœžœžœžœžœ
˜<Jšœžœ˜Jš
žœžœ
žœžœžœ˜>—J˜šŸœžœ˜&Jšœžœ	žœ˜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˜šŸœžœ˜%Jšœžœ	žœ˜$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˜—šŸœžœ˜'Jšœžœ*˜4šžœ3žœ
ž˜?Jšœžœ	žœ˜%Jš
œ˜Jš
œ˜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šœžœ
žœ	žœ˜8Jš	œžœžœ#žœ
žœ
˜IJšžœ%žœ
žœ
˜2šžœžœ
ž˜Jšžœ
žœžœ
žœ
˜%šžœž˜šžœžœ
˜šžœ˜	Jšžœ˜šžœ
žœžœ˜+Jšžœ ˜+Jšžœ ˜.——Jš
œ˜—š
ž˜šœ
žœžœ.ž˜HJšœ	žœžœžœ˜@Jšœžœžœžœ˜:Jšžœžœžœžœ˜L———Jšœžœ
˜Jšžœ
˜—šžœžœž˜7šœ
žœžœ	ž˜,Jš
œ˜Jš
œ˜Jšœžœ	žœžœ˜*Jšžœžœ
žœ
˜%——šžœ&˜-Jšžœžœžœ
˜8—šœ
žœžœ˜$Jšžœ˜šžœ
žœ˜Jšžœ
˜Jšžœ˜——Jšœžœžœ˜(Jšœžœžœ™.Jšœ
žœ
˜Jšœ
žœ˜Jšžœ
˜—Jšœžœžœ˜(Jšœžœžœ™.Jšœ
žœ
˜Jšœ
žœ˜Jšžœ
˜—Jšœžœžœ˜(Jšœžœžœ™.Jšœ
žœ
˜Jšœ
žœ˜Jšžœžœ
žœ
žœžœ
žœ
˜FJšžœ
˜—Jšœžœžœ˜)Jš
œ˜Jš
œ3˜3Jš
œ-˜-Jš
œR˜RJš
œ-˜-——J˜Jšœžœ˜%Jšœžœ˜%Jšœžœ˜'Jšœžœ˜'Jšžœžœ˜%Jšžœžœ˜%J˜—š
Ÿ
œžœ	žœžœ	žœ˜WJšœžœ	žœ˜%Jš
œ	žœžœ
žœžœ
žœ
žœ˜=Jš
œžœžœ
žœžœ
žœ
žœ˜7Jšœ	žœ#˜/Jšœ
žœ8˜EJšœ	žœ
žœ˜0Jšœžœ
žœ˜2Jšœžœžœžœ˜5Jšœžœžœ-˜@Jšœ
žœžœ(˜:Jšœ
žœžœ'˜9Jšœžœžœ,˜?Jšœ	žœžœ,˜=Jšœžœžœ*˜:šœŸ
œ˜$Jšœžœ6˜?Jš
œ˜Jšœžœ
˜	Jš
œ˜Jš
œ=˜=šžœž˜Jšžœžœ
˜Jšžœžœ
˜Jšœžœ
žœ˜šœž
˜	Jšœžœ
˜Jšœžœ
˜šžœžœ
žœž˜$Jš
žœžœžœžœžœ˜^šžœžœžœ˜'Jš
œ8˜8JšœŸœ˜)Jšžœ˜—Jš
œ)˜)Jšžœ
˜—Jš
œ
˜
—Jš
œ˜šœž
˜Jšœžœ˜šžœžœ
žœž˜$Jšœžœ˜!šžœžœ˜"šžœ˜
Jšžœ8˜<Jšžœ;˜?—Jšžœ˜—Jš
œP˜PJšžœ
žœ
žœ˜&——Jšžœžœ˜——šžœžœ
žœž˜$Jšœžœ
žœ
žœ˜%Jšœžœ˜
Jšœžœ˜+Jšœžœ˜-šžœžœ
žœž˜)šžœžœ˜Jš
œ˜Jš
œ&˜&Jš
œ˜—Jš
œ˜Jšžœ
˜—Jšžœ
˜—Jšœ	Ÿœ˜0J˜šŸ
œžœ˜+Jšœžœ	žœ˜#JšΠbnœ˜Jšœ
žœžœ/˜Ešžœ&žœžœ
ž˜FJš
žœžœ
žœ#žœžœ˜R——J˜šŸœžœ˜,Jšœžœ	žœ˜#Jšœžœžœ'˜>šžœžœ
žœž˜$š
žœžœžœžœžœ˜HJšœžœžœ/˜FJšœžœžœ1˜H—šžœžœ
žœž˜(Jšœžœžœ1˜HJšœžœžœžœ˜<Jšžœ
˜—Jšžœ
˜—Jšœžœžœ/˜FJš
œ7˜7—J™š‘œžœ
žœ˜?Jšœžœ	žœ˜%Jšœ	žœ˜Jšœ
žœ˜!Jšœ
žœ˜$Jš
œ˜Jš
œ˜Jš
žœžœ
žœžœ'žœ
˜SJšžœžœ
žœ
˜"šžœ&žœžœ
ž˜:Jšžœžœžœ˜3Jšœžœ
˜—Jš
œ.˜.—J˜šŸœžœžœ	˜1Jšžœžœžœ
žœ
˜CJš
œ
˜
šžœžœ
žœž˜$Jšœžœ˜*Jšžœžœ˜+Jšžœ˜
——J˜š
Ÿœžœžœžœžœ˜RJšœžœ˜šžœžœ
žœž˜%Jšžœžœ
žœ
˜#Jš
œ˜Jš
œ˜Jšžœžœ
žœ˜#Jšžœ
˜—Jšžœ	žœ
žœ =˜TJšžœ	žœ
žœ ˜.Jš
žœžœžœ
žœ
žœ˜-Jšžœ	 5˜D—J˜Jšœžœ
˜Jš	œžœžœ	žœ
žœ˜8Jšœžœžœ	žœ˜6Jš	œžœžœžœ
žœ˜9Jšœžœ ˜-Jšœžœ‰
˜ž
J˜šŸœžœ
žœ	žœ˜=š
Ÿœžœžœžœ
žœ˜+Jšœ
žœ
žœ,˜6—Jš
œ4˜4Jšžœ
žœ
žœ
žœ˜,Jš
œ.˜.Jšœžœ˜šžœžœž˜Jšœžœžœ
˜'—J˜Jšœžœ˜6Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœžœ˜0Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœžœ˜0Jš
œ˜Jš
œ˜Jšœžœ˜4J˜Jšœž
œ˜FJš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœž
œ˜DJš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœž
œ˜BJš
œ˜Jš
œ˜Jšœž
œ˜DJ˜Jšœžœ˜3Jšœžœ˜1Jšœžœ˜3Jšœžœ˜/Jšœžœ˜3Jšœžœ
˜+Jšœžœ˜/Jšœžœ˜1Jšœžœ˜,Jšœžœ˜/Jšœžœ˜0Jšœžœ˜1Jšœžœ˜/Jšœžœ˜4Jšœžœ˜1Jšœžœ˜1J˜šžœžœž˜-Jš
œ2˜2Jšœ3žœ
˜;—J˜Jš
œ˜Jš
œ˜Jšœžœ
˜/J˜Jš
œ˜Jš
œ˜Jšœž
œ˜DJ˜Jšœžœ˜3Jšœžœ˜1Jšœžœ˜3Jšœžœ˜/Jšœžœ˜3Jšœžœ
˜+Jšœžœ˜/Jšœžœ˜1Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ.˜.Jš
œ˜Jš
œ˜Jšœžœ
˜.J˜Jš
œ˜—J™Jšœžœ
žœ˜$J˜Jšžœ
˜J˜——…—Dβ\Ή