DIRECTORY 
AlpsBool, CD, CDBasics, CDCells, CDDirectory, CDOrient, CDPinObjects, CDProperties, CMos, MC, MCCtl, MCMInterface, MCPadFrame, Onion, PW, PWPins, Rope;

MCGen: CEDAR PROGRAM
IMPORTS CD, CDBasics, CDCells, CDDirectory, CDOrient, CDPinObjects, CDProperties, CMos, MC, MCCtl, MCMInterface, MCPadFrame, Onion, PW, PWPins, Rope= 
BEGIN OPEN PW;

ROPE: TYPE = Rope.ROPE;
l: INT = CD.lambda;

MapCacheArray: PROC [design: CD.Design, nLines, nCamColumns, nRamColumns: INT] RETURNS [ObPtr] = {
pbusix: INT;

RepeatingCell: PROC [cell: ObPtr] RETURNS [ObPtr] = INLINE {
RETURN[AbutY[design, FlipY[design, cell], cell]];
};

PBusName: PWPins.RenameProc = {
SELECT TRUE FROM
Rope.Equal[oldRope, "bus"] => newRope _ MC.IndexedName["PBus", pbusix];
Rope.Equal[oldRope, "adrsInLineMSB"] => newRope _ "PBus[20]";
Rope.Equal[oldRope, "adrsInLineLSB"] => newRope _ "PBus[21]";
ENDCASE => newRope _ oldRope;
};


Ram: PROC[nColumns, nLines: INT] RETURNS [ObPtr] = {
ramCell: ObPtr _ Get[design, "SRamTwoBits"];
ramTop: ObPtr _ Get[design, "RamTop"];
ramColumn: ObPtr _ ArrayY[design, ramCell, nLines];
ramDualColumn: ObPtr _ AbutY[design,
AbutX[design, ramColumn, ramColumn],
ramTop];
renamedDualColumn, result: ObPtr;

pbusix _ 0;
result _ PWPins.RenamePins[design, ramDualColumn, PBusName];
pbusix _ pbusix+1;
THROUGH [2..nColumns/2] DO
renamedDualColumn _ PWPins.RenamePins[design, ramDualColumn, PBusName];
result _ AbutX[design, result, renamedDualColumn];
pbusix _ pbusix+1;
ENDLOOP;

RETURN[result];
};


PowerStrap: PROC[nLines: INT] RETURNS[ObPtr] = {
powerStrapCell: ObPtr _ Get[design, "PowerStrap"];
repeatingCell: ObPtr _ AbutY[design, FlipY[design, powerStrapCell], powerStrapCell];
powerStrapTop: ObPtr _ Get[design, "PowerStrapTop"];
RETURN[AbutY[design,
ArrayY[design, repeatingCell, nLines/2],
powerStrapTop]];
};

RamAccess: PROC[nLines: INT] RETURNS [ObPtr] = {
ramAccessCell: ObPtr _ Get[design, "RamAccessCore"];
repeatingCell: ObPtr _ AbutY[design, FlipY[design, ramAccessCell], ramAccessCell];
ramAccessCtlTop: ObPtr _ Get[design, "RamAccessCtlTop"];

ramAccessCtlTop _ PWPins.RenamePins[design, ramAccessCtlTop, PBusName];
RETURN[AbutY[design,
ArrayY[design, repeatingCell, nLines/2],
ramAccessCtlTop]];
};

Cam: PROC[nColumns, nLines: INT] RETURNS [ObPtr] = {
groupSize: INT = 10;	-- number of cells between straps to metal2
nGroups: INT = nColumns/groupSize;
nRemainingColumns: INT = nColumns MOD groupSize;
column, strapColumn, renamedColumn: ObPtr; 
camBitCell: ObPtr _ Get[design, "SCamBit"];
camBitTop: ObPtr _  Get[design, "CamTop"];
camStrapCell: ObPtr _ Get[design, "SCamStrap"];
camStrapTop: ObPtr _ Get[design, "SCamStrapTop"];
result: ObPtr;

column _ AbutY[design,
ArrayY[design, RepeatingCell[camBitCell], nLines/2],
camBitTop];
strapColumn _ AbutY[design,
ArrayY[design, RepeatingCell[camStrapCell], nLines/2],
camStrapTop] ;


pbusix _ 0;
result _ strapColumn;
THROUGH [1..groupSize] DO
renamedColumn _ PWPins.RenamePins[design, column, PBusName];
result _ AbutX[design, result, renamedColumn];
pbusix _ pbusix+1;
ENDLOOP;
 
THROUGH [2..nGroups] DO
result _ AbutX[design, result, strapColumn];
THROUGH [1..groupSize] DO
renamedColumn _ PWPins.RenamePins[design, column, PBusName];
result _ AbutX[design, result, renamedColumn];
pbusix _ pbusix+1;
ENDLOOP;
ENDLOOP;

THROUGH [1..nRemainingColumns] DO
renamedColumn _ PWPins.RenamePins[design, column, PBusName];
result _ AbutX[design, result, renamedColumn];
pbusix _ pbusix+1;
ENDLOOP;

result _ AbutX[design, result, strapColumn];
RETURN[result];
};

VPValid: PROC [nLines: INT] RETURNS [ObPtr] = {
vpValidCoreCell: ObPtr _ Get[design, "VPValidCore"];
vpValidTop: ObPtr _ Get[design, "VPValidTop"];
RETURN[AbutY[design,
ArrayY[design, RepeatingCell[vpValidCoreCell], nLines/2],
vpValidTop]];
};

CamAccess: PROC [nLines: INT] RETURNS [ObPtr] = {
camAccessCell: ObPtr _ Get[design, "CAMAccessCore"];
camAccessTop: ObPtr _ Get[design, "CamAccessTop"];
RETURN[AbutY[design,
ArrayY[design, RepeatingCell[camAccessCell], nLines/2],
camAccessTop]];
};

RPValid: PROC [nLines: INT] RETURNS [ObPtr] = {
rpValidCoreLeftCell: ObPtr _ Get[design, "RPValidCoreLeft"];
rpValidTopLeft: ObPtr _ Get[design, "RPValidTopLeft"];
rpValidCoreBitCell: ObPtr _ Get[design, "RPValidCoreBit"];
rpValidTop: ObPtr _ Get[design, "RPValidTop"];
rpValidCoreCell: ObPtr;
 
rpValidTop _ PWPins.RenamePins[design, rpValidTop, PBusName];
rpValidCoreCell _ rpValidCoreLeftCell;
THROUGH [1..MC.nEntriesPerLine] DO
rpValidCoreCell _ AbutX[design, rpValidCoreCell, rpValidCoreBitCell];
ENDLOOP;
RETURN[AbutY[design,
ArrayY[design, RepeatingCell[rpValidCoreCell], nLines/2],
AbutX[design, rpValidTopLeft, rpValidTop]]];
};

Ref: PROC [nLines: INT] RETURNS [ObPtr] = {
refCoreCell: ObPtr _ Get[design, "RefCore"];
refTop: ObPtr _ Get[design, "RefTop"];
RETURN[AbutY[design,
ArrayY[design, RepeatingCell[refCoreCell], nLines/2],
refTop] ];
};

Adrs: PROC [nLines: INT] RETURNS [ObPtr] = {

DecoderFunction: XYFunction = {
op: ObPtr;
IF XthBitOfN[nCols-1-x, y]
THEN op _ adrsDecoderOneCell
ELSE op _ adrsDecoderZeroCell;
IF XthBitOfN[0, y]
THEN RETURN[op]
ELSE RETURN[FlipY[design, op]];
};

adrsGndLeftCell: ObPtr _ Get[design, "AdrsGndLeft"];
adrsGndLeftTop: ObPtr _ Get[design, "AdrsGndLeftTop"];
adrsDecoderZeroCell: ObPtr _ Get[design, "AdrsDecoderZero"];
adrsDecoderOneCell: ObPtr _ Get[design, "AdrsDecoderOne"];
adrsDecoderBitTop: ObPtr _ Get[design, "AdrsDecoderBitTop"];
adrsGndRightCell: ObPtr _ Get[design, "AdrsGndRight"];
adrsGndRightTop: ObPtr _ Get[design, "AdrsGndRightTop"];
adrsDriverCell: ObPtr _ Get[design, "AdrsDriver"];
adrsDriverTop: ObPtr _ Get[design, "AdrsDriverTop"];
gndLeftColumn, gndRightColumn, driverColumn, top: ObPtr;
col, nCols: INT;

NewName: PWPins.RenameProc = {
SELECT TRUE FROM
Rope.Equal[oldRope, "adrs"] => newRope _ MC.IndexedName["ArrayAdrsxAB", col];
ENDCASE => newRope _ oldRope;
};


nCols _ IF nLines=TwoToTheLog2[nLines] THEN Log2[nLines] ELSE Log2[nLines]+1;
gndLeftColumn _ ArrayY[design, RepeatingCell[adrsGndLeftCell], nLines/2];
gndRightColumn _ ArrayY[design, RepeatingCell[adrsGndRightCell], nLines/2];
driverColumn _ ArrayY[design, RepeatingCell[adrsDriverCell], nLines/2];

top _ adrsGndLeftTop; col _ 0;
THROUGH [1..nCols] DO
renamed: ObPtr _ PWPins.RenamePins[design, adrsDecoderBitTop, NewName];
top _ AbutX[design, top, renamed];
col _ col+1;
ENDLOOP;

top _ AbutX[design, top, adrsGndRightTop, adrsDriverTop];

RETURN[AbutY[design,
 AbutX[design, gndLeftColumn, MapFunction[design, DecoderFunction, 0, nCols, 0, nLines], gndRightColumn, driverColumn],
top]];
};
RETURN[AbutListX[design, LIST[Adrs[nLines], Ref[nLines], RPValid[nLines], CamAccess[nLines], VPValid[nLines], Cam[nCamColumns, nLines], RamAccess[nLines], PowerStrap[nLines], Ram[nRamColumns, nLines]]]];
};

inputs: LIST OF ROPE _ LIST[
"Incr", "ArrayAdrsxBA[4]", "ArrayAdrsxBA[3]", "ArrayAdrsxBA[2]", "ArrayAdrsxBA[1]", "ArrayAdrsxBA[0]",
"nMAdCyclexBA",
"MCmdxBA[0]", "MCmdxBA[1]", "MCmdxBA[2]", "MCmdxBA[3]",
"MCSelectedxBA",
"MDataxBA[2]", "MDataxBA[3]", "MDataxBA[4]", "MDataxBA[5]",
"CyclexBA[0]", "CyclexBA[1]", 
"CyclexAB[0]", "CyclexAB[1]",
"arrayMatchxAB",
"wtProtectFlag",
"ResetxBA", "ResetxAB"];

MapCacheControl: PROC [design: CD.Design] RETURNS [result: ObPtr] = {

alpsResult, alpsResultLatchandDrive, feedBack, feedBackLatchandDrive: CD.ObPtr;


fedBackSignals: LIST OF ROPE _ LIST ["CyclexAB[0]", "CyclexAB[1]", "CyclexBA[0]", "CyclexBA[1]", "ArrayAdrsxAB[0]", "ArrayAdrsxAB[1]", "ArrayAdrsxAB[2]", "ArrayAdrsxAB[3]", "ArrayAdrsxAB[4]",  "ResetxBA"];
arrayDrivenSignals: LIST OF ROPE _ LIST ["Incr", "arrayMatchxBA", "wtProtectFlag"];
table: AlpsBool.TableOfVariables _ MCCtl.CreateTable[inputs];

MCCtl.Microcode[table];
MCCtl.Counter[table];
MCCtl.StateMachine[table];

table _ MCCtl.Permute[table, permuteFast];
alpsResult _ Rot270[design, MCCtl.GenerateLayout[design, table]];
alpsResultLatchandDrive _ MCCtl.MakeAlpsLatchandDrive[design, alpsResult];
feedBackLatchandDrive _ MCCtl.MakeFeedBackLatchandDrive[design, MCCtl.ListCat[fedBackSignals, arrayDrivenSignals]];
feedBack _ MCCtl.MakeFeedBack[design, alpsResult, feedBackLatchandDrive];

result _ AbutX[design,
AbutY[design, feedBackLatchandDrive, feedBack],
AbutY[design, alpsResultLatchandDrive, alpsResult]];
result _ PWPins.RenamePins[design, result];

MCCtl.InitCtlOutNames[];
MCCtl.AddTableToCtlOutNames[table];
MCCtl.AddListToCtlOutNames[arrayDrivenSignals];
};
busNames: LIST OF ROPE _ NIL;

MapCacheBuses: PROC [design: CD.Design, len: INT] RETURNS [result: ObPtr] = {
layer: CD.Layer _ CMos.met2;
wireLength: INT _ len;
wireThickness: INT _ 4*2;
wireSeparation: INT _ 5*2;
busNames _ MCCtl.ctlOutNames;
busNames _ MCCtl.ListCat[LIST["phA", "nphA", "phB", "nphB", "Vnbias", "Vpbias", "NotDebug"], busNames];


FOR i: INT DECREASING IN [0..24] DO busNames _ CONS[MC.IndexedName["PBus", i], busNames] ENDLOOP;

busNames _ MCCtl.ListCat[LIST["VBus.VPV", "VBus.RPV"], busNames];

result _ MC.MakeBusX[design, layer, busNames, wireLength, wireThickness, wireSeparation];

result _ PWPins.RenamePins[design, result];

};





RingWidth: Onion.RingWidthProc -- [netName: ROPE] RETURNS [ringWidth: D2Basic.Number] --  = {
ringWidth _ IF Rope.Equal[netName, "Vdd"] THEN MC.VddRingWidth ELSE IF Rope.Equal[netName, "Gnd"] THEN MC.GndRingWidth ELSE 8;
};

SelectInnerPins: PWPins.RenameProc -- [oldRope: ROPE] RETURNS [newRope: ROPE] --  = {
IF Rope.Equal[oldRope, "Vdd"] OR Rope.Equal[oldRope, "Gnd"] OR Rope.Equal[oldRope, "drMBusxBA"] THEN RETURN[oldRope];
SELECT TRUE FROM
Rope.Equal["vdd", oldRope] 		=> RETURN["Vdd"];
Rope.Equal["gnd", oldRope] 		=> RETURN["Gnd"];
Rope.Match["MExt[*].dataIn", oldRope] 	=> RETURN[oldRope];
Rope.Match["MExt[*].dataOut", oldRope] 	=> RETURN[oldRope];
Rope.Match["MCmd[*].dataIn", oldRope] 	=> RETURN[oldRope];
Rope.Match["MCmd[*].dataOut", oldRope] 	=> RETURN[oldRope];
Rope.Match["MData[*].dataIn", oldRope] 	=> RETURN[oldRope];
Rope.Match["MData[*].dataOut", oldRope] 	=> RETURN[oldRope];
Rope.Equal["MCSelected.dataIn", oldRope]	=> RETURN["MCSelected"];
Rope.Equal["Reset.dataIn", oldRope]		=> RETURN["Reset"];
Rope.Equal["Reset.dataOut", oldRope]		=> RETURN["Reset"];
Rope.Equal["nMAdCycle.dataIn", oldRope]	=> RETURN["nMAdCycle"];
Rope.Equal["nMAdCycle.dataOut", oldRope]	=> RETURN["nMAdCycle"];
Rope.Match["CycleABZeroxAB", oldRope] 	=> RETURN[NIL];
ENDCASE				=> {};
FOR names: LIST OF ROPE _ MCPadFrame.padNames, names.rest WHILE names#NIL DO
IF Rope.Equal[names.first, oldRope] THEN RETURN[oldRope];
ENDLOOP;
FOR names: LIST OF ROPE _ busNames, names.rest WHILE names#NIL DO
IF Rope.Equal[names.first, oldRope] THEN RETURN[oldRope];
ENDLOOP;
FOR names: LIST OF ROPE _ inputs, names.rest WHILE names#NIL DO
IF Rope.Equal[names.first, oldRope] OR Rope.Equal[Rope.Cat["Not", names.first], oldRope] THEN RETURN[NIL];
ENDLOOP;
newRope _ NIL; MC.TTYOut[" killed ", oldRope, " "];
};

Channel: PUBLIC PROC [design: CD.Design, bottomOb, topOb: CD.ObPtr, size: INT, params: Onion.LayersParameters _ Onion.channelDefaultParameters] RETURNS [cell: CD.ObPtr] = {
bottomObRect: CD.Rect _ CD.InterestRect[bottomOb];
topObRect: CD.Rect _ CD.InterestRect[topOb];

inner: CD.ObPtr _ CDCells.CreateEmptyCell[];
outer: CD.ObPtr _ CDCells.CreateEmptyCell[];

KeepInner: PWPins.AppEnumerator -- [app: CD.ApplicationPtr] RETURNS [quit: BOOL _ FALSE] -- = {
name: ROPE _ CDPinObjects.GetName[app];
realSize: CD.Position _ CDOrient.OrientedSize[app.ob.size, app.orientation]; 
location: CD.Position _ CDBasics.SubPoints[app.location, CDBasics.BaseOfRect[bottomObRect]];
IF PWPins.GetSide[bottomOb, app].side#PWPins.top THEN RETURN;
IF CDPinObjects.GetLayer[app]#params.radialLayer	THEN {
Output["*** Top Pin ", name, " on BottomOb discarded: not of radialLayer material.\n"];
RETURN;
};
[] _ Onion.IncludePin[inner, name, CDPinObjects.GetLayer[app], realSize, location];
};
KeepOuter: PWPins.AppEnumerator -- [app: CD.ApplicationPtr] RETURNS [quit: BOOL _ FALSE] -- = {
name: ROPE _ CDPinObjects.GetName[app];
realSize: CD.Position _ CDOrient.OrientedSize[app.ob.size, app.orientation]; 
location: CD.Position _ CDBasics.SubPoints[app.location, CDBasics.BaseOfRect[topObRect]];
IF PWPins.GetSide[topOb, app].side#PWPins.bottom THEN RETURN;
IF CDPinObjects.GetLayer[app]#params.radialLayer	THEN {
Output["*** Bottom Pin ", name, " on TopOb discarded: not of radialLayer material.\n"];
RETURN;
};
[] _ Onion.IncludePin[outer, name, CDPinObjects.GetLayer[app], realSize, location];
};
[] _ PWPins.EnumerateEdgePins[bottomOb, KeepInner];
[] _ Onion.IncludeOb[inner, bottomOb, [0, 0]];
[] _ CDCells.RepositionCell[inner, NIL];
[] _ CDDirectory.Include[design, inner, "BottomInner"];

[] _ PWPins.EnumerateEdgePins[topOb, KeepOuter];
[] _ Onion.IncludeOb[outer, topOb, [0, 0]];
CDCells.SetInterestRect[outer, [0, -(bottomObRect.y2-bottomObRect.y1+size), MAX[bottomObRect.x2-bottomObRect.x1, topObRect.x2-topObRect.x1], 0]];
[] _ CDCells.RepositionCell[outer, NIL];
[] _ CDDirectory.Include[design, outer, "TopOuter"];

cell _ Onion.LRSRoute[design, inner, outer, [0, 0], params].cell;
CDCells.SetInterestRect[cell, [0, 0, PW.Size[cell].x, PW.Size[cell].y+topObRect.y2-topObRect.y1]];

};

KeepPinsOnRight: PUBLIC PROC [design: CD.Design, ob: CD.ObPtr] RETURNS [cell: CD.ObPtr] = 
BEGIN
cellPtr: CD.CellPtr;
KeepPinOnEdge: PWPins.AppEnumerator -- [app: CD.ApplicationPtr] RETURNS [quit: BOOL _ FALSE] --  = {
newApp: CD.ApplicationPtr;
name: ROPE _ CDPinObjects.GetName[app];
IF PWPins.GetSide[ob, app].side#PWPins.right THEN RETURN;
newApp _ NEW[CD.Application _ [
ob: CDPinObjects.CreatePinOb[app.ob.size], 
location: app.location, orientation: app.orientation, 
properties: CDProperties.CopyProps[app.properties]]];
CDPinObjects.SetName[newApp, name];
cellPtr.contents _ CONS[newApp, cellPtr.contents];
};

app: CD.ApplicationPtr _ NEW[CD.Application _ [ob: ob]];
CDProperties.PutPropOnApplication[app, $StopEnumerateDeepPins, $StopEnumerateDeepPins];
cell _ CDCells.CreateEmptyCell[]; cellPtr _ NARROW[cell.specificRef];
[] _ PWPins.EnumerateEdgePins[ob, KeepPinOnEdge];
cellPtr.contents _ CONS[app, cellPtr.contents];
CDCells.SetInterestRect[cell, CD.InterestRect[ob]];
[] _ CDCells.RepositionCell[cell, NIL];
[] _ CDDirectory.Include[design, cell, "KeepPinsOnRight"];
END;


MakeMapCache: UserProc = {
mc, mcCtl, topToBus, mcArray, arrayToBus, mcBus, mcTop, mcMInterface, mcCtlToInterfaceGlue, frame, copyrightSign, myName: PW.ObPtr;
mcSize: CD.Position;


params: Onion.LayersParameters _ NEW[Onion.LayersParametersRec _ Onion.defaultLayersParameters^];
params.ringWidth _ RingWidth;
params.wireExtendProc _ Onion.WireExtendMetToMet;

SetDefaultSource[design, OpenDesign["///MapCacheCellLibrary.dale"]];

mcArray _ MapCacheArray[design, MC.nLines, MC.nCamColumns, MC.nRamColumns];
mcCtl _ MapCacheControl[design];
mcMInterface _ MCMInterface.MBusInterface[design, PW.Size[mcCtl].y];
mcCtlToInterfaceGlue _ MCMInterface.AlpsToMBusInterfaceGlue[design, mcCtl];
mcTop _ AbutX[design, mcCtl, mcCtlToInterfaceGlue, mcMInterface];
mcSize.x _ MAX[PW.Size[mcArray].x, PW.Size[mcTop].x]+16;

mcTop _ AbutX[design, mcTop, MC.RightFillerCell[design, mcTop, mcSize.x-PW.Size[mcTop].x]];
mcArray _ AbutX[design, mcArray, MC.RightFillerCell[design, mcArray, mcSize.x-PW.Size[mcArray].x]];

mcBus _ MapCacheBuses[design, mcSize.x];
arrayToBus _ MC.ConnectTopToBus[design, mcArray, mcBus];
topToBus _ MC.ConnectBotToBus[design, mcTop, mcBus];
mcBus _ KeepPinsOnRight[design, mcBus];
mc _ PW.CreateEmptyCell[];
mcSize.y _ PW.Size[mcArray].y+2*PW.Size[mcBus].y+PW.Size[mcTop].y;
PW.IncludeInCell[design, mc, mcArray, [0, 0]];
PW.IncludeInCell[design, mc, arrayToBus, [0, PW.Size[mcArray].y]];
PW.IncludeInCell[design, mc, mcBus, [0, PW.Size[mcArray].y]];
PW.IncludeInCell[design, mc, mcBus, [0, PW.Size[mcArray].y+PW.Size[mcBus].y]];
PW.IncludeInCell[design, mc, topToBus, [0, PW.Size[mcArray].y+PW.Size[mcBus].y]];
PW.IncludeInCell[design, mc, mcTop, [0, PW.Size[mcArray].y+2*PW.Size[mcBus].y]];
CDCells.SetInterestRect[mc, [0, 0, mcSize.x, mcSize.y]];
PW.IncludeInDirectory[design, mc, "mc"];
mc _ PWPins.RenamePins[design, mc, SelectInnerPins];
mc _ Onion.MakeInner[design, mc]; 
mc _ MCPadFrame.Shell[design, mc];
mc _ Onion.MakeInner[design, mc]; 

MC.TTYOut["\nMap Cache Generation Done.\n"];
frame _ MCPadFrame.PadFrame[design];
mc _ Onion.LRSRoute[design, mc, frame, Onion.Center[mc, frame], params].cell;
SetDefaultSource[design, OpenDesign["///MCLogo.dale"]];
copyrightSign _ PW.Get[design, "copyrightSign"];
myName _ PW.Get[design, "myName"];
PW.IncludeInCell[design, mc, copyrightSign, [-500*l, 0], 2];
PW.IncludeInCell[design, mc, myName, [PW.Size[mc].x+300*l, 5*l], 6];
RETURN[mc];
};

MakeMapCacheArray: UserProc = {
SetDefaultSource[design, OpenDesign["///MapCacheCellLibrary.dale"]];
RETURN[MapCacheArray[design, 4, 4, 4]];
};

MakeMapCacheControl: UserProc = {
SetDefaultSource[design, OpenDesign["///MapCacheCellLibrary.dale"]];
RETURN[MapCacheControl[design ]];
};

MakePadFrame: UserProc = {
SetDefaultSource[design, OpenDesign["///MapCacheCellLibrary.dale"]];
RETURN[MCPadFrame.PadFrame[design]];
};

SimpleTest: UserProc = {
SetDefaultSource[design, OpenDesign["///MapCacheCellLibrary.dale"]];
RETURN[MCMInterface.AlpsToMBusInterfaceGlue[design, MapCacheControl[design]]];
};

Register[MakePadFrame, "MakePadFrame"];
Register[MakeMapCacheArray, "MakeMapCacheArray"];
Register[MakeMapCacheControl, "MakeMapCacheControl"];
Register[MakeMapCache, "MakeMapCache"];
Register[SimpleTest, "SimpleTest"];


END.

FMCGen.mesa
Copyright c 1984 by Xerox Corporation.  All rights reserved.
Written by: Sindhu, June 7, 1985 10:48:56 pm PDT
Last Edited by: Sindhu, July 14, 1985 10:36:23 pm PDT
Last Edited by: Serlet, July 11, 1985 2:08:43 am PDT

-- Descriptors for the pad frame
This is a hack that'll work only for this version; must fix for later


counter inputs (should go away in version 2 of Map Cache)

normal inputs

Get each generator to put its outputs into table
MCCtl.Order[table]; -- omit order for debugging version
Optimize the table as required
table _ MCCtl.Permute[table, permuteAllCases];

Record the alps outputs and the array driven signals in ctlOutNames


CtlOut Signals

Utility Signals
RBus Signals  omit for debugging version
FOR i: INT DECREASING IN [0..31] DO busNames _ CONS[MC.IndexedName["RBus", i], busNames] ENDLOOP;
QBus Signals  omit for debugging version
FOR i: INT DECREASING IN [0..9] DO busNames _ CONS[MC.IndexedName["QBus", i], busNames] ENDLOOP;

PBus Signals
VBus Signals
Now rename all the pins so they'll pop out to the topmost level



-- include the logo
สบ–

"cedar" style˜
code™
Kšœ
ฯm
œ1™<K™0K™5J™4K™—K˜šฯk	œ
˜
Kšœ
žœNžœ*žœ˜—
—K˜•StartOfExpansion[]šฯbœžœ
ž˜KšžœQžœ*žœ˜–
Kšžœ
žœ
žœ
˜K˜Kšžœžœžœ
˜Jšฯg
œžœžœ˜J™ K˜šฯn
œžœ
žœžœžœ
žœžœ˜bKšœžœ
˜K˜šก
œžœžœžœ˜<Kšžœ+˜1Kš
œ˜—K˜šŸœ˜šžœ
žœ
ž˜Jšœ(žœ˜GJš
œ=˜=Jš
œ=˜=Jšžœ˜—J˜—K˜K˜šกœžœžœžœ˜4Kš
œ,˜,K˜&Kš
œ3˜3˜$K˜$K˜—Kš
œ!˜!K˜Kš
œ˜Kš
œ<˜<K˜šžœž˜Kš
œG˜GKš
œ2˜2K˜Kšžœ
˜—K˜Kšžœ	˜Kš
œ˜—K˜K˜šก
œžœ	žœžœ˜0Kš
œ2˜2Kš
œT˜TKš
œ4˜4šžœ˜Kš
œ(˜(Kš
œ˜—K˜K˜—šก	œžœ	žœžœ˜0Kš
œ4˜4Kš
œR˜RK˜8K˜Kš
œG˜Gšžœ˜Kš
œ(˜(Kš
œ˜—Kš
œ˜K˜—šกœžœžœžœ˜4Kšœžœฯc+˜@Kšœ	žœ˜"Kšœžœžœ˜0Kš
œ+˜+Kš
œ+˜+Kš
œ*˜*Kš
œ/˜/Kš
œ1˜1Kš
œ˜K˜š
œ˜Kš
œ4˜4Kš
œ˜—š
œ˜Kš
œ6˜6Kš
œ˜—K˜K˜K™EK˜Kš
œ˜šžœž˜Kš
œ<˜<Kš
œ.˜.K˜Kšžœ
˜K˜
—šžœž˜Kš
œ,˜,šžœž˜Kš
œ<˜<Kš
œ.˜.K˜Kšžœ
˜—Kšžœ
˜—K˜šžœž˜!Kš
œ<˜<Kš
œ.˜.K˜Kšžœ
˜—K˜Kš
œ,˜,Kšžœ	˜K™Kš
œ˜—K˜šกœžœ
žœžœ˜/Kš
œ4˜4K˜.šžœ˜Kš
œ9˜9Kš
œ
˜
—Kš
œ˜—K˜šก	œžœ
žœžœ˜1Kš
œ4˜4Kš
œ2˜2šžœ˜Kš
œ7˜7Kš
œ˜—Kš
œ˜—K˜šกœžœ
žœžœ˜/Kš
œ<˜<Kš
œ6˜6Kš
œ:˜:Kš
œ.˜.Kš
œ˜K˜
Kš
œ=˜=Kš
œ&˜&šžœžœž˜"K˜EKšžœ
˜—šžœ˜Kš
œ9˜9Kš
œ,˜,—Kš
œ˜—K˜šกœžœ
žœžœ˜+Kš
œ,˜,Kš
œ&˜&šžœ˜Kš
œ5˜5Kš
œ
˜
—Kš
œ˜—K˜šกœžœ
žœžœ˜,K˜šŸœ˜Kš
œ
˜
šžœ˜Kšžœ˜Kšžœ˜—šžœ˜Kšžœ
žœ˜Kšžœ
žœ˜—Kš
œ˜—K˜Kš
œ4˜4Kš
œ6˜6Kš
œ<˜<Kš
œ:˜:Kš
œ<˜<Kš
œ6˜6Kš
œ8˜8Kš
œ2˜2Kš
œ4˜4Kš
œ8˜8Kšœžœ
˜K˜šŸœ˜šžœ
žœ
ž˜Jšœ)žœ"˜MJšžœ˜—J˜—K˜K˜Kšœžœžœžœ˜MK˜IK˜KK˜GK˜K˜šžœž˜Kš
œG˜GK˜"K˜Kšžœ
˜—K˜Kš
œ9˜9K˜šžœ˜Kš
œw˜wKš
œ˜—Kš
œ˜—K™Kšžœžœฎ
˜ห
Kš
œ˜—J˜š	œžœ
žœ
žœžœ
˜Jš
œ9™9Jš
œf˜fJ™J™
Jš
œ˜J˜7J˜J˜;J˜J˜J˜Jš
œ˜Jš
œ˜—K˜šกœžœ
žœ	žœ˜EJ˜JšœFžœ˜OJ˜J˜Jš	œžœ
žœ
žœžœช
˜อ
Jš	œžœ
žœ
žœžœ,˜SJš
œ=˜=J˜J™J™0Jš
œ˜Jš
œ˜Jš
œ7™7Jš
œ˜J˜J™Jš
œ*˜*Jš
œ.™.J™Jš
œA˜AJš
œJ˜JJš
œs˜sJš
œI˜IJ˜š
œ˜Jš
œ/˜/Jš
œ4˜4—J˜+J˜J™CJš
œ˜Jš
œ#˜#Jš
œ/˜/Jš
œ˜—J™Jš	œ
žœ
žœ
žœžœ
˜K˜š
ก
œžœ
žœžœžœ˜MKšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜K™K™Kš
œ˜K™K™KšœžœJ˜gK˜K™)Kšžœžœ
ž
œ
žœ	žœžœ
žœ#žœ
™aK˜K™)Kšžœžœ
ž
œ
žœžœžœ
žœ#žœ
™`K™K™Kšžœžœ
ž
œ
žœ	žœžœ
žœ#žœ
˜aK˜K™Kšœžœ$˜AK˜Kšœ	žœN˜YK˜K™?K˜+K˜K˜—K˜J˜˜K˜—K˜–; -- [netName: ROPE] RETURNS [ringWidth: D2Basic.Number] -- šะbn	œะck:œ˜]Kšœžœžœ
žœžœ
žœžœ
žœžœ˜~K˜—K˜–/ -- [oldRope: ROPE] RETURNS [newRope: ROPE] -- šŸœค.œ˜UJš
žœžœžœ"žœ
žœ
˜ušžœ
žœ
ž˜Kšœ žœ˜.Kšœ žœ˜.Kšœ*žœ
˜:Kšœ+žœ
˜;Kšœ*žœ
˜:Kšœ+žœ
˜;Kšœ+žœ
˜;Kšœ,žœ
˜<Kšœ,žœ˜AKšœ(žœ
˜8Kšœ)žœ
˜9Kšœ+žœ˜?Kšœ,žœ˜@Kšœ*žœ
žœ˜6Kšžœ
˜—š
žœžœ
žœ
žœ#žœžœ
ž˜LKšžœ"žœ
žœ
˜9Jšžœ
˜—š
žœžœ
žœ
žœžœžœ
ž˜AKšžœ"žœ
žœ
˜9Jšžœ
˜—š
žœžœ
žœ
žœžœžœ
ž˜?Kš
žœ"žœ3žœ
žœ
žœ˜jJšžœ
˜—Kšœ
žœžœ"˜3K˜—K˜šกœžœ
žœ
žœžœžœCžœžœ˜ฌ
Jšœžœžœ˜2Jšœžœžœ˜,J˜Jšœžœ#˜,Jšœžœ#˜,J˜šŸ	œข;œ˜_Jšœžœ˜'Jšœ
žœA˜MJšœ
žœP˜\J–*[ob: 
CD.ObPtr, pin: 
CD.ApplicationPtr]šžœ/žœ
žœ
˜=šžœ/žœ˜7Jš
œW˜WJšžœ
˜J˜—Jš
œS˜SJ˜—šŸ	œข;œ˜_Jšœžœ˜'Jšœ
žœA˜MJšœ
žœM˜YJ–*[ob: 
CD.ObPtr, pin: 
CD.ApplicationPtr]šžœ/žœ
žœ
˜=šžœ/žœ˜7Jš
œW˜WJšžœ
˜J˜—Jš
œS˜SJ˜—Jš
œ3˜3Jš
œ.˜.Jšœ#žœ˜(Jš
œ7˜7J˜Jš
œ0˜0Jš
œ+˜+Jš
œ‘
˜‘
Jšœ#žœ˜(Jš
œ4˜4J˜Jš
œA˜AJšœ%žœžœ*˜bJ˜J˜—K˜šŸœžœ
žœ
žœ
žœžœžœ
˜ZJš
ž˜Jšœ	žœ	˜–= -- [app: CD.ApplicationPtr] RETURNS [quit: BOOL _ FALSE] -- šก
œค<œ˜dJšœžœ˜Jšœžœ˜'Jšžœ+žœ
žœ
˜9šœ	žœ
žœ˜Jš
œ+˜+Jš
œ6˜6Jš
œ5˜5—Jš
œ#˜#Jšœžœ˜2Jš
œ˜—J˜Jšœžœžœ
žœ˜8Jš
œW˜WJšœ,žœ˜EJš
œ1˜1Jšœžœ˜/Jšœžœ˜3Jšœ"žœ˜'Jš
œ:˜:Jšžœ
˜—K˜K˜šŸœ˜Kšœzžœ˜ƒ
Kšœžœ
˜K˜K˜Jšœ!žœ=˜aKš
œ˜Kš
œ1˜1K˜Kš
œD˜DK˜Kšœ žœ	žœžœ˜KKš
œ ˜ Kšœ2žœ˜DKš
œK˜KKš
œA˜AKšœžœ
žœžœ˜8K˜KšœHžœ˜[KšœNžœ˜cK˜Kš
œ(˜(Kšœ
žœ)˜8Kšœžœ'˜4K˜'K™Kšœžœ˜Kšœžœžœžœ˜BKšžœ,˜.Kšžœ+žœ˜BKšžœ&žœ˜=Kšžœ&žœžœ˜NKšžœ)žœžœ˜QKšžœ&žœžœ˜PKš
œ8˜8Kšžœ&˜(K™K˜4Kš
œ"˜"Kš
œ"˜"Kš
œ"˜"K™K˜Kšžœ*˜,Kš
œ$˜$Kš
œM˜MKš
œ™Kš
œ7˜7Jšœžœ˜0Jšœ	žœ˜"Jšžœ0 
œ	˜<Jšžœ6 
œ 
œ˜DKšžœ˜Kš
œ˜K˜—šŸœ˜Kš
œD˜DKšžœ!˜'K˜K˜—šŸœ˜!Kš
œD˜DKšžœ˜!K˜—K˜šŸœ˜Kš
œD˜DKšžœ˜$Kš
œ˜—K˜šŸ
œ˜Kš
œD˜DKšžœH˜NKš
œ˜K˜—Kš
œ'˜'Kš
œ1˜1Kš
œ5˜5Kš
œ'˜'Kš
œ#˜#K˜K˜Kšžœ
˜—K˜—…—DJZJ