DIRECTORY BitOps, CD, CDBasics, CDCells, CDCommandOps, CDDirectory, CDEvents, CDProperties, CDSequencer, Core, CoreClasses, CoreFlat, CoreGeometry, CoreOps, CoreProperties, HashTable, IntHashTable, IO, Ports, Rope, Rosemary, RosemaryUser, Sisyph, TerminalIO, TiogaButtons, ViewerClasses, ViewerOps;

SchematicSimulation: CEDAR PROGRAM
IMPORTS BitOps, CDBasics, CDCells, CDCommandOps, CDDirectory, CDEvents, CDProperties, CoreClasses, CoreFlat, CoreGeometry, CoreOps, CoreProperties, HashTable, IntHashTable, IO, Ports, Rope, Rosemary, RosemaryUser, Sisyph, TerminalIO, TiogaButtons, ViewerOps
= BEGIN 

SchSimError: ERROR [msg: Rope.ROPE] = CODE;

SchSimDebug: BOOL _ FALSE;
SchematicSimulationValue: PROC [command: CDSequencer.Command] = {

PrintAValue: SelectedFlatWireActionProc = {
TerminalIO.PutF[
"Value[%g]  = %g\n", 
IO.rope[CoreFlat.WirePathRope[display.cellType, flatWire^]], 
IO.rope[Ports.LSToRope[
Rosemary.WireValue[display.simulation, flatWire], 
CoreOps.WireBits[flatWire.wire]]]];
};

DoForSelectedFlatWire[command, PrintAValue];
};

SchematicSimulationAddToPlot: PROC [command: CDSequencer.Command] = {

AddAWire: SelectedFlatWireActionProc = {
errorMsg _ RosemaryUser.AddWireToPlot[display, flatWire];
};

DoForSelectedFlatWire[command, AddAWire];
};

SelectedFlatWireActionProc: TYPE = PROC [display: RosemaryUser.RoseDisplay, flatWire: CoreFlat.FlatWire] RETURNS [errorMsg: Rope.ROPE _ NIL];

DoForSelectedFlatWire: PROC [command: CDSequencer.Command, action: SelectedFlatWireActionProc] = {
errorMsg: Rope.ROPE;
{
ENABLE SchSimError, CoreFlat.PathError => {errorMsg _ msg; GOTO Done};

DoAValue: EachSelectedFlatWireProc = {
flatWireRef: CoreFlat.FlatWire _ NEW[CoreFlat.FlatWireRec];
flatWireRef^ _ selectedFlatWire;
IF HashTable.Insert[table: enumeratedWires, key: flatWireRef, value: $Enumerated] THEN {
errorMsg _ action[display, flatWireRef];
someValueFound _ TRUE;
quit _ errorMsg#NIL;
};
};

display: RosemaryUser.RoseDisplay _ NARROW [CDProperties.GetDesignProp[command.design, $DAUserRoseDisplay]];
someValueFound: BOOL _ FALSE;
enumeratedWires: HashTable.Table _ HashTable.Create[equal: CoreFlat.FlatWireEqual, hash: CoreFlat.FlatWireHash];
[] _ EnumerateSelectedFlatWires[command.design, Sisyph.mode.decoration, display.cellType, display.cutSet, DoAValue];
IF NOT someValueFound THEN errorMsg _ "*** No such wire(s) found.";
EXITS
Done => NULL;
};
IF errorMsg#NIL THEN TerminalIO.PutRopes[errorMsg, "\n"];
};

ResolveData: TYPE = REF ResolveDataRec;
ResolveDataRec: TYPE = RECORD [
cell: Core.CellType _ NIL,
instanceData: IntHashTable.Table _ NIL,
feedBackButton: TiogaButtons.TiogaButton _ NIL,
selectedInstance: NAT _ 0,
doesNotMatter: BOOL _ TRUE,
struckOut: BOOL _ FALSE];

InstanceData: TYPE = REF InstanceDataRec;
InstanceDataRec: TYPE = RECORD [
design: CD.Design _ NIL,
pushedData: PushedData _ NIL,
resolve: ResolveData _ NIL,
instance: NAT _ 0,
objects: LIST OF CoreGeometry.Object _ NIL,  -- only needed for debug if ChoiceRequired changed to use transitiveClosure
cells: LIST OF Core.CellType _ NIL,  -- only needed for debug
button: TiogaButtons.TiogaButton _ NIL];

pushedDataAtom: ATOM = $DAUserPushedData;
PushedData: TYPE = REF PushedDataRec;
PushedDataRec: TYPE = RECORD [
topViewer: ViewerClasses.Viewer _ NIL,
decoration: CoreGeometry.Decoration _ NIL,
root: Core.CellType _ NIL,
cutSet: CoreFlat.CutSet _ NIL,
selectionData: HashTable.Table _ NIL,
transitiveClosure: HashTable.Table _ NIL,
cellType: Core.CellType _ NIL,
flatCellType: CoreFlat.FlatCellTypeRec _ [],
errorMessage: Rope.ROPE _ NIL];

CreateSelectionViewer: PROC [design: CD.Design, pushedData: PushedData, root: Core.CellType, decoration: CoreGeometry.Decoration, cutSet: CoreFlat.CutSet _ NIL] RETURNS [selectionData: HashTable.Table _ NIL, transitiveClosure: HashTable.Table _ NIL] = {

RecordEachAncestor: EachLeastCommonObjectAncestorProc = {
resolveData: ResolveData _ NARROW[HashTable.Fetch[selectionData, ancestor].value];
instanceData: InstanceData _ NIL;
IF resolveData=NIL THEN {
resolveData _ NEW[ResolveDataRec];
IF NOT HashTable.Insert[selectionData, ancestor, resolveData] THEN ERROR;
resolveData.cell _ ancestor;
resolvers _ CONS[resolveData, resolvers];
resolveData.instanceData _ IntHashTable.Create[];
};
instanceData _ NARROW[IntHashTable.Fetch[resolveData.instanceData, instance].value];
IF instanceData=NIL THEN {
instanceData _ NEW[InstanceDataRec];
instanceData.design _ design;
instanceData.pushedData _ pushedData;
instanceData.resolve _ resolveData;
instanceData.instance _ instance;
IF NOT IntHashTable.Insert[resolveData.instanceData, instance, instanceData] THEN ERROR;
};
IF object#NIL THEN FOR objects: LIST OF CoreGeometry.Object _ instanceData.objects, objects.rest UNTIL objects=NIL DO
IF objects.first=object THEN EXIT;
REPEAT FINISHED => instanceData.objects _ CONS[object, instanceData.objects];
ENDLOOP;
IF cell#NIL THEN FOR cells: LIST OF Core.CellType _ instanceData.cells, cells.rest UNTIL cells=NIL DO
IF cells.first=cell THEN EXIT;
REPEAT FINISHED => instanceData.cells _ CONS[cell, instanceData.cells];
ENDLOOP;
};

viewer: ViewerClasses.Viewer _ TiogaButtons.CreateViewer[[		
name: Rope.Cat[CoreOps.GetCellTypeName[root], " Selection"],
iconic: FALSE,
column: left]];
resolvers: LIST OF ResolveData _ NIL;
pushedData.topViewer _ viewer;
selectionData _ HashTable.Create[];
transitiveClosure _ EnumerateLeastCommonObjectAncestors[root, decoration, RecordEachAncestor, cutSet];
FOR resolveList: LIST OF ResolveData _ resolvers, resolveList.rest UNTIL resolveList=NIL DO

FindType: IntHashTable.EachPairAction = {
IF HashTable.Insert[table: finishedSubCells, key: data[key].type, value: $Finished] THEN {
subCellType _ data[key].type;
quit _ TRUE;
};
};

data: CoreClasses.RecordCellType _ NARROW[resolveList.first.cell.data];
subCellType: Core.CellType _ NIL;
resolveName: Rope.ROPE _ CoreOps.GetCellTypeName[resolveList.first.cell];
button: TiogaButtons.TiogaButton _ TiogaButtons.CreateButton[viewer: viewer, rope: Rope.Cat[resolveName, ": "], looks: "f"];
finishedSubCells: HashTable.Table _ HashTable.Create[];
firstChoice: BOOL _ TRUE;
IF SchSimDebug THEN TerminalIO.PutRopes[resolveName, "\n"];
resolveList.first.feedBackButton _ button;
WHILE IntHashTable.Pairs[resolveList.first.instanceData, FindType] DO

AddInstanceChoice: IntHashTable.EachPairAction = {
IF data[key].type=subCellType THEN {
instanceData: InstanceData _ NARROW[value];
instanceName: Rope.ROPE _ CoreClasses.GetCellInstanceName[data[key]];
instanceData.button _ TiogaButtons.AppendToButton[button: button, rope: IF instanceName=NIL THEN IO.PutFR["%g", IO.int[key]] ELSE instanceName, looks: "f", proc: RecordInstanceNumber, clientData: instanceData, fork: FALSE];
[] _ TiogaButtons.AppendToButton[button: button, rope: " "];
IF firstChoice THEN {
SetInstanceNumber[instanceData];
firstChoice _ FALSE;
};
IF SchSimDebug THEN {
TerminalIO.PutRopes["  ", IO.PutFR["%g(%g)", IO.int[key], IO.rope[CoreOps.GetCellTypeName[data[key].type]]], "\n"];
TerminalIO.PutRope["    Cells:\n"];
FOR cells: LIST OF Core.CellType _ instanceData.cells, cells.rest UNTIL cells=NIL DO
TerminalIO.PutRopes["      ", CoreOps.GetCellTypeName[cells.first], "\n"];
ENDLOOP;
TerminalIO.PutRope["    Objects:\n"];
FOR objects: LIST OF CoreGeometry.Object _ instanceData.objects, objects.rest UNTIL objects=NIL DO
TerminalIO.PutRopes["      ", CDDirectory.Name[objects.first], "\n"];
ENDLOOP;
};
};
};

[] _ IntHashTable.Pairs[resolveList.first.instanceData, AddInstanceChoice];
[] _ TiogaButtons.AppendToButton[button: button, rope: Rope.Cat["(", CoreOps.GetCellTypeName[subCellType], ") "], looks: "f"];
ENDLOOP;
ENDLOOP;
};
RecordInstanceNumber: TiogaButtons.TiogaButtonProc = {
instanceData: InstanceData _ NARROW[clientData];
oldInstanceData: InstanceData _ NARROW[IntHashTable.Fetch[table: instanceData.resolve.instanceData, key: instanceData.resolve.selectedInstance].value];
TiogaButtons.ChangeButtonLooks[oldInstanceData.button, NIL, "i"];
SetInstanceNumber[instanceData];
RecomputePushedCellType[instanceData.design, instanceData.pushedData];
};
SetInstanceNumber: PROC [instanceData: InstanceData] = {
instanceData.resolve.selectedInstance _ instanceData.instance;
TiogaButtons.ChangeButtonLooks[instanceData.button, "i"];
instanceData _ instanceData;
};
PushPop: CDEvents.EventProc = {
pushedData: PushedData _ NARROW[CDProperties.GetDesignProp[design, pushedDataAtom]];
IF pushedData#NIL THEN RecomputePushedCellType[design, pushedData];
};
RecomputePushedCellType: PROC [design: CD.Design, pushedData: PushedData] = {

BuildFlatCell: PROC [cell: Core.CellType, flatCell: CoreFlat.FlatCellTypeRec _ CoreFlat.rootCellType, instance: CoreClasses.CellInstance _ NIL, instances: LIST OF CD.Instance] = {
matchingObject: BOOL _ CoreGeometry.GetObject[pushedData.decoration, cell]=instances.first.ob;
SELECT TRUE FROM
matchingObject AND instances.rest=NIL => {
pushedData.errorMessage _ NIL;
pushedData.cellType _ cell;
pushedData.flatCellType _ flatCell;
};
FixedCutSetMemberResolved[flatCell, instance, cell, pushedData.cutSet] => pushedData.errorMessage _ "*** No such cell";
cell.class=CoreClasses.recordCellClass => {
rct: CoreClasses.RecordCellType _ NARROW[cell.data];
IF matchingObject THEN FOR inst: NAT IN [0..rct.size) DO
thisInstance: CoreClasses.CellInstance _ rct[inst];
possibleInst: CoreGeometry.Instance _ [CoreGeometry.GetObject[pushedData.decoration, thisInstance.type], CoreGeometry.GetTrans[pushedData.decoration, thisInstance]];
IF SameCDInstance[instances.rest.first, instances.first.trans, possibleInst] THEN {
BuildFlatCell[thisInstance.type, [CoreFlat.ExtendPath[flatCell.path, inst, rct], 0], thisInstance, instances.rest];
EXIT;
};
REPEAT FINISHED => ERROR;  -- record cell with CD object and next instance does not match?
ENDLOOP
ELSE {
found: BOOL _ FALSE;
multiple: BOOL _ FALSE;
inst: NAT _ LAST[NAT];
FOR i: NAT IN [0..rct.size) DO
subCellTable: HashTable.Table _ NARROW[HashTable.Fetch[ pushedData.transitiveClosure, rct[i].type].value];
IF HashTable.Fetch[subCellTable, instances.first.ob].found THEN {
multiple _ found;
found _ TRUE;
inst _ i;
IF multiple THEN EXIT;
};
ENDLOOP;
SELECT TRUE FROM
NOT found => pushedData.errorMessage _ "*** Cell cannot be reached with current selection viewer settings or selection viewer cannot disambiguate this object";
NOT multiple => {
thisInstance: CoreClasses.CellInstance _ rct[inst];
BuildFlatCell[thisInstance.type, [CoreFlat.ExtendPath[flatCell.path, inst, rct], 0], thisInstance, instances];
};
ENDCASE => {
resolveData: ResolveData _ NARROW[HashTable.Fetch[pushedData.selectionData, cell].value];
IF resolveData=NIL THEN pushedData.errorMessage _ "*** Selection viewer cannot disambiguate the push stack" 
ELSE {
thisInstance: CoreClasses.CellInstance _ rct[resolveData.selectedInstance];
resolveData.doesNotMatter _ FALSE;
BuildFlatCell[thisInstance.type, [CoreFlat.ExtendPath[flatCell.path, resolveData.selectedInstance, rct], 0], thisInstance, instances];
};
};
};
};
ENDCASE => {
thisCell: Core.CellType _ CoreOps.Recast[cell];
BuildFlatCell[thisCell, IF thisCell=cell THEN flatCell ELSE [flatCell.path, flatCell.recastCount+1], instance, IF matchingObject THEN instances.rest ELSE instances];
};
};

instanceStack: LIST OF CD.Instance _ UnwindCDStack[design ! SchSimError => {pushedData.errorMessage _ msg; GOTO Quit}];
IF HashTable.Pairs[pushedData.selectionData, SetDoesNotMatter] THEN ERROR;
BuildFlatCell[cell: pushedData.root, instances: instanceStack];
IF pushedData.errorMessage=NIL THEN IF HashTable.Pairs[pushedData.selectionData, DisplayDoesNotMatter] THEN ERROR;
EXITS Quit => NULL;
};
FilterUsingSelectionData: PROC [root: Core.CellType, flatCell: CoreFlat.FlatCellTypeRec, selectionData: HashTable.Table, instanceSelections: HashTable.Table] RETURNS [pass: BOOL _ FALSE] = {

CheckSelection: CoreFlat.UnboundFlatCellProc = {
SELECT TRUE FROM
CoreFlat.FlatCellTypeEqualRec[flatCell, target] => pass _ TRUE;
cell.class=CoreClasses.recordCellClass => {
resolveData: ResolveData _ NARROW[HashTable.Fetch[selectionData, cell].value];
IF resolveData=NIL THEN CoreFlat.NextUnboundCellType[cell, target, flatCell, instance, index, parent, flatParent, NIL, CheckSelection]
ELSE {

ChoiceRequired: IntHashTable.EachPairAction = {
instanceData: InstanceData _ NARROW[value];
FOR objects: LIST OF CoreGeometry.Object _ instanceData.objects, objects.rest UNTIL objects=NIL DO
IF objects.first=instanceSelect.subObject THEN {
quit _ found;
found _ TRUE;
EXIT;
};
ENDLOOP;
};

rct: CoreClasses.RecordCellType _ NARROW[cell.data];
pathBits: NAT _ BitOps.NBits[rct.size];
instanceBits: PACKED ARRAY [0..16) OF BOOL _ ALL [FALSE];
thisIndex: NAT _ 0;
found: BOOL _ FALSE;
instanceSelect: InstanceSelectionData _ NARROW[HashTable.Fetch[instanceSelections, cell].value];
FOR bit: NAT IN [0..pathBits) DO
instanceBits[16-pathBits+bit] _ target.path.bits[flatCell.path.length+bit];
ENDLOOP;
thisIndex _ LOOPHOLE[instanceBits];
resolveData.doesNotMatter _ (instanceSelect#NIL AND (thisIndex=instanceSelect.instance OR (instanceSelect.subObject#NIL AND NOT IntHashTable.Pairs[resolveData.instanceData, ChoiceRequired])));
IF thisIndex=resolveData.selectedInstance OR resolveData.doesNotMatter THEN CoreFlat.NextUnboundCellType[cell, target, flatCell, instance, index, parent, flatParent, NIL, CheckSelection]
};
};
ENDCASE => CoreFlat.NextUnboundCellType[cell, target, flatCell, instance, index, parent, flatParent, NIL, CheckSelection];
};
IF HashTable.Pairs[selectionData, SetDoesNotMatter] THEN ERROR;
CheckSelection[cell: root, target: flatCell];
IF pass THEN IF HashTable.Pairs[selectionData, DisplayDoesNotMatter] THEN ERROR;
};
SetDoesNotMatter: HashTable.EachPairAction = {
resolveData: ResolveData _ NARROW[value];
resolveData.doesNotMatter _ TRUE;
};

DisplayDoesNotMatter: HashTable.EachPairAction = {
resolveData: ResolveData _ NARROW[value];
IF resolveData.doesNotMatter#resolveData.struckOut THEN {
IF resolveData.doesNotMatter THEN TiogaButtons.ChangeButtonLooks[resolveData.feedBackButton, "y"] ELSE TiogaButtons.ChangeButtonLooks[resolveData.feedBackButton, NIL,  "y"];
resolveData.struckOut _ resolveData.doesNotMatter;
};
};

EachLeastCommonObjectAncestorProc: TYPE = PROC [ancestor: Core.CellType, instance: NAT, cell: Core.CellType _ NIL, object: CoreGeometry.Object _ NIL];

FixedCutSetMemberResolved: PROC [flatCell: CoreFlat.FlatCellTypeRec, instance: CoreClasses.CellInstance, cellType: Core.CellType, cutSet: CoreFlat.CutSet] RETURNS [member: BOOL] = {
member _ cellType.class=CoreClasses.transistorCellClass OR cellType.class=CoreClasses.unspecifiedCellClass OR CoreFlat.CutSetMemberResolved[flatCell, instance, cellType, cutSet];
};

EnumerateLeastCommonObjectAncestors: PROC [root: Core.CellType, decoration: CoreGeometry.Decoration, eachLeastCommonAncestor: EachLeastCommonObjectAncestorProc, cutSet: CoreFlat.CutSet _ NIL] RETURNS [transitiveClosure: HashTable.Table _ NIL] = {
ComputeCellObjectDependence: PROC [cell: Core.CellType, flatCell: CoreFlat.FlatCellTypeRec _ CoreFlat.rootCellType, instance: CoreClasses.CellInstance _ NIL] RETURNS [cellObjects: HashTable.Table] = {

cellObjects _ NARROW[HashTable.Fetch[transitiveClosure, cell].value];
IF cellObjects=NIL THEN {
cellObjects _ HashTable.Create[];
IF CoreProperties.GetCellTypeProp[cell, $DAUserIgnoreForSelection]=NIL THEN {
IF NOT HashTable.Insert[cellObjects, cell, $DependsOn] THEN ERROR;
IF cell.class#CoreClasses.transistorCellClass AND CoreGeometry.HasObject[decoration, cell] THEN IF NOT HashTable.Insert[cellObjects, CoreGeometry.GetObject[ decoration, cell], $DependsOn] THEN ERROR;
SELECT TRUE FROM
FixedCutSetMemberResolved[flatCell, instance, cell, cutSet] => NULL;
cell.class=CoreClasses.recordCellClass => {
rct: CoreClasses.RecordCellType _ NARROW[cell.data];
FOR i: NAT IN [0..rct.size) DO

InsertRecordSubObject: HashTable.EachPairAction = {
subCell: Core.CellType _ NIL;
object: CoreGeometry.Object _ NIL;
IF NOT HashTable.Insert[cellObjects, key, NEW[NAT _ i]] THEN {
firstInstance: REF ANY _ HashTable.Fetch[cellObjects, key].value;
WITH key SELECT FROM
o: CoreGeometry.Object => object _ o;
s: Core.CellType => subCell _ s;
ENDCASE => ERROR;
IF ISTYPE[firstInstance, REF NAT] THEN {
eachLeastCommonAncestor[cell, NARROW[firstInstance, REF NAT]^, subCell, object];
[] _ HashTable.Store[cellObjects, key, $DependsOn];
};
eachLeastCommonAncestor[cell, i, subCell, object];
};
};

subCellObjects: HashTable.Table _ ComputeCellObjectDependence[rct[i].type, [CoreFlat.ExtendPath[flatCell.path, i, rct], 0], rct[i]];
IF HashTable.Pairs[subCellObjects, InsertRecordSubObject] THEN ERROR;
ENDLOOP;
};
ENDCASE => {

InsertOtherSubObject: HashTable.EachPairAction = {
[] _ HashTable.Store[cellObjects, key, $DependsOn];
};

new: Core.CellType _ CoreOps.Recast[cell];
recastCellObjects: HashTable.Table _ IF cell=new THEN ComputeCellObjectDependence[cell, flatCell, instance] ELSE ComputeCellObjectDependence[new, [flatCell.path, flatCell.recastCount+1], instance];
IF HashTable.Pairs[recastCellObjects, InsertOtherSubObject] THEN ERROR;
};
};
IF NOT HashTable.Insert[transitiveClosure, cell, cellObjects] THEN ERROR;
};
};

transitiveClosure _ HashTable.Create[];
[] _ ComputeCellObjectDependence[root];
};
EachSelectedFlatWireProc: TYPE = PROC [selectedFlatWire: CoreFlat.FlatWireRec] RETURNS [quit: BOOL _ FALSE];

EnumerateSelectedFlatWires: PROC [design: CD.Design, decoration: CoreGeometry.Decoration, root: Core.CellType, cutSet: CoreFlat.CutSet _ NIL, eachSelectedFlatWire: EachSelectedFlatWireProc] RETURNS [quit: BOOL _ FALSE] = {

ThisSelectedWire: EachSelectedWireProc = {
quit _ eachSelectedFlatWire[[
flatCell: flatCell,
wireRoot: IF publicWire THEN public ELSE internal,
wire: selectedWire]];
};

publicWire: BOOL _ FALSE;
flatCell: CoreFlat.FlatCellTypeRec _ [];
cellType: Core.CellType _ NIL;
[cellType, flatCell] _ FlatCellTypeFromPushed[design, decoration, root, cutSet];
IF cellType=NIL THEN ERROR SchSimError["The object of the instance at the top of the push stack does not appear in the simulation"];
publicWire _ cellType.class#CoreClasses.recordCellClass;
quit _ EnumerateSelectedWires[design, decoration, IF publicWire THEN cellType.public ELSE NARROW[cellType.data, CoreClasses.RecordCellType].internal, publicWire, ThisSelectedWire];
};
FlatCellTypeFromPushed: PROC [design: CD.Design, decoration: CoreGeometry.Decoration, root: Core.CellType, cutSet: CoreFlat.CutSet _ NIL] RETURNS [pushedCellType: Core.CellType _ NIL, pushedFlatCellType: CoreFlat.FlatCellTypeRec _ CoreFlat.rootCellType] = {

GetPushData: PROC = {
IF pushedData.errorMessage#NIL THEN ERROR SchSimError[pushedData.errorMessage];
pushedCellType _ pushedData.cellType;
pushedFlatCellType _ pushedData.flatCellType;
};

pushedData: PushedData _ NARROW[CDProperties.GetDesignProp[design, pushedDataAtom]];
IF pushedData#NIL AND pushedData.root#root THEN {
ViewerOps.DestroyViewer[pushedData.topViewer];
TerminalIO.PutRope["***  Only single selection viewer allowed per ChipNDale design\n"];
pushedData _ NIL;
};
IF pushedData=NIL THEN {
CheckForMultiple: EachSelectedFlatCellTypeProc = {
pushedCellType _ cellType;
pushedFlatCellType _ flatCellType;
quit _ alreadyCalled;
alreadyCalled _ TRUE;
};

alreadyCalled: BOOL _ FALSE;
IF EnumerateCellTypesForPushed[design, decoration, root, cutSet, CheckForMultiple] THEN {
pushedData _ NEW[PushedDataRec];
pushedData.decoration _ decoration;
pushedData.root _ root;
pushedData.cutSet _ cutSet;
[pushedData.selectionData, pushedData.transitiveClosure] _ CreateSelectionViewer[design, pushedData, root, decoration, cutSet];
CDProperties.PutDesignProp[design, pushedDataAtom, pushedData];
RecomputePushedCellType[design, pushedData];
GetPushData[];
};
}
ELSE GetPushData[];
};

EachSelectedFlatCellTypeProc: TYPE = PROC [cellType: Core.CellType, flatCellType: CoreFlat.FlatCellTypeRec, instanceSelections: HashTable.Table] RETURNS [quit: BOOL _ FALSE];

instanceSelectionNoInstance: NAT = LAST[NAT];
InstanceSelectionData: TYPE = REF InstanceSelectionDataRec;
InstanceSelectionDataRec: TYPE = RECORD [
subObject: CoreGeometry.Object _ NIL,
instance: NAT _ instanceSelectionNoInstance];

UnwindEnumeration: ERROR = CODE;

EnumerateCellTypesForPushed: PROC [design: CD.Design, decoration: CoreGeometry.Decoration, root: Core.CellType, cutSet: CoreFlat.CutSet _ NIL, eachFlatCellType: EachSelectedFlatCellTypeProc] RETURNS [quit: BOOL _ FALSE] = {

EnumerateCellTypes: CoreFlat.UnboundFlatCellProc = {
instances: LIST OF CD.Instance _ NARROW[data];
matchingObject: BOOL _ CoreGeometry.HasObject[decoration, cell] AND CoreGeometry.GetObject[decoration, cell]=instances.first.ob;
IF parent#NIL THEN {
selectionData: InstanceSelectionData _ GetSelectionData[parent];
selectionData.subObject _ instances.first.ob;
};
IF matchingObject AND instances.rest=NIL THEN {IF eachFlatCellType[cell, flatCell, instanceSelections] THEN ERROR UnwindEnumeration[]}
ELSE IF NOT FixedCutSetMemberResolved[flatCell, instance, cell, cutSet] THEN
IF cell.class=CoreClasses.recordCellClass AND matchingObject THEN CoreFlat.NextUnboundCellType[cell, target, flatCell, instance, index, parent, flatParent, instances, TransformInstance]
ELSE CoreFlat.NextUnboundCellType[cell, target, flatCell, instance, index, parent, flatParent, IF matchingObject THEN instances.rest ELSE instances, EnumerateCellTypes];
};

TransformInstance: CoreFlat.UnboundFlatCellProc = {
instances: LIST OF CD.Instance = NARROW [data];
possibleInst: CoreGeometry.Instance = [CoreGeometry.GetObject[decoration, instance.type], CoreGeometry.GetTrans[decoration, instance]];
IF SameCDInstance[instances.rest.first, instances.first.trans, possibleInst] THEN {
selectionData: InstanceSelectionData _ GetSelectionData[parent];
selectionData.instance _ index;
EnumerateCellTypes[cell, target, flatCell, instance, index, parent, flatParent, instances.rest];
selectionData.instance _ instanceSelectionNoInstance;
};
};

GetSelectionData: PROC [parent: Core.CellType] RETURNS [selectionData: InstanceSelectionData] = {
selectionData _ NARROW[HashTable.Fetch[instanceSelections, parent].value];
IF selectionData=NIL THEN {
selectionData _ NEW[InstanceSelectionDataRec];
IF NOT HashTable.Insert[instanceSelections, parent, selectionData] THEN ERROR;
};
};

instanceStack: LIST OF CD.Instance _ UnwindCDStack[design];
instanceSelections: HashTable.Table _ HashTable.Create[];
EnumerateCellTypes[cell: root, data: instanceStack ! UnwindEnumeration => GOTO Quit];
EXITS Quit => quit _ TRUE;
};
EachSelectedWireProc: TYPE = PROC [selectedWire: Core.Wire] RETURNS [quit: BOOL _ FALSE];

EnumerateSelectedWires: PROC [design: CD.Design, decoration: CoreGeometry.Decoration, root: Core.Wire, public: BOOL _ FALSE, eachSelectedWire: EachSelectedWireProc] RETURNS [quit: BOOL _ FALSE] = {
ThisSelectedInstance: EachSelectedInstanceProc = {
ThisWire: CoreOps.EachWireProc = {
ThisWireInstance: CoreGeometry.EachInstanceProc = {
quit _ instance=selectedInstance;
};
match: BOOL _ IF public THEN CoreGeometry.EnumeratePins[decoration, wire, ThisWireInstance] ELSE CoreGeometry.EnumerateGeometry[decoration, wire, ThisWireInstance];
IF match THEN quit _ eachSelectedWire[wire];
};
quit _ CoreOps.VisitWire[root, ThisWire]
};
quit _ EnumerateSelectedInstances[design, ThisSelectedInstance];
};
EachSelectedInstanceProc: TYPE = PROC [selectedInstance: CoreGeometry.Instance] RETURNS [quit: BOOL _ FALSE];

EnumerateSelectedInstances: PROC [design: CD.Design, eachInstance: EachSelectedInstanceProc] RETURNS [quit: BOOL _ FALSE] = {

ThisInstance: CDCells.InstEnumerator = {
IF inst.selected THEN {
trans: CD.Transformation _ design.actual.first.mightReplace.trans;
quit _ eachInstance[[inst.ob, [CDBasics.DeMapPoint[inst.trans.off, trans], CDBasics.DecomposeOrient[itemInWorld: inst.trans.orient, cellInWorld: trans.orient]]]];
};
};

quit _ CDCells.EnumerateInstances[design.actual.first.dummyCell.ob, ThisInstance];
};
SameCDInstance: PROC [cdinst: CD.Instance, trans: CD.Transformation, instance: CoreGeometry.Instance] RETURNS [BOOL] = {
RETURN [
cdinst.ob=instance.obj AND 
CDBasics.DeMapPoint[cdinst.trans.off, trans]=instance.trans.off AND 
CDBasics.DecomposeOrient[itemInWorld: cdinst.trans.orient, cellInWorld: trans.orient]=instance.trans.orient
];
};

UnwindCDStack: PROC [design: CD.Design] RETURNS [instanceStack: LIST OF CD.Instance] = {
IF design.actual.rest=NIL THEN ERROR SchSimError["*** No currently pushed-in cell."];
FOR stack: LIST OF CD.PushRec _ design.actual, stack.rest WHILE stack.rest#NIL DO
IF stack.first.specific.changed THEN ERROR SchSimError[IO.PutFR["*** Impossible to extract stack, cell %g has been changed and not saved.", IO.rope[CDDirectory.Name[stack.first.mightReplace.ob]]]];
instanceStack _ CONS[stack.first.mightReplace, instanceStack];
ENDLOOP;
};
CDCommandOps.RegisterWithMenu[menu: $OtherProgramMenu, entry: "Schematic Simulation Value", key: $DAUserSchematicSimulationValue, proc: SchematicSimulationValue, queue: doQueue];
CDCommandOps.RegisterWithMenu[menu: $OtherProgramMenu, entry: "Schematic Simulation Add To Plot", key: $DAUserSchematicSimulationAddToPlot, proc: SchematicSimulationAddToPlot, queue: doQueue];
CDEvents.RegisterEventProc[event: $AfterPush, proc: PushPop];
CDEvents.RegisterEventProc[event: $AfterPop, proc: PushPop];
END. 
SchematicSimulation.mesa
Copyright Ó 1987 by Xerox Corporation.  All rights reserved.
Barth, March 20, 1987 2:34:19 pm PST
DAUser
SinixOps





RecomputePushedCellType: PROC [design: CD.Design, pushedData: PushedData] = {

FilterSelections: EachSelectedFlatCellTypeProc = {
IF FilterUsingSelectionData[pushedData.root, flatCellType, pushedData.selectionData, instanceSelections] THEN {
IF alreadyCalled THEN {
quit _ TRUE;
pushedData.errorMessage _ "*** Selection data not enough to pick a flat cell.";
}
ELSE {
alreadyCalled _ TRUE;
pushedData.errorMessage _ NIL;
pushedData.cellType _ cellType;
pushedData.flatCellType _ flatCellType;
};
};
};

alreadyCalled: BOOL _ FALSE;
IF NOT EnumerateCellTypesForPushed[design, pushedData.decoration, pushedData.root, pushedData.cutSet, FilterSelections ! SchSimError => {pushedData.errorMessage _ msg; GOTO Quit}] THEN IF NOT alreadyCalled THEN pushedData.errorMessage _ "*** Selection data picks no cell.";
EXITS Quit => NULL;
};


Using the ignore bindings form of enumeration keep a hash table of objects and cell types reachable from a cell, including the cell itself and the object belonging to it.  While combining the objects and cells reachable from a cell notice if an object or cell is inserted more than once, i.e. accessable through more than one instance.  If it is then call eachLeastCommonAncestor for the current cell.  This routine only understands record cells and therefore only record cells are passed to eachLeastCommonAncestor.  eachLeastCommonAncestor may be called multiple times with the same arguments.  It will be called with all of the multiple instances through which a cell or object may be reached.  transitiveClosure maps CellType to HashTable which then maps Object or CellType to $DependsOn or REF NAT.








�Êߘ
code–

"Cedar" styleš
œ™K–

"Cedar" style™<Kš
œ$™$K˜—KšÏk	œ�œ²
�œb˜ªK˜šÏnœ�œ
�˜"Kš�œ¦
�œR˜�Kšœ�œ
˜K˜—šžœ�œ�œ�œ
˜+K˜—Kšžœ�œ�œ
˜
headš
ž™šžœ�œ#˜AK˜šžœ ˜+š
œ˜Kš
œ˜Kš�œ;˜=š�œ˜Kš
œ2˜2Kš
œ#˜#——K˜K˜—Kš
œ,˜,Kš
œ˜K˜—šžœ�œ#˜EK˜šžœ ˜(Kš
œ9˜9K˜K˜—Kš
œ)˜)Kš
œ˜K˜—šœ�œ�œB�œ�œ�œ˜�
K˜—šžœ�œG˜bKšœ�œ
˜š
œ
˜
Kš�œ5�œ˜FK˜šžœ˜&Kšœ!�œ˜;Kš
œ ˜ š�œP�œ˜XKš
œ(˜(Kšœ�œ
˜Kšœ�œ
˜K˜—K˜K˜—Kšœ$�œB˜lKšœ�œ�œ
˜Kš
œp˜pKš
œt˜tKš�œ
�œ�œ)˜Cš
�˜Kšœ�œ
˜
—K˜—Kš�œ
�œ
�œ%˜9Kš
œ˜K˜——š
ž™Jšœ
�œ�œ˜'šœ�œ�œ˜Jšœ�œ
˜Jšœ#�œ
˜'Jšœ+�œ
˜/Jšœ�œ˜Jšœ�œ�˜Jšœ�œ�œ˜J˜—Jšœ�œ�œ˜)šœ�œ�œ˜ Jšœ�œ
�œ
˜Jšœ�œ
˜Jšœ�œ
˜Jšœ
�œ˜Jšœ	�œ
�œ�œÏcK˜xJšœ�œ
�œ�œŸ˜=Jšœ#�œ˜(J˜—Jšœ�œ˜)Jšœ�œ�œ˜%šœ�œ�œ˜Jšœ"�œ
˜&Jšœ&�œ
˜*Jšœ�œ
˜Jšœ�œ
˜Jšœ!�œ
˜%Jšœ%�œ
˜)Jšœ�œ
˜Jš
œ,˜,Jšœ�œ�œ˜J˜—šžœ�œ
�œu�œ�œ#�œ'�œ˜ý
K˜šžœ'˜9Kšœ�œ1˜RKšœ�œ
˜!š�œ
�œ
�œ˜Kšœ�œ˜"Kš�œ
�œ8�œ
�œ
˜IKš
œ˜Kšœ�œ˜)Kš
œ1˜1K˜—Kšœ�œ?˜Tš�œ�œ
�œ˜Kšœ�œ˜$Kš
œ˜Kš
œ%˜%Kš
œ#˜#Kš
œ!˜!Kš�œ
�œG�œ
�œ
˜XK˜—š�œ�œ
�œ
�œ
�œ
�œ:�œ	�œ
�˜uKš�œ�œ
�œ
˜"Kš�œ
�œ�œ˜MKš�œ
˜—š�œ�œ
�œ
�œ�œ
�œ0�œ�œ
�˜eKš�œ�œ
�œ
˜Kš�œ
�œ�œ˜GKš�œ
˜—K˜K˜—š
œ<˜<Jš
œ<˜<Jšœ�œ
˜Jš
œ˜—Kšœ�œ
�œ�œ
˜%Kš
œ˜Kš
œ#˜#Kš
œf˜fš�œ�œ
�œ+�œ
�œ
�˜[K˜šžœ!˜)š�œR�œ˜ZKš
œ˜Kšœ�œ
˜K˜—K˜K˜—Kšœ#�œ˜GKšœ�œ
˜!Kšœ�œ3˜IKš
œ|˜|K˜7Kšœ
�œ�œ
˜Kš�œ
�œ(˜;Kš
œ*˜*š�œ>�˜EK˜šžœ!˜2š�œ�œ˜$Kšœ�œ˜+Kšœ�œ.˜EKšœH�œ�œ
�œ
�œ
�œ�œW�œ˜ß
Kš
œ<˜<š�œ
�œ˜Kš
œ ˜ Kšœ�œ
˜K˜—š�œ
�œ˜Kšœ�œ�œ�œ7˜sKš
œ#˜#š�œ�œ
�œ0�œ�œ
�˜TKš
œJ˜JKš�œ
˜—Kš
œ%˜%š�œ
�œ
�œ:�œ	�œ
�˜bKš
œE˜EKš�œ
˜—K˜—K˜—K˜K˜—Kš
œK˜KKš
œ~˜~Kš�œ
˜—Kš�œ
˜—Kš
œ˜K™—šžœ"˜6Kšœ�œ
˜0Kšœ �œq˜—
Kšœ7�œ˜AKš
œ ˜ Kš
œF˜FKš
œ˜K™—šžœ�œ!˜8Kš
œ>˜>Kš
œ9˜9Kš
œ˜Kš
œ˜K™—šžœ˜Kšœ�œ5˜TKš�œ�œ
�œ-˜CKš
œ˜K™—šžœ�œ
�œ$˜MK˜šž
œ�œx�œ
�œ
�œ
�œ˜³
Kšœ�œJ˜^š�œ
�œ
�˜šœ�œ�œ˜*Kšœ�œ
˜Kš
œ˜Kš
œ#˜#Kš
œ˜—Kš
œw˜wš
œ+˜+Kšœ"�œ˜4š	�œ�œ�œ
�œ�˜8K˜3Kš
ϴ
˜¥
š�œK�œ˜SKš
œs˜sKš�œ
˜K˜—Kš�œ
�œ�œŸ?˜ZKš
�˜—š�œ˜Kšœ�œ�œ
˜Kšœ
�œ�œ
˜Kšœ�œ�œ
�œ˜š�œ�œ
�œ�˜Kšœ �œD˜jš�œ9�œ˜AKš
œ˜Kšœ�œ
˜
K˜	Kš�œ
�œ
�œ
˜K˜—Kš�œ
˜—š�œ
�œ
�˜Kš�œœ
˜Ÿ
š�œ˜Kš
œ3˜3Kš
œn˜nKš
œ˜—š�œ˜Kšœ�œ8˜YKš�œ
�œ
�œU˜lš�œ˜Kš
œK˜KKšœ�œ
˜"Kš
Ϡ
˜†
K˜—Kš
œ˜——K˜—K˜—š�œ˜Kš
œ/˜/Kš
œ�œ�œ
�œ4�œ�œ�œ˜¥
Kš
œ˜——Kš
œ˜K˜—Kš	œ�œ
�œ
�œR�œ˜wKš�œ=�œ
�œ
˜JKš
œ?˜?Kš�œ�œ
�œ
�œA�œ
�œ
˜rKš�œ	�œ
˜Kš
œ˜K™—šžœ�œ
�œ$™MK™šžœ"™2š�œg�œ™oš�œ�œ™Kšœ�œ
™Kš
œO™OK™
—š�œ™Kšœ�œ
™Kšœ�œ
™Kš
œ™Kš
œ'™'K™—K™—Kš
œ™K™—Kšœ�œ�œ
™Kš�œ
�œ¢
�œ�œ
�œ
�œ�œ?™‘Kš�œ	�œ
™Kš
œ™K™—š
žœ�œ€
�œ�œ�œ˜¾
K˜šžœ"˜0š
�˜Kšœ:�œ
˜?š
œ+˜+Kšœ�œ-˜NKš�œ
�œ
�œ[�œ˜†
š�œ˜K˜šžœ!˜/Kšœ�œ˜+š�œ
�œ
�œ:�œ	�œ
�˜bš�œ(�œ˜0Kš
œ
˜
Kšœ�œ
˜
Kš�œ
˜Kš
œ˜—Kš�œ
˜—K˜K˜—Kšœ"�œ˜4Kšœ
�œ˜'Kš
œ�œ
�œ	�œ
�œ�œ�œ˜9Kšœ�œ˜Kšœ�œ�œ
˜Kšœ(�œ2˜`š�œ�œ
�œ�˜ Kš
œK˜KKš�œ
˜—Kšœ�œ˜#Kš
œ,�œ
�œ$�œ�œ
�œ
�œA˜À
Kš�œ(�œ�œ[�œ˜º
K˜—K˜—Kš�œ^�œ˜z—K˜—Kš�œ2�œ
�œ
˜?Kš
œ-˜-Kš
�œ�œ
�œ6�œ
�œ
˜PKš
œ˜K™—šžœ˜.Kšœ�œ˜)Kšœ�œ
˜!K˜K˜—šžœ˜2Kšœ�œ˜)š�œ1�œ˜9Kš�œ�œA�œ<�œ˜­
Kš
œ2˜2K˜—K˜K˜—šœ#�œ�œ%�œ�œ �œ˜–
K˜—šžœ�œ|�œ
�œ˜µ
Kšœ8�œ1�œE˜²
Kš
œ˜K˜—š
ž#œ�œ’
�œ�œ'�œ˜ö
KšœËŸX™£šžœ�œx�œ�œ#˜È
K˜Kšœ�œ1˜Eš�œ
�œ
�œ˜Kš
œ!˜!š�œA�œ
�œ˜MKš�œ
�œ1�œ
�œ
˜BKš�œ,�œ*�œ
�œ
�œV�œ
�œ
˜Ç
š�œ
�œ
�˜Kšœ?�œ
˜Dš
œ+˜+Kšœ"�œ˜4š�œ�œ
�œ�˜K˜šžœ˜3Kšœ�œ
˜Kšœ�œ
˜"š
�œ
�œ$�œ
�œ�œ˜>Kšœ�œ
�œ+˜Aš�œ�œ
�˜Kš
œ%˜%Kš
œ ˜ Kš�œ�œ
˜—š
�œ
�œ�œ
�œ�œ˜(Kšœ�œ�œ
�œ˜PKš
œ3˜3K˜—Kš
œ2˜2K˜—K˜K˜—Kš
œ„
˜„
Kš�œ8�œ
�œ
˜EKš�œ
˜—K˜—š�œ˜K˜šžœ˜2Kš
œ3˜3K˜K˜—Kš
œ*˜*Kšœ%�œ
�œ7�œU˜Å
Kš�œ:�œ
�œ
˜GK˜——K˜—Kš�œ
�œ8�œ
�œ
˜IK˜—K˜K˜—K˜'Kš
œ'˜'Kš
œ˜K™—šœ�œ�œ*�œ�œ�œ˜lK˜—šžœ�œ
�œ]�œ2�œ�œ�œ˜Þ
K˜šžœ˜*š
œ˜Kš
œ˜Kšœ
�œ�œ�œ
˜2Kš
œ˜—K˜K˜—Kšœ�œ�œ
˜Kš
œ(˜(Kšœ�œ
˜Kš
œP˜PKš�œ
�œ
�œ
�œj˜„
Kš
œ8˜8Kš	œ2�œ�œ�œ
�œT˜´
Kš
œ˜K™—šžœ�œ
�œ]�œ�œ"�œK˜�K˜šžœ�œ˜Kš�œ�œ
�œ
�œ&˜OKš
œ%˜%Kš
œ-˜-K˜—K˜Kšœ�œ5˜Tš�œ�œ
�œ�œ˜1Kš
œ.˜.K˜WKšœ
�œ
˜K˜—š�œ�œ
�œ˜K™šžœ"˜2Kš
œ˜Kš
œ"˜"Kš
œ˜Kšœ�œ
˜Kš
œ˜K˜—Kšœ�œ�œ
˜š�œQ�œ˜YKšœ
�œ˜ Kš
œ#˜#Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ?˜?Kš
œ,˜,Kš
œ˜K˜—K˜
—Kš�œ˜K˜K˜—šœ�œ�œh�œ�œ�œ˜®
K˜—Kšœ�œ�œ
�œ˜-Kšœ�œ�œ˜;šœ�œ�œ˜)Kšœ!�œ
˜%Kšœ
�œ ˜-K˜—šžœ�œ�œ
˜ K˜—šžœ�œ
�œ]�œ2�œ�œ�œ˜ß
K˜šžœ"˜4Kš	œ�œ
�œ
�œ�œ˜.Kšœ�œ,�œ=˜€
š�œ�œ
�œ˜Kš
œ@˜@Kš
œ-˜-K˜—Kš�œ�œ�œ
�œ�œ6�œ
�œ˜†
š�œ
�œ
�œ=�˜LKš�œ(�œ�œx˜¹
Kš�œ[�œ�œ�œ ˜©
—Kš
œ˜K˜—šžœ"˜3Jš	œ�œ
�œ
�œ�œ˜/Jš
œ‡
˜‡
š�œK�œ˜SKš
œ@˜@Kš
œ˜Jš
œ`˜`Kš
œ5˜5J˜—K˜K˜—šžœ�œ�œ+˜aKšœ�œ4˜Jš�œ�œ
�œ˜Kšœ�œ˜.Kš�œ
�œ=�œ
�œ
˜NK˜—K˜K˜—Kšœ�œ
�œ
�œ"˜;Kš
œ9˜9KšœJ�œ˜UKš�œ�œ
˜Kš
œ˜K™—šœ�œ�œ�œ�œ�œ˜YK˜—šžœ�œ
�œG�œ�œ*�œ�œ�œ˜Å
šžœ˜2šžœ˜"šžœ#˜3Kš
œ!˜!K˜—Kš	œ�œ�œ�œ@�œD˜¤
Kš�œ�œ˜,K˜—K˜(K˜—Kš
œ@˜@Kš
œ˜K™—šœ�œ�œ+�œ�œ�œ˜mK˜—šžœ�œ
�œ1�œ�œ�œ˜}K˜šžœ˜(š�œ�œ˜Kšœ�œ9˜BKš
Ϣ
˜¢
K˜—K˜K˜—Kš
œR˜RKš
œ˜K™—šžœ�œ
�œ�œ2�œ�œ˜xš�œ˜Kšœ�œ
˜Kšœ@�œ
˜DKš
œk˜kKš
œ˜—K˜K˜—šž
œ�œ
�œ	�œ�œ
�œ
�œ˜XKš�œ�œ
�œ
�œ1˜Uš
�œ�œ
�œ
�œ%�œ�œ
�˜QKš
�œ�œ
�œ
�œS�œ7˜Å
Jšœ�œ*˜>Kš�œ
˜—Kš
œ˜K™——Kš
œ²
˜²
Kš
œÀ
˜À
Kš
œ=˜=Kš
œ<˜<Kš�œ˜K™—…—bž�