
<<IFUPWControl.mesa>>
<<Copyright © 1985 by Xerox Corporation.  All rights resersed.>>
<<Last Edited by: Curry, January 21, 1986 4:38:16 pm PST>>
<<>>
DIRECTORY CD, CDFrame, IO, PLAOps, PW, PWRoute, Rope, SymTab;

IFUPWControl: CEDAR DEFINITIONS =
BEGIN 

Frame: TYPE = CDFrame.Frame;

DriveRec:        TYPE = RECORD[
name:            ROPE        _ NIL,        -- reference name
nameInv:        ROPE        _ NIL,        -- reference name
drDir:            Dir,    
gate:            DrGate    _ pos,
dualOut:        BOOL        _ FALSE,
in:                RelativeSignal _ [ ],
ref:            RelativeSignal _ [pol: pos], -- ph is latch phase
out:            RelativeSignal _ [ ],
pass:            BOOL        _ FALSE ];
<<>>
RelativeSignal: TYPE = RECORD[    -- relative to reference names
pol:            Polarity    _ unk,
ph:            Ph            _ unk,
cycle:            INT        _ unk ];

Ph:                TYPE = {A, B, AB, BA, Ac, Bc, unk};
DrGate:            TYPE = {neg, negAc, negBc, pos};
Dir:                TYPE = {in, out};                        -- into control, out to data
Polarity:            TYPE = {pos, neg, unk};                -- into control, out to data

ROPE:            TYPE = Rope.ROPE;
Side:                TYPE = CDFrame.Side;
unk:                INT   = -1;

PLADescription:        TYPE = REF PLADescriptionRec;    -- specific parameters and handles
PLADescriptionRec:    TYPE = RECORD [
name:                    ROPE                _ NIL,
design:                CD.Design        _ NIL,    -- input if from drivers or file
cell:                    CD.Object        _ NIL,
drFrame:                Frame                _ NIL,    -- input if from drivers
plaType:                PLAType            _ static,    -- input if from drivers
plaSpecFile:            ROPE                _ NIL,    -- input if from file
plaInNames:            LIST OF ROPE    _ NIL,    -- input if from file (optional)
plaOutNames:        LIST OF ROPE    _ NIL,    -- input if from file (optional)
drSignalOrder:        LIST OF ROPE    _ NIL,    -- input if from file (optional)
doCompleteSum:        BOOL                _ TRUE,    -- optional input
  csAddMerges:        BOOL                _ FALSE,    -- optional input
  csAddConsensus:    BOOL                _ FALSE,    -- optional input
doMinimization:        BOOL                _ FALSE,    -- optional input
  timeOutMinutes:    CARDINAL        _ 20,        -- optional input
ttt:                        PLAOps.PLA        _ NIL,    -- specific parameter
termsPerHeader:        INT                _ 1000,    -- specific parameter;
smlToBigOut:        XsFormSeq        _ NIL,    -- specific parameter
connSeq:                REF ConnSeq        _ NIL,    -- specific parameter
nofAndCols:            CARDINAL        _ 0,        -- specific parameter
nofOrCols:            CARDINAL        _ 0,        -- specific parameter
nofTermCols:            CARDINAL        _ 1,         -- static parameter
fullWidthTerms:        BOOL                _ FALSE,    -- static parameter
data:                    REF                _ NIL ];

RowType:    TYPE = {header, xheader, footer, xfooter, conn, dataUp, dataDn, blank, extend};
PLAType:    TYPE = {decoder, static, precharged};

XsFormSeq:            TYPE = REF XsFormSeqRec;
XsFormSeqRec:        TYPE = RECORD[SEQUENCE size: CARDINAL OF INT];
ConnSeq:            TYPE = RECORD[SEQUENCE size: CARDINAL OF Connection];
Connection:        TYPE = RECORD[
dr:                    REF DriveRec,
index:                INT,
isOutput:            BOOL,
isLeftSide:        BOOL ];

RefToDriverFrame:    PROC
[name: ROPE, xory: CDFrame.XorY, data, refRec: REF, unordered: BOOL, initial: DriveRec]
RETURNS[seq: Frame];
AccmPosAndAddDriversBasedOnShellSide:
PROC[drivers: Frame, shell: REF CDFrame.ShellRec, side: Side] RETURNS[Frame];
ReorderFrameBasedOnAvePos: PROC[frame: Frame];
ChanObj: PROC [
layer:    CD.Layer,
side:    Side,
ref:    REF    _ NIL,
ph:    Ph    _ unk,
dim:    INT            _ 0,
design:    CD.Design    _ NIL] RETURNS [cell: CD.Object];
DriverFill: PROC RETURNS[frame: Frame];
DriverExt: PROC[up: BOOL _ FALSE] RETURNS[frame: Frame];
DriverCell: PROC[plaType: PLAType, drRowType: RowType,
driver: REF DriveRec_NIL, design: CD.Design_NIL] RETURNS[cell: CD.Object];
BuildDrivers:            PROC[frame: Frame, design: CD.Design];
BitNameToSigName:    PROC[name: ROPE] RETURNS [ROPE];
ParsePinName:            PROC [name: ROPE] RETURNS [not: BOOL, root: ROPE, ph: Ph];

DriverPinType:    TYPE = {in, out0, out1};
DriverPinName:     PROC [type: DriverPinType, driver: REF DriveRec]    RETURNS [name: ROPE];
SignalName:        PROC [not: BOOL, positive, negative: ROPE, ph: Ph]    RETURNS [name: ROPE];

MakePLA: PROC[
name:        ROPE,            plaType: PLAType,    drIn, drInClk, plaIn, drOutClk, drOut: Ph_unk,
design:    CD.Design,    orCols:    INT_0,        termCols:    INT_1,
fullWidthTerms:    BOOL_FALSE,    termsPerHeader: INT _ 1000]
RETURNS[new: Frame];
DrPLA: PROC
[name: ROPE, pla: PLAOps.PLA, plaType: PLAType, plaIn, plaOut, drOut: Ph_unk]
RETURNS[new: Frame];
DrivenPLA: PROC [
drFrame:    Frame,        design:    CD.Design,
orCols:    INT_0,        termCols:    INT_1,
fullWidthTerms:    BOOL_FALSE,    termsPerHeader: INT _ 20]
RETURNS [new: Frame];

XferPins:                        PROC [
design:                CD.Design,
template:                PW.Object,
objSide:                Side,
routingLayerDes:    Rope.ROPE,
minWidth:            INT]
RETURNS [cell: PW.Object _ NIL];

MergePwrPins:    PROC [
design:                CD.Design,
vgTemplate:            PW.Object,
pinTemplate:            PW.Object,
pinTemplateSide:    Side,
routingLayerDes:    Rope.ROPE _ NIL,
minWidth:            INT _ 0]
RETURNS [cell: PW.Object _ NIL];

IncludeRecursiveInDesign: PROC [design: CD.Design];
DeleteUnusedStaticInDrs:    PROC [desc: PLADescription, drs: Frame];
MakeStaticPLASection:        PROC [desc: PLADescription];
<<>>
BuildFrame: CDFrame.SpecificFrameProc;

END.