DIRECTORY 
Basics,
CD, CDBasics, CDCells, CDDirectory, CDInstances, CDProperties, CDSatellites, CDSymbolicObjects,
CedarProcess, 
Core, CoreClasses, CoreOps, CoreProperties, 
CoreGeometry,
GList, HashTable, IO, Process,
PWObjects,
Rope, RopeList, 
Sinix, SinixD2Intervals, TerminalIO;

SinixImpl: CEDAR PROGRAM
IMPORTS Basics, CD, CDBasics, CDCells, CDDirectory, CDInstances, CDProperties, CDSatellites, CDSymbolicObjects, CedarProcess, CoreClasses, CoreOps, CoreProperties, CoreGeometry, SinixD2Intervals, GList, HashTable, IO, Process, PWObjects, Rope, RopeList, TerminalIO
EXPORTS Sinix
SHARES CoreGeometry = 
BEGIN OPEN Sinix;
InternalBug: PUBLIC SIGNAL [name: ROPE] = CODE;
CallerBug: PUBLIC SIGNAL [] = CODE;
FusionPropMismatch: PUBLIC SIGNAL [name: ROPE, prop: ATOM, value1, value2: REF] = CODE;
FusionStructureMismatch: PUBLIC SIGNAL [name: ROPE, wire1, wire2: Wire] = CODE;
StructureMismatch: PUBLIC SIGNAL [name: ROPE, actual, subPublic: WireSeq] = CODE;
FusionByNameMismatch: PUBLIC SIGNAL [name, msg: ROPE, wire: Wire] = CODE;
StructuralLoop: PUBLIC SIGNAL [name: ROPE, wire: Wire] = CODE;
ROPES: TYPE = LIST OF ROPE;
Transformation: TYPE = CoreGeometry.Transformation;
Instance: TYPE = CoreGeometry.Instance;
Instances: TYPE = CoreGeometry.Instances;
Cache: TYPE = REF CacheRec;
CacheRec: TYPE = RECORD [
mode: Mode, properties: CD.PropList _ NIL, userData: REF _ NIL, 
result: REF, props: Properties _ NIL
];

FlushCache: PUBLIC PROC [obj: CD.Object] = {CDProperties.PutObjectProp[obj, cacheProp, NIL]};
NameWire: TYPE = RECORD [name: ROPE, wire: Wire];

FusionData: TYPE = REF FusionDataRec;
FusionDataRec: TYPE = RECORD [
mode: Mode, 					-- to avoid passing it around
nir: CD.Rect,						-- Rectangles for which geometry that is strictly inside (edge excluded) is not promoted public
name: ROPE,						-- name of the object currently extracted
isAbut: BOOL,					-- recording publics depend on this property
fused: HashTable.Table,		-- Association [fused -> root] [Wire -> Wire].  If root=NIL, then this wire is a root.  Basically all the wires ever created belong to this table.
data: REF, 						-- different information for Abut and Cell.  For abuts it contains the next rects, (REF SinixD2Intervals.Table).  For Cell, it is a LIST OF NameWire.  This list is not sorted at creation time, and same name may appear several times.
rects: SEQUENCE nbOfLayers: NAT OF SinixD2Intervals.Table -- Association (per layer) [fusion geometry -> wire] [CD.Rect -> IW].  Wire may or may not be a root.  
];

AbutData: TYPE = REF AbutDataRec;
AbutDataRec: TYPE = RECORD [
inX: BOOL, 					-- to avoid passing it around
nextRects: SEQUENCE nbOfLayers: NAT OF SinixD2Intervals.Table -- Association (per layer) [fusion geometry -> wire] [CD.Rect -> IW].  Wire may or may not be a root.  
];

rect: PROC [r: CD.Rect] RETURNS [IO.Value] = {
RETURN [IO.rope[IO.PutFR["[%g, %g, %g, %g]", IO.int[r.x1], IO.int[r.y1], IO.int[r.x2], IO.int[r.y2]]]];
};

CreateRoot: PROC [fusionData: FusionData, size: NAT, props: Properties _ NIL] RETURNS [wire: Wire] = {
EachProperty: PROC [prop: ATOM, val: REF ANY _ NIL] = {
newVal: REF ANY _ SELECT prop FROM
fusionData.mode.decoration.pinsProp => NIL,
fusionData.mode.decoration.geometryProp => NIL,
CoreOps.nameProp => NIL,
ENDCASE => val;
CoreProperties.PutWireProp[wire, prop, newVal];
};
wire _ CoreOps.CreateWires[size: size];
CoreProperties.Enumerate[props, EachProperty];
[] _ HashTable.Store[fusionData.fused, wire, NIL];
};

InsertInstances: PROC [fusionData: FusionData, transformation: Transformation, instances: Instances, wire: Wire, copyGeometry: BOOL] = {
IF ~HashTable.Fetch[fusionData.fused, wire].found 
THEN SIGNAL InternalBug[fusionData.name];
IF RootWire[fusionData, wire]#wire THEN SIGNAL InternalBug[fusionData.name];
FOR is: Instances _ instances, is.rest WHILE is#NIL DO
inst: Instance _ CoreGeometry.Transform[transformation, is.first];
layers: LayerRange _ fusionData.mode.instanceLayer[inst];
FOR i: NAT IN [layers.min .. layers.max] DO SinixD2Intervals.Insert[fusionData[i], inst, wire] ENDLOOP;
IF CoreGeometry.AtEdge[fusionData.nir, inst] 
THEN CoreProperties.PutWireProp[wire, $Public, $Public];
ENDLOOP;
IF copyGeometry THEN CoreGeometry.AddGeometry[fusionData.mode.decoration, wire, CoreGeometry.TransformList[transformation, instances]];
};
CreateDAGWireSeq: PROC [table: HashTable.Table] RETURNS [wire: WireSeq] = {
wires: LIST OF Wire _ NIL;
EachKeyDelete: HashTable.EachPairAction = {
WireDelete: PROC [wire: Wire] = {
IF ~HashTable.Delete[table, wire] THEN RETURN; -- already done
FOR i: NAT IN [0 .. wire.size) DO
WireDelete[wire[i]];
ENDLOOP;
};
wire: Wire _ NARROW [key]; 
FOR i: NAT IN [0 .. wire.size) DO 
WireDelete[wire[i]]; 
ENDLOOP;
};
index: NAT _ 0;
SummarizeWires: HashTable.EachPairAction = {
wire[index] _ NARROW [key]; 
index _ index+1;
};
[] _ HashTable.Pairs[table, EachKeyDelete];
wire _ CoreOps.CreateWires[HashTable.GetSize[table]];
[] _ HashTable.Pairs[table, SummarizeWires];
IF index#HashTable.GetSize[table] THEN SIGNAL InternalBug[NIL];
};

MakeResult: PROC [fusionData: FusionData, obj: CD.Object, cellInstances: LIST OF CoreClasses.CellInstance] RETURNS [record: CellType] = {
decoration: CoreGeometry.Decoration = fusionData.mode.decoration;
publics: HashTable.Table _ HashTable.Create[3];
internals: HashTable.Table _ HashTable.Create[5];
InternalDagIfy: HashTable.EachPairAction = {
WireDagIfy: PROC [wire: Wire, maxIter: NAT _ 32] = {
IF maxIter=0 THEN SIGNAL StructuralLoop[fusionData.name, wire]; -- probably loop in the Wire structure
IF RootWire[fusionData, wire]#wire THEN SIGNAL InternalBug[fusionData.name];
FOR i: NAT IN [0 .. wire.size) DO
wire[i] _ RootWire[fusionData, wire[i]];
WireDagIfy[wire[i], maxIter-1];
ENDLOOP;
};
wire: Wire _ NARROW [key]; 
IF value#NIL THEN RETURN; -- we dagify only the roots
[] _ HashTable.Store[internals, wire, NIL];
IF CoreProperties.GetWireProp[wire, $Public]#NIL THEN {
[] _ HashTable.Store[publics, wire, NIL]; 
CoreProperties.PutWireProp[wire, $Public, NIL];
};
WireDagIfy[wire];
};
AddDecorateWire: CoreOps.EachWireProc = {
pins: Instances _ NIL;
AddPin: CoreGeometry.EachInstanceProc = {
IF CoreGeometry.AtEdge[fusionData.nir, instance] THEN pins _ CONS [instance, pins];
};
[] _ CoreGeometry.EnumerateGeometry[decoration, wire, AddPin];
CoreGeometry.AddPins[decoration, wire, pins];
};
[] _ HashTable.Pairs[fusionData.fused, InternalDagIfy];
FOR list: LIST OF CoreClasses.CellInstance _ cellInstances, list.rest WHILE list#NIL DO
instance: CoreClasses.CellInstance _ list.first;
actual: Wire _ instance.actual;
FOR i: NAT IN [0 .. actual.size) DO
wire: Wire _ RootWire[fusionData, actual[i]];
IF ~CoreOps.CorrectConform[wire, instance.type.public[i]] THEN SIGNAL StructureMismatch[fusionData.name, wire, instance.type.public[i]]; 
actual[i] _ wire;
ENDLOOP;
ENDLOOP;
record _ CoreClasses.CreateRecordCell[
public: CreateDAGWireSeq[publics], internal: CreateDAGWireSeq[internals],
instances: cellInstances,
name: CDDirectory.Name[obj],
giveNames: TRUE
];
CoreGeometry.PutObject[decoration, record, obj];
CoreGeometry.PutRecordLazyPins[decoration, record, fusionData.nir];
[] _ CoreOps.VisitWireSeq[record.public, AddDecorateWire];
};

LayoutFusionByName: PROC [fusionData: FusionData] = {
refList: REF LIST OF NameWire = NARROW [fusionData.data];
nameToWire: HashTable.Table = HashTable.Create[mod: 11, equal: HashTable.RopeEqual, hash: HashTable.HashRope];
FOR nameWires: LIST OF NameWire _ refList^, nameWires.rest WHILE nameWires#NIL DO
wire: Wire _ RootWire[fusionData, nameWires.first.wire];
name: ROPE _ OrNames[nameWires.first.name, CoreOps.GetShortWireName[wire], fusionData.name]; 
previousWire: Wire _ NARROW [HashTable.Fetch[nameToWire, name].value];
IF previousWire#NIL THEN {
previousWire _ RootWire[fusionData, previousWire];
IF previousWire#wire THEN {
wire _ StructuredFusion[fusionData, wire, previousWire];
TerminalIO.PutF["Fusion by name for '%g' in cell '%g'.\n", IO.rope[name], IO.rope[fusionData.name]];
CoreProperties.PutWireProp[wire, $FusedByName, $FusedByName];
};
};
[] _ HashTable.Store[nameToWire, name, wire];
[] _ CoreOps.SetShortWireName[wire, name];
ENDLOOP;
};

NoFusionByName: PROC [fusionData: FusionData] = {
refList: REF LIST OF NameWire = NARROW [fusionData.data];
EachNameWire: HashTable.EachPairAction = {
uniqueID: INT _ 0;
name: ROPE = NARROW [key];
wires: Wires _ NARROW [value];
[] _ CoreOps.SetShortWireName[wires.first, name];
wires _ wires.rest;
IF wires=NIL THEN RETURN;
TerminalIO.PutF["NO fusion by name for '%g' in cell '%g'.\n", IO.rope[name], IO.rope[fusionData.name]];
WHILE wires#NIL DO
[] _ CoreOps.SetShortWireName[wires.first, IO.PutFR["%g$%g$", IO.rope[name], IO.int[uniqueID]]];
uniqueID _ uniqueID + 1;
wires _ wires.rest;
ENDLOOP;
};
nameToWires: HashTable.Table = HashTable.Create[mod: 11, equal: HashTable.RopeEqual, hash: HashTable.HashRope]; -- contains (for every name) the list of roots that have it for name
FOR nameWires: LIST OF NameWire _ refList^, nameWires.rest WHILE nameWires#NIL DO
name: ROPE _ nameWires.first.name; 
wire: Wire = RootWire[fusionData, nameWires.first.wire];
wires: Wires _ NARROW [HashTable.Fetch[nameToWires, name].value];
IF NOT CoreOps.Member[wires, wire] THEN wires _ CONS [wire, wires];
[] _ HashTable.Store[nameToWires, name, wires];
ENDLOOP;
[] _ HashTable.Pairs[nameToWires, EachNameWire];
};

SchematicsFusionByName: PROC [fusionData: FusionData] = {
refList: REF LIST OF NameWire = NARROW [fusionData.data];
nameToWire: HashTable.Table = HashTable.Create[mod: 11, equal: HashTable.RopeEqual, hash: HashTable.HashRope];
names: ROPES _ NIL;
FOR nameWires: LIST OF NameWire _ refList^, nameWires.rest WHILE nameWires#NIL DO
wire: Wire _ RootWire[fusionData, nameWires.first.wire];
name: ROPE _ OrNames[nameWires.first.name, CoreOps.GetShortWireName[wire], fusionData.name]; 
previousWire: Wire _ NARROW [HashTable.Fetch[nameToWire, name].value];
hasComponents: BOOL = CoreOps.ParseWireName[name].components#NIL;
IF previousWire#NIL THEN previousWire _ RootWire[fusionData, previousWire];
IF previousWire#NIL AND previousWire#wire 
THEN wire _ StructuredFusion[fusionData, wire, previousWire] 
ELSE IF hasComponents THEN names _ CONS [name, names];
[] _ HashTable.Store[nameToWire, name, wire];
IF NOT hasComponents THEN [] _ CoreOps.SetShortWireName[wire, name];
ENDLOOP;
names _ RopeList.Sort[names, RopeList.Compare];
FOR list: ROPES _ RopeList.Sort[names, RopeList.Compare], list.rest WHILE list#NIL DO
name: ROPE _ list.first; 
wire: Wire = RootWire[fusionData, NARROW [HashTable.Fetch[nameToWire, name].value]];
base: ROPE; components: ROPES _ NIL;
matchingWire: Wire;
[base, components] _ CoreOps.ParseWireName[name];
matchingWire _ NARROW [HashTable.Fetch[nameToWire, base].value];
WHILE components#NIL DO
index: INT _ -1;
IF matchingWire=NIL THEN SIGNAL FusionByNameMismatch[fusionData.name, IO.PutFR["Path name %g does not correspond to any wire", IO.rope[name]], wire];
matchingWire _ RootWire[fusionData, matchingWire];
FOR i: NAT IN [0 .. matchingWire.size) DO
subWireName: ROPE _ CoreOps.GetShortWireName[matchingWire[i]];
IF subWireName=NIL THEN subWireName _ IO.PutR1[IO.int[i]];
IF Rope.Equal[subWireName, components.first] THEN {
IF index=-1 THEN index _ i ELSE FusionByNameMismatch[fusionData.name, IO.PutFR["Current wire has 2 or more sub-wires with field `%g'", IO.rope[components.first]], wire];
};
ENDLOOP;
IF index=-1 THEN SIGNAL FusionByNameMismatch[fusionData.name, IO.PutFR["Current wire does not have a sub-wire with field `%g'", IO.rope[components.first]], wire];
matchingWire _ matchingWire[index];
components _ components.rest;
ENDLOOP;
[] _ StructuredFusion[fusionData, matchingWire, wire];
ENDLOOP;
};

AddNameWire: PROC [fusionData: FusionData, name: ROPE, wire: Wire] = {
nameWires: REF LIST OF NameWire _ NARROW [fusionData.data];
nameWires^ _ CONS [[name: name, wire: wire], nameWires^];
};

RootWire: PROC [fusionData: FusionData, wire: Wire] RETURNS [rootWire: Wire] = {
IF wire=NIL THEN SIGNAL InternalBug[fusionData.name];
rootWire _ NARROW [HashTable.Fetch[fusionData.fused, wire].value];
IF rootWire=NIL THEN RETURN [wire];
IF rootWire=wire THEN SIGNAL InternalBug[fusionData.name];
rootWire _ RootWire[fusionData, rootWire];
[] _ HashTable.Replace[fusionData.fused, wire, rootWire];
};

PropFusionProc: TYPE = PROC [prop: ATOM, value1, value2: REF ANY, name: ROPE] RETURNS [value: REF ANY];

NameFusion: PropFusionProc = {
value _ OrNames[NARROW [value1], NARROW [value2], name];
};

DefaultFusion: PropFusionProc = {
IF value1#NIL AND value2#NIL AND value1#value2 THEN SIGNAL FusionPropMismatch[name, prop, value1, value2];
value _ IF value1=NIL THEN value2 ELSE value1;
};
FuseProperties: PUBLIC PROC [mode: Sinix.Mode, fused, root: Wire, name: ROPE] = {
EachProperty: PROC [prop: ATOM, val: REF ANY] = {
rootValue: REF _ CoreProperties.GetWireProp[root, prop];
SELECT prop FROM
CoreOps.nameProp				=> CoreProperties.PutWireProp[root, prop, NameFusion[prop, val, rootValue, name]];
mode.decoration.geometryProp	=> CoreGeometry.AddGeometry[mode.decoration, root, CoreGeometry.GetGeometry[mode.decoration, fused]];
mode.decoration.pinsProp		=> CoreGeometry.AddPins[mode.decoration, root, CoreGeometry.GetPins[mode.decoration, fused]]; -- this never happens during Cell or Abut extraction, because pins are not yet there, but might occur when called from SisyphImpl.ProcessGlobalName
ENDCASE 						=> CoreProperties.PutWireProp[root, prop, DefaultFusion[prop, val, rootValue, name]];
};
CoreProperties.Enumerate[fused.properties, EachProperty];
};
DeleteFused: PROC [fusionData: FusionData, fused, root: Wire] = {
IF ~HashTable.Fetch[fusionData.fused, fused].found THEN SIGNAL InternalBug[fusionData.name];
IF RootWire[fusionData, fused]#fused THEN SIGNAL InternalBug[fusionData.name];
IF ~HashTable.Fetch[fusionData.fused, root].found THEN SIGNAL InternalBug[fusionData.name];
IF RootWire[fusionData, root]#root THEN SIGNAL InternalBug[fusionData.name];
IF fused=root THEN SIGNAL InternalBug[fusionData.name]; -- should never occur
FuseProperties[fusionData.mode, fused, root, fusionData.name]; 
fused.properties _ NIL; -- to help GC
[] _ HashTable.Store[fusionData.fused, fused, root];
};

StructuredFusion: PROC [fusionData: FusionData, wire1, wire2: Wire] RETURNS [wire: Wire] = {
wire1 _ RootWire[fusionData, wire1];
wire2 _ RootWire[fusionData, wire2];
IF wire1=wire2 THEN RETURN [wire1];
SELECT TRUE FROM
wire1=wire2				=> wire _ wire1;
wire1.size=0 				=> {DeleteFused[fusionData, wire1, wire2]; wire _ wire2};
wire2.size=0				=> {DeleteFused[fusionData, wire2, wire1]; wire _ wire1};
wire1.size=wire2.size	=> {
wire _ CreateRoot[fusionData, wire1.size]; 
FOR i: NAT IN [0 .. wire.size) DO
wire[i] _ StructuredFusion[fusionData, wire1[i], wire2[i]];
ENDLOOP;
DeleteFused[fusionData, wire1, wire];
DeleteFused[fusionData, wire2, wire];
};
ENDCASE					=> SIGNAL FusionStructureMismatch[fusionData.name, wire1, wire2]; 
};

FindTouchingWires: PROC [fusionData: FusionData, transformation: Transformation, geometry: Instances] RETURNS [touchingWires: LIST OF Wire _ NIL] = {
FOR insts: Instances _ geometry, insts.rest WHILE insts#NIL DO
inst: Instance _ CoreGeometry.Transform[transformation, insts.first];
layers: LayerRange _ fusionData.mode.instanceLayer[inst];
rect: CD.Rect _ CoreGeometry.InlineBBox[inst];
InternalFindTouchingWires: PROC [instance: Instance, wire: Wire] = {
wire _ RootWire[fusionData, wire];
IF ~HashTable.Fetch[fusionData.fused, wire].found THEN SIGNAL InternalBug[fusionData.name];
IF CoreOps.Member[touchingWires, wire] THEN RETURN;
IF fusionData.mode.touchProc[instance, inst] THEN touchingWires _ CONS [wire, touchingWires];
};
FOR i: NAT IN [layers.min .. layers.max] DO
SinixD2Intervals.Enumerate[fusionData[i], InternalFindTouchingWires, rect];
ENDLOOP;
ENDLOOP;
};
FusionGeometry: PROC [fusionData: FusionData, transformation: Transformation, geometry: Instances, copyGeometry: BOOL] RETURNS [wire: Wire _ NIL] = {
touchingWires: LIST OF Wire _ FindTouchingWires[fusionData, transformation, geometry];
IF touchingWires=NIL THEN {
wire _ CreateRoot[fusionData, 0]; 
InsertInstances[fusionData, transformation, geometry, wire, copyGeometry];
RETURN;
};
wire _ touchingWires.first;
InsertInstances[fusionData, transformation, geometry, wire, copyGeometry];
touchingWires _ touchingWires.rest;
WHILE touchingWires#NIL DO
fused: Wire _ touchingWires.first;
wire _ StructuredFusion[fusionData, fused, wire];
touchingWires _ touchingWires.rest;
ENDLOOP;
};

FusionWire: PROC [fusionData: FusionData, dagTable: HashTable.Table, public: Wire, transformation: Transformation, copyProps: BOOL] RETURNS [actual: Wire] = {
prevActual: Wire _ NARROW [HashTable.Fetch[dagTable, public].value];
structActual: Wire; 
publicName: ROPE _ CoreOps.GetShortWireName[public];
pins: Instances _ CoreGeometry.GetPins[fusionData.mode.decoration, public];
IF prevActual#NIL THEN RETURN [prevActual];
structActual _ CreateRoot[fusionData, public.size, IF copyProps THEN public.properties ELSE NIL]; 
FOR i: NAT IN [0 .. public.size) DO
structActual[i] _ FusionWire[fusionData, dagTable, public[i], transformation, copyProps];
ENDLOOP;
actual _ IF pins=NIL 
THEN structActual 
ELSE StructuredFusion[
fusionData, structActual, 
FusionGeometry[fusionData, transformation, pins, copyProps]
];
IF copyProps AND publicName#NIL THEN AddNameWire[fusionData, publicName, actual];
[] _ HashTable.Store[dagTable, public, actual];
};

FusionWireSeq: PROC [fusionData: FusionData, public: WireSeq, transformation: Transformation] RETURNS [actual: Wire] = {
dagTable: HashTable.Table _ HashTable.Create[3];
actual _ CoreOps.CreateWires[public.size];
FOR i: NAT IN [0 .. actual.size) DO 
actual[i] _ FusionWire[fusionData, dagTable, public[i], transformation, FALSE];
ENDLOOP;
};

SortInstances: PROC [instances: LIST OF CD.Instance] RETURNS [sorted: LIST OF CD.Instance _ NIL] = {
Eval: PROC [inst: CD.Instance] RETURNS [INT] = {
pos: CD.Position _ CDBasics.BaseOfRect[CDInstances.InstRectI[inst]];
RETURN [pos.x+pos.y];
};
Compare: GList.CompareProc = {
RETURN [Basics.CompareINT[Eval[NARROW [ref1]], Eval[NARROW [ref2]]]];
};
sorted _ NARROW [GList.Sort[instances, Compare]]; 
};
cacheProp: ATOM _ PWObjects.RegisterProp[$SinixCache, FALSE, TRUE];

Extract: PUBLIC ExtractProc = {
cache: Cache _ NARROW [CDProperties.GetObjectProp[obj, cacheProp]];
CDProperties.PutObjectProp[obj, satellitesProp, CDSatellites.GetSatelliteRopes[obj]];
IF cache#NIL AND cache.mode=mode AND mode.equalProc[obj, cache.properties, cache.userData, properties, userData] THEN RETURN [result: cache.result, props: cache.props];
BEGIN
priority: CedarProcess.Priority _ CedarProcess.GetPriority[];
atom: ATOM _ NARROW [CDProperties.GetListProp[properties, mode.extractProcProp]];
extractProc: ExtractProc;
IF atom=NIL THEN atom _ NARROW [CDProperties.GetObjectProp[obj, mode.extractProcProp]];
IF atom=NIL THEN atom _ NARROW [CDProperties.GetProp[obj.class, mode.extractProcProp]];
IF atom=NIL THEN extractProc _ ExtractExpand ELSE {
refProc: REF ExtractProc _ NARROW [HashTable.Fetch[registeredExtractProcs, atom].value];
IF refProc=NIL THEN {
TerminalIO.PutF["*** ExtractProc $%g not registered.  You must run the program defining it.\n", IO.atom[atom]]; SIGNAL CallerBug[];
};
extractProc _ refProc^;
};
CedarProcess.CheckAbort[];
CedarProcess.SetPriority[background];
Process.Yield[];
[result, props] _ extractProc[obj, mode, properties, userData];
WITH result SELECT FROM
wire: Wire 			=> {};
wires: Wires 			=> {};
cellType: CellType 	=> IF NOT CoreGeometry.HasObject[mode.decoration, cellType] THEN SIGNAL CallerBug[]; -- decorations missing!
ENDCASE				=> IF result#NIL THEN SIGNAL CallerBug[]; -- probably some ExtractProc is grossly wrong
CedarProcess.SetPriority[priority];
CDProperties.PutObjectProp[obj, cacheProp, NEW [CacheRec _ [mode: mode, properties: properties, userData: userData, result: result, props: props]]];
END;
};

registeredExtractProcs: HashTable.Table _ HashTable.Create[];

RegisterExtractProc: PUBLIC PROC [key: ATOM, extractProc: ExtractProc] = {
IF NOT HashTable.Store[registeredExtractProcs, key, NEW [ExtractProc _ extractProc]] THEN TerminalIO.PutF["ExtractProc overwritten for $%g.\n", IO.atom[key]];
};

ExtractCell: PUBLIC ExtractProc = {
ir: CD.Rect _ CD.InterestRect[obj];
cdInstances: LIST OF CD.Instance _ NIL;
nbOfInstances: INT = CDCells.CountInstances[obj];
fusionData: FusionData _ NEW [FusionDataRec[mode.nbOfLayers]];
currentInstances: LIST OF CoreClasses.CellInstance _ NIL;
EachInstance: CDCells.InstEnumerator = {cdInstances _ CONS [inst, cdInstances]};
[] _ CDCells.EnumerateInstances[obj, EachInstance];
cdInstances _ SortInstances[cdInstances]; -- Modified in place!
TerminalIO.PutF["Extracting [%g] cell %g (bbox: %g, instances: %g)\n", IO.rope[IF mode.fusionByName=none THEN IO.PutFR["%g[%g]", IO.rope[mode.decoration.name], IO.int[NARROW [userData, REF INT]^]] ELSE mode.decoration.name], IO.rope[CDDirectory.Name[obj]], rect[obj.bbox], IO.int[nbOfInstances]];
fusionData.mode _ mode; fusionData.name _ CDDirectory.Name[obj]; 
fusionData.nir _ IF mode.fusionByName=none 
THEN CDBasics.Extend[ir, - NARROW [userData, REF INT]^] ELSE ir; 
fusionData.fused _ HashTable.Create[3]; fusionData.data _ NEW [LIST OF NameWire _ NIL]; fusionData.isAbut _ FALSE;
FOR i: NAT IN [0 .. mode.nbOfLayers) DO
fusionData[i] _ SinixD2Intervals.Create[
logHashSize: SELECT TRUE FROM nbOfInstances<=7 => 3, nbOfInstances<=60 => 5, ENDCASE => 11,
range: obj.bbox
];
ENDLOOP;
CDProperties.PutObjectProp[obj, satellitesProp, CDSatellites.GetSatelliteRopes[obj]]; -- to reinforce invariantes on the object (restriction of CDSatellites)
WHILE cdInstances#NIL DO
cdInstance: CD.Instance _ cdInstances.first;
subUserData: REF _ userData;
subResult: REF; subProps: Properties;
CDProperties.PutInstanceProp[cdInstance, satellitesProp, CDSatellites.GetSatelliteRopes[cdInstance]];
IF mode.fusionByName=none THEN {
UnionOverlap: PROC [rect: CD.Rect] = {
interSize: CD.Position;
IF overlap+overlap>bbox.x2-bbox.x1 OR overlap+overlap>bbox.y2-bbox.y1 THEN RETURN;
interSize _ CDBasics.SizeOfRect[CDBasics.Intersection[rect, CDBasics.Extend[bbox, -overlap]]];
overlap _ MAX [overlap, MIN [interSize.x, interSize.y]];
IF overlap+overlap>bbox.x2-bbox.x1 OR overlap+overlap>bbox.y2-bbox.y1 THEN RETURN;
interSize _ CDBasics.SizeOfRect[CDBasics.Intersection[rect, CDBasics.Extend[bbox, -overlap]]];
overlap _ MAX [overlap, MIN [interSize.x, interSize.y]];
};
EachInstanceOverlap: CDCells.InstEnumerator = {
IF inst#cdInstance THEN UnionOverlap[CDInstances.InstRectO[inst]];
};
bbox: CD.Rect _ CDInstances.InstRectI[cdInstance];
overlap: INT _ 0;
UnionOverlap[[FIRST[INT], FIRST[INT], fusionData.nir.x1, LAST[INT]]];
UnionOverlap[[fusionData.nir.x2, FIRST[INT], LAST[INT], LAST[INT]]];
UnionOverlap[[FIRST[INT], FIRST[INT], LAST[INT], fusionData.nir.y1]];
UnionOverlap[[FIRST[INT], fusionData.nir.y2, LAST[INT], LAST[INT]]];
[] _ CDCells.EnumerateInstances[obj, EachInstanceOverlap];
subUserData _ NEW [INT _ overlap];
};
[subResult, subProps] _ Extract[cdInstance.ob, mode, cdInstance.properties, subUserData];
IF subResult#NIL THEN WITH subResult SELECT FROM
subWire: Wire 			=> {
[] _ FusionWire[fusionData, HashTable.Create[1], subWire, cdInstance.trans, TRUE];
};
subWires: Wires 			=> {
dagTable: HashTable.Table _ HashTable.Create[3];
WHILE subWires#NIL DO
[] _ FusionWire[fusionData, dagTable, subWires.first, cdInstance.trans, TRUE];
subWires _ subWires.rest;
ENDLOOP;
};
subCellType: CellType	=> {
bbox: CD.Rect _ CDInstances.BoundingRectO[cdInstances.rest];
instance: CoreClasses.CellInstance _ CoreClasses.CreateInstance[
actual: FusionWireSeq[fusionData, subCellType.public, cdInstance.trans], 
type: subCellType, props: subProps
];
CoreGeometry.PutTrans[mode.decoration, instance, cdInstance.trans];
currentInstances _ CONS [instance, currentInstances];
FOR i: NAT IN [0 .. mode.nbOfLayers) DO
SinixD2Intervals.DeleteOutside[fusionData[i], bbox];
ENDLOOP;
};
ENDCASE				=> SIGNAL InternalBug[fusionData.name];
cdInstances _ cdInstances.rest;
ENDLOOP;
SELECT mode.fusionByName FROM
layout		=> LayoutFusionByName[fusionData];
none			=> NoFusionByName[fusionData];
schematics	=> SchematicsFusionByName[fusionData];
ENDCASE		=> CallerBug[]; --no way to do fusionByName in this mode!
result _ MakeResult[fusionData, obj, currentInstances];
};

AbutFusionWire: PROC [fusionData: FusionData, dagTable: HashTable.Table, public: Wire, transformation: Transformation, subIr: CD.Rect] RETURNS [actual: Wire] = {
RecordEachPin: CoreGeometry.EachInstanceProc = {
sides: CoreGeometry.Sides _ CoreGeometry.GetSides[subIr, instance];
IF (~inX AND sides[bottom]) OR (inX AND sides[left]) 
THEN thesePins _ CONS [instance, thesePins];
IF (~inX AND sides[top]) OR (inX AND sides[right]) THEN {
inst: Instance _ CoreGeometry.Transform[transformation, instance];
layers: LayerRange _ mode.instanceLayer[inst];
FOR i: NAT IN [layers.min .. layers.max] DO SinixD2Intervals.Insert[abutData[i], inst, structActual] ENDLOOP;
};
IF NOT CoreGeometry.TransfedNotAtEdge[transformation, nir, instance] 
THEN CoreProperties.PutWireProp[structActual, $Public, $Public];
};
prevActual: Wire _ NARROW [HashTable.Fetch[dagTable, public].value];
structActual: Wire; 
abutData: AbutData _ NARROW [fusionData.data];
thesePins: Instances _ NIL; -- not transformed
mode: Mode _ fusionData.mode;
inX: BOOL _ abutData.inX;
nir: CD.Rect _ fusionData.nir;
IF prevActual#NIL THEN RETURN [prevActual];
structActual _ CreateRoot[fusionData, public.size]; 
[] _ CoreGeometry.EnumeratePins[fusionData.mode.decoration, public, RecordEachPin];
FOR i: NAT IN [0 .. public.size) DO
structActual[i] _ AbutFusionWire[fusionData, dagTable, public[i], transformation, subIr];
ENDLOOP;
actual _ IF thesePins=NIL 
THEN structActual 
ELSE StructuredFusion[
fusionData, structActual, 
FusionGeometry[fusionData, transformation, thesePins, FALSE]
];
[] _ HashTable.Store[dagTable, public, actual];
};

AbutFusionWireSeq: PROC [fusionData: FusionData, public: WireSeq, transformation: Transformation, subIr: CD.Rect] RETURNS [actual: Wire] = {
dagTable: HashTable.Table _ HashTable.Create[3];
actual _ CoreOps.CreateWires[public.size];
FOR i: NAT IN [0 .. actual.size) DO 
actual[i] _ AbutFusionWire[fusionData, dagTable, public[i], transformation, subIr];
ENDLOOP;
};

ExtractAbut: PUBLIC ExtractProc = {
ir: CD.Rect _ CD.InterestRect[obj];
range: CD.Rect _ obj.bbox;
fusionData: FusionData _ NEW [FusionDataRec[mode.nbOfLayers]];
abutData: AbutData _ NEW [AbutDataRec[mode.nbOfLayers]];
currentInstances: LIST OF CoreClasses.CellInstance _ NIL;
count: NAT _ 0;
EachAbutSubObject: PWObjects.EachSubObjectProc = {
subIr: CD.Rect _ CD.InterestRect[subObject]; -- in the transformation coordonnate system
subResult: REF; subCellType: CellType; subProps: Properties;
instance: CoreClasses.CellInstance;
transformation: Transformation = [CDBasics.SubPoints[pos, CDBasics.BaseOfRect[subIr]]];
[subResult, subProps] _ Extract[subObject, mode, NIL, userData];
subCellType _ NARROW [subResult];
instance _ CoreClasses.CreateInstance[
actual: AbutFusionWireSeq[fusionData, subCellType.public, transformation, subIr], 
type: subCellType, props: subProps
];
IF ~CoreOps.CorrectConform[instance.actual, subCellType.public] THEN SIGNAL StructureMismatch[fusionData.name, instance.actual, subCellType.public];
FOR i: NAT IN [0 .. mode.nbOfLayers) DO
table: SinixD2Intervals.Table _ fusionData[i];
fusionData[i] _ abutData[i]; abutData[i] _ table; 
SinixD2Intervals.DeleteOutside[table, SinixD2Intervals.universe];
ENDLOOP;
CoreGeometry.PutTrans[mode.decoration, instance, transformation];
currentInstances _ CONS [instance, currentInstances];
};
CountAbutSubObject: PWObjects.EachSubObjectProc = {count _ count + 1};
PWObjects.EnumerateSubObjects[obj, CountAbutSubObject];
fusionData.mode _ mode; fusionData.name _ CDDirectory.Name[obj]; fusionData.fused _ HashTable.Create[3]; fusionData.data _ abutData; fusionData.isAbut _ TRUE;
fusionData.nir _ IF mode.fusionByName=none 
THEN CDBasics.Extend[ir, - NARROW [userData, REF INT]^] ELSE ir; 
abutData.inX _ obj.class=PWObjects.abutXClass; 
FOR i: NAT IN [0 .. mode.nbOfLayers) DO
abutData[i] _ SinixD2Intervals.Create[range: range];
ENDLOOP;
FOR i: NAT IN [0 .. mode.nbOfLayers) DO
fusionData[i] _ SinixD2Intervals.Create[range: range];
ENDLOOP;
TerminalIO.PutF["Extracting [%g] abut %g (bbox: %g, instances: %g)\n", IO.rope[mode.decoration.name], IO.rope[CDDirectory.Name[obj]], rect[obj.bbox], IO.int[count]];
PWObjects.EnumerateSubObjects[obj, EachAbutSubObject];
result _ MakeResult[fusionData, obj, currentInstances];
};

ExtractExpand: PUBLIC ExtractProc = {
newObj: CD.Object _ CDDirectory.Expand[obj, NIL, NIL].new;
TerminalIO.PutF["Expanding [%g] object %g of class %g\n", IO.rope[mode.decoration.name], IO.rope[CDDirectory.Name[obj]], IO.atom[obj.class.objectType]];
IF newObj=NIL THEN SIGNAL CallerBug[]; -- no expand proc found for this object that we do not know how to extract!
RETURN Extract[newObj, mode, CDProperties.DAppendProps[obj.properties, properties], userData];
};

OrNames: PROC [name1, name2, objName: ROPE] RETURNS [name: ROPE _ NIL] = {
IF name1=NIL THEN RETURN [name2];
IF name2=NIL THEN RETURN [name1];
IF Rope.Equal[name1, name2] THEN RETURN [name1];
SIGNAL FusionPropMismatch[objName, CoreOps.nameProp, name1, name2];
};

NameFromSatellites: PROC [obj: Object, properties: CD.PropList] RETURNS [name: ROPE _ NIL] = {
objName: ROPE = CDDirectory.Name[obj];
name _ NARROW [CDProperties.GetListProp[properties, $SignalName]];
FOR ropes: ROPES _ NARROW [CDProperties.GetListProp[properties, satellitesProp]], ropes.rest 
WHILE ropes#NIL DO name _ OrNames[name, ropes.first, objName] ENDLOOP;
FOR ropes: ROPES _ NARROW [CDProperties.GetObjectProp[obj, satellitesProp]], ropes.rest 
WHILE ropes#NIL DO name _ OrNames[name, ropes.first, objName] ENDLOOP;
};

ExtractRect: PUBLIC ExtractProc = {
wire: Wire;
IF obj.layer=CD.shadeLayer OR obj.layer=CD.errorLayer OR obj.layer=CD.backgroundLayer OR obj.layer=CD.outlineLayer OR obj.layer=CD.selectionLayer OR obj.layer=CD.commentLayer THEN RETURN [NIL];
wire _ CoreOps.CreateWire[name: NameFromSatellites[obj, properties]];
CoreGeometry.PutPins[mode.decoration, wire, LIST [[obj]]];
result _ wire;
};

ExtractPin: PUBLIC ExtractProc = {
wire: Wire;
instance: CD.Instance _ CDInstances.NewInst[ob: obj, properties: properties];
pinName: ROPE _ CDSymbolicObjects.GetName[instance];
IF NOT Rope.Equal[NameFromSatellites[obj, properties], pinName] THEN SIGNAL CallerBug[];
wire _ CoreOps.CreateWire[name: pinName];
CoreGeometry.PutPins[mode.decoration, wire, LIST [[CoreGeometry.CDPinToCoreGeometryPin[obj, properties]]]];
result _ wire;
};

ExtractAtomic: PUBLIC ExtractProc = {
wire: Wire;
wire _ CoreOps.CreateWire[name: NameFromSatellites[obj, properties]];
CoreGeometry.PutPins[mode.decoration, wire, LIST [[obj]]];
result _ wire;
};

ExtractNull: PUBLIC ExtractProc = {result _ NIL};

LazyPinsEnumerate: CoreGeometry.LazyEnumerateProc = {
node: PWObjects.Node _ NARROW [data1];
rir: REF CD.Rect _ NARROW [data2];
FOR i: NAT IN [0 .. node.size) DO
instance: CoreGeometry.Instance = [node[i].object, [node[i].position]];
IF CoreGeometry.AtEdge[rir^, instance] THEN quit _ eachInstance[instance];
IF quit THEN RETURN;
ENDLOOP;
};

LazyGeometryEnumerate: CoreGeometry.LazyEnumerateProc = {
node: PWObjects.Node _ NARROW [data1];
FOR i: NAT IN [0 .. node.size) DO
quit _ eachInstance[[node[i].object, [node[i].position]]];
IF quit THEN RETURN;
ENDLOOP;
};

ExtractRouting: ExtractProc = {
cellType: CellType;
routing: PWObjects.RoutingSpecific = NARROW [obj.specific];
publics: LIST OF Wire _ NIL;
TerminalIO.PutF["Extracting [%g] routing %g (nodes: %g)\n", IO.rope[mode.decoration.name], IO.rope[CDDirectory.Name[obj]], IO.int[routing.size]];
FOR i: NAT IN [0 .. routing.size) DO
node: PWObjects.Node = routing[i];
name: ROPE = NARROW [CDProperties.GetListProp[node.properties, $SignalName]];
wire: Wire _ CoreOps.CreateWire[name: name];
CoreGeometry.PutLazyGeometry[mode.decoration, wire, LazyGeometryEnumerate, node];
CoreGeometry.PutLazyPins[mode.decoration, wire, LazyPinsEnumerate, node, NEW [CD.Rect _ routing.ir]];
publics _ CONS [wire, publics];
ENDLOOP;
cellType _ CoreClasses.CreateRecordCell[
public: CoreOps.CreateWire[publics], 
internal: CoreOps.CreateWire[publics],
instances: NIL,
name: CDDirectory.Name[obj]
];
CoreGeometry.PutObject[mode.decoration, cellType, obj];
result _ cellType;
};
DefaultInstanceLayer: PUBLIC PROC [Instance] RETURNS [LayerRange] = {RETURN [[0, 0]]};
AlwaysTrue: PUBLIC PROC [obj: CD.Object, properties1: CD.PropList, userData1: REF, properties2: CD.PropList, userData2: REF] RETURNS [BOOL _ TRUE] = {};
AlwaysFalse: PUBLIC PROC [obj: CD.Object, properties1: CD.PropList, userData1: REF, properties2: CD.PropList, userData2: REF] RETURNS [BOOL _ FALSE] = {};
CompareProps: PUBLIC PROC [obj: CD.Object, properties1: CD.PropList, userData1: REF, properties2: CD.PropList, userData2: REF] RETURNS [BOOL] = {
FOR p1: CD.PropList _ properties1, p1.rest WHILE p1#NIL DO
IF CDProperties.GetListProp[properties2, p1.first.key]#p1.first.val THEN RETURN [FALSE];
ENDLOOP;
FOR p2: CD.PropList _ properties2, p2.rest WHILE p2#NIL DO
IF CDProperties.GetListProp[properties1, p2.first.key]#p2.first.val THEN RETURN [FALSE];
ENDLOOP;
RETURN [TRUE];
};

satellitesProp: PUBLIC ATOM _ PWObjects.RegisterProp[$SinixSatellites];
RegisterExtractProc[$ExtractCell, ExtractCell];
RegisterExtractProc[$ExtractAbut, ExtractAbut];
RegisterExtractProc[$ExtractExpand, ExtractExpand];
RegisterExtractProc[$ExtractRect, ExtractRect];
RegisterExtractProc[$ExtractPin, ExtractPin];
RegisterExtractProc[$ExtractAtomic, ExtractAtomic];
RegisterExtractProc[$ExtractNull, ExtractNull];
RegisterExtractProc[$ExtractRouting, ExtractRouting];

END.

	>SinixImpl.mesa
Copyright c 1985, 1986 by Xerox Corporation.  All rights reversed.
Created by Bertrand Serlet August 15, 1985 2:09:54 pm PDT
Bertrand Serlet March 15, 1987 1:16:32 am PST
Pradeep Sindhu May 5, 1986 5:16:10 pm PDT
Barth, April 18, 1986 4:42:48 pm PST

Signals
Type Aliases
Cache
Fusion data structure and internal manipulation
copyGeometry indicates if this geometry is only going to be used for fusion and does not have to figure in the geometry and pins properties (real geometry versus geometry at the level below).
If a pin is found we just note that this is a public wire
Fusion external manipulation
Creates a DAG Wire from a HashTable, getting rid of wires that have their father also in the list.  
delete all the sons
32 should be enough to avoid 815
We find out who are the publics and internals
We replace in all instances wires by their roots
We build the CellType
We set all pins to be lazy for that record
We correct previous statement for all explicit geometry
We first fuse all the nameWire with same name, and at the same time prepare the list of all the names that have components
We sort the names, using the trick that foo[2].mumble or foo[2][3] are after foo[2] in the lexicographic order
The following PROC implements Fisher-Galler fusion, not for efficiency, but for simplicity
This mechanism could be exported if we wanted that.

Appends the properties of fused to the ones of root, but treating short names specially

This proc really does the fusion of fused and root, by wiping fused of some tables, and adding interesting properties of fused to root.
Other Internal utilities
The complexity of this proc is partly due to the fact that we have a DAG
Attention: modifies physically its argument!
Extraction
We detect trivial causes of bugs!
Compute the right overlap of theses cells on this instance
it is impossible here to check for conformance, since fusion might have been done differently in different parts of the DAG
We try to simplify fusionData by getting rid of all pieces of geometry which are outside the bounding box for sure
Time to do fusion by name!
The main loop over "instances".  Attention, we are assuming here that we are seing instances from left to right and bottom to top [this assumption is made in AbutFusionWire by the chosen sides]
We build the CellType
Extraction mode procs
Initialization
Κ"~–

"cedar" style˜
codeš
œ™Kšœ
Οm
œ7™BKšœ6Οk™9Kš
œ-™-Kšœ&ž™)Kšœ!ž™$—K™šž	œ
˜
K˜Kšžœ]˜_Kš
œ˜Kš
œ,˜,Kš
œ
˜
Kšœžœ
˜Kš
œ
˜
Kš
œ˜Kš
œ$˜$—K˜•StartOfExpansion[]šΠbn	œžœ
ž˜Kšžœ	žœΔ
žœ0˜ˆKšžœ˜
Kšžœ˜Kšžœ
žœ˜—
head™Jš
Οnœžœ
žœžœžœ
˜/JšŸ	œžœ
žœžœ
˜#Jš œžœ
žœžœžœžœžœ
˜WJš
 œžœ
žœžœžœ
˜OJš
 œžœ
žœžœ žœ
˜QJš
 œžœ
žœ
žœžœ
˜IJš
 œžœ
žœžœžœ
˜>—™Jš
žœžœžœ
žœ
žœ
˜Kšœžœ˜3Kšœ
žœ˜'Kšœžœ˜)—™Jšœžœžœ
˜šœ
žœžœ˜Jš	œžœžœžœžœ˜@Jšœžœž˜$Jš
œ˜J˜—Jš
 
œžœ
žœžœ7žœ˜]—™/šœ
žœžœžœ˜1J˜—Jšœžœžœ˜%šœžœžœ˜JšœΟc˜.Jšœžœ‘_˜rJšœžœ‘)˜:Jšœžœ‘,˜>Jšœ‘’
˜«
Jšœžœ‘θ
˜ω
Jšœžœ
žœ
žœ‘g˜‘
J˜J˜—Jšœ
žœžœ
˜!šœ
žœžœ˜Jšœžœ‘˜-Jšœžœ
žœ
žœ‘g˜₯
J˜J˜—š	œžœžœžœžœ˜.Kšžœžœžœžœžœžœžœ˜gKš
œ˜K˜—š
 
œžœ žœžœžœ˜fš œžœžœžœ
žœžœ˜7šœžœ
žœžœž˜"Jšœ'žœ
˜+Jšœ+žœ
˜/Jšœžœ
˜Jšžœ˜—Jš
œ/˜/J˜—Jš
œ'˜'Jš
œ.˜.Jšœ-žœ˜2J˜J˜—Jš
œΏ
™Ώ
š œžœjžœ˜ˆ
šžœ0˜2Jšžœ
žœ˜)—Jšžœ!žœ
žœ˜Lšžœ$žœžœ
ž˜6Jš
œB˜BJš
œ9˜9Jš
žœžœ
žœžœ4žœ
˜gJš
œ9™9šžœ+˜-Jšžœ4˜8—Jšžœ
˜—Jšžœžœs˜‡
J˜——™Jšœ
žœW™dš œžœžœ˜KJšœžœ
žœžœ
˜šŸ
œ˜+š 
œžœ˜!Jšžœ žœ
žœ‘˜>šžœžœ
žœž˜!Jš
œ˜Jšžœ
˜—J˜—Jšœ
žœ˜šžœžœ
žœžœ
˜"Jš
œ™Jš
œ˜Jšžœ
˜—J˜—Jšœžœ˜šŸœ˜,Jšœžœ˜J˜J˜—Jš
œ+˜+Jš
œ5˜5Jš
œ,˜,Jšžœ žœ
žœ
žœ˜?J˜J˜—š 
œžœžœžœ
žœžœ˜‰
Jš
œA˜AJš
œ/˜/Jš
œ1˜1š œ˜,š 
œžœžœ
˜4Jš
œ ™ Jšžœžœ
žœ(‘&˜fJšžœ!žœ
žœ˜Lšžœžœ
žœž˜!Jš
œ(˜(Jš
œ˜Jšžœ
˜—Jš
œ˜—Jšœ
žœ˜Jš	žœžœ
žœ
žœ‘˜5Jšœ&žœ˜+šžœ+žœ
žœ˜7Jšœ$žœ˜*Jšœ*žœ˜/Jš
œ˜—Jš
œ˜Jš
œ˜—š œ˜)Jšœžœ
˜š œ#˜)Jšžœ/žœžœ˜SJ˜—Jš
œ>˜>Jš
œ-˜-J˜—Jš
œ-™-Jš
œ7˜7Jš
œ0™0šžœžœ
žœ5žœžœ
ž˜WJš
œ0˜0Jš
œ˜šžœžœ
žœž˜#Jš
œ-˜-Jšžœ8žœ
žœD˜‰
Jš
œ˜Jšžœ
˜—Jšžœ
˜—Jš
œ™š
œ&˜&Jš
œI˜IJš
œ˜Jš
œ˜Jšœž˜J˜—Jš
œ0˜0Jš
œ*™*Jš
œC˜CJš
œ7™7Jš
œ:˜:J˜J˜—š œžœ˜5Jš	œ	žœ
žœ
žœžœ˜9Jš
œn˜nšžœžœ
žœ%žœžœ
ž˜QJš
œ8˜8JšœžœS˜]Jšœžœ+˜Fšžœžœ
žœ˜Jš
œ2˜2šžœžœ˜Jš
œ8˜8Jšœ;žœ
žœ˜dJš
œ=˜=J˜—J˜—Jš
œ-˜-Jš
œ*˜*Jšžœ
˜—J˜J˜—š œžœ˜1Jš	œ	žœ
žœ
žœžœ˜9š œ˜*Jšœ
žœ˜Jšœžœžœ˜Jšœžœ	˜Jš
œ1˜1Jš
œ˜Jšžœžœ
žœ
žœ
˜Jšœ>žœ
žœ˜gšžœžœ
ž˜Jšœ+žœžœ
žœ˜`Jš
œ˜Jš
œ˜Jšžœ
˜—J˜—Jšœp‘D˜΄
šžœžœ
žœ%žœžœ
ž˜QJšœžœ˜#Jš
œ8˜8Jšœžœ,˜AJšžœ
žœžœ	žœ˜CJš
œ/˜/Jšžœ
˜—Jš
œ0˜0J˜J˜—š œžœ˜9Jš	œ	žœ
žœ
žœžœ˜9Jš
œn˜nJšœžœžœ
˜Jš
œz™zšžœžœ
žœ%žœžœ
ž˜QJš
œ8˜8JšœžœS˜]Jšœžœ+˜FJšœžœ*žœ
˜AJšžœžœ
žœ3˜Kšžœžœ
žœ˜*Jšžœ9˜=Jšžœ
žœžœ	žœ˜6—Jš
œ-˜-Jšžœ
žœžœ+˜DJšžœ
˜—Jš
œn™nJš
œ/˜/š	žœžœ5žœžœ
ž˜UJšœžœ˜Jšœ"žœ,˜TJšœžœžœžœ
˜$Jš
œ˜Jš
œ1˜1Jšœžœ+˜@šžœžœ
ž˜Jšœžœ˜Jšžœžœ
žœ
žœ'žœ7žœ˜•
Jš
œ2˜2šžœžœ
žœž˜)Jšœ
žœ-˜>Jš
žœ
žœ
žœžœžœ	˜:šžœ+žœ˜3Jš
žœ
žœžœ'žœ?žœ ˜©
Jš
œ˜—Jšžœ
˜—Jš
žœ
žœ
žœ'žœ@žœ ˜’
Jš
œ#˜#Jš
œ˜Jšžœ
˜—Jš
œ6˜6Jšžœ
˜—J˜J˜—š œžœ žœ˜FJš	œžœ
žœ
žœžœ˜;Jšœ
žœ(˜9J˜K˜—JšœžœH™Zš œžœ&žœ˜PJšžœžœ
žœ
žœ˜5Jšœžœ1˜BJšžœ
žœ
žœ
žœ˜#Jšžœžœ
žœ˜:Jš
œ*˜*Jš
œ9˜9J˜J˜—K™3šœžœžœžœžœ
žœžœžœ	žœ
žœ˜gK˜—šŸ
œ˜Kšœžœžœ˜8K˜K˜—šŸ
œ˜!Jšžœžœ
žœžœ
žœžœ
žœ0˜jJš	œžœžœ
žœžœ˜.K˜J™—Jš
œW™Wš œžœ
žœ-žœ˜Qš
 œžœžœžœ
žœ˜1Jšœžœ*˜8šžœž˜Jš
œf˜fJš
œ‚
˜‚
Jšœx‘“
˜‹Jšžœ\˜c—J˜—Jš
œ9˜9J˜J™—Jš
œ‡
™‡
š œžœ0˜AJšžœ1žœ
žœ˜\Jšžœ#žœ
žœ˜NJšžœ0žœ
žœ˜[Jšžœ!žœ
žœ˜LJšžœžœ
žœ‘˜MJš
œ?˜?Jšœžœ‘
˜%Jš
œ4˜4J˜J˜—š œžœ.žœ˜\Jš
œ$˜$Jš
œ$˜$Jšžœ
žœ
žœ	˜#šžœ
žœ
ž˜Jš
œ˜Jš
œJ˜JJš
œI˜Iš
œ˜Jš
œ+˜+šžœžœ
žœž˜!Jš
œ;˜;Jšžœ
˜—Jš
œ%˜%Jš
œ%˜%J˜—Jšžœžœ9˜N—J˜J˜—š œžœOžœžœ
žœžœ˜•
šžœ)žœžœ
ž˜>Jš
œE˜EJš
œ9˜9J–> -- [key: RefTab.Key, val: RefTab.Val] RETURNS [quit: BOOLEAN]šœžœ&˜.šŸœžœ%˜DJš
œ"˜"Jšžœ0žœ
žœ˜[Jšžœ%žœ
žœ
˜3Jšžœ+žœžœ˜]J˜—šžœžœ
žœž˜+Jš
œK˜KJšžœ
˜—Jšžœ
˜—J˜——™š
 œžœ]žœžœžœ˜•
Jšœžœ
žœ@˜Všžœžœ
žœ˜Jš
œ"˜"Jš
œJ˜JJšžœ
˜J˜—Jš
œ˜Jš
œJ˜JJš
œ#˜#šžœžœ
ž˜Jš
œ"˜"Jš
œ1˜1Jš
œ#˜#Jšžœ
˜—J˜J˜—JšœEž™Hš 
œžœnžœžœ˜ž
Jšœžœ+˜DJš
œ˜Jšœžœ$˜4Jš
œK˜KJšžœžœ
žœ
žœ˜+Jš	œ3žœžœžœ
žœ˜bšžœžœ
žœž˜#Jš
œY˜YJšžœ
˜—šœ	žœžœ
˜Jšžœ˜šžœ˜Jš
œ˜Jš
œ;˜;Jš
œ˜——Jšžœžœžœ
žœ-˜QJš
œ/˜/J˜J˜—š 
œžœKžœ˜xJš
œ0˜0Jš
œ*˜*šžœžœ
žœžœ
˜$JšœHžœ˜OJšžœ
˜—J˜J˜—Jš
œ,™,š 
œžœ
žœ
žœ
žœžœ
žœ
žœ
žœžœ˜dš
 œžœžœžœžœ˜0Jšœžœ=˜DJšžœ˜J˜—š œ˜Jšžœžœžœ˜EJ˜—Jšœ	žœ#˜2J˜——™
Jšœžœ'žœžœ˜CJ˜šŸœžœ˜Jšœžœ.˜CJš
œU˜UJšžœžœ
žœžœMžœ
žœ,˜¨
š
ž˜Jš
œ=˜=Jšœžœžœ>˜QJ˜Jšžœžœ
žœžœ9˜WJšžœžœ
žœžœ9˜Wšžœžœ
žœžœ˜3Jšœ	žœžœ7˜Xšžœ	žœ
žœ˜Jšœ`žœžœ
˜ƒ
J˜—Jš
œ˜J˜—Jš
œ˜Jš
œ%˜%Jš
œ˜Jš
œ?˜?Jš
œ!™!šžœžœ
ž˜J˜J˜Jš
œžœ
žœ3žœ
žœ‘˜€
Jšžœžœžœ
žœ
žœ‘-˜b—Jš
œ#˜#Jšœ+žœf˜”
Jšžœ
˜—J˜J˜—š
œ=˜=J˜—š œžœ
žœžœ˜JJš
žœ
žœ.žœžœ7žœ˜ž
J˜J˜—šŸœžœ˜#Jšœžœžœ˜#Jš	œ
žœ
žœ
žœžœ
˜'Jšœžœ˜1Jšœžœ"˜>Jšœžœ
žœžœ
˜9Jš œ*žœ˜PJš
œ3˜3Jšœ*‘˜?JšœGžœžœžœ
žœžœžœžœžœ
žœžœžœ.žœ˜¨Jš
œA˜Ašœžœ˜+Jš
žœžœžœ
žœžœ˜A—Jšœ:žœžœ
žœžœžœ
˜ršžœžœ
žœž˜'š
œ(˜(Jš	œ
žœ
žœ
žœ0žœ˜[Jš
œ˜Jš
œ˜—Jšžœ
˜—JšœV‘G˜
šžœ
žœ
ž˜Jšœžœ˜,Jšœ
žœ˜Jšœžœ˜%Jš
œe˜ešžœžœ˜ š œžœžœ
˜&Jšœžœ
˜Jšžœ!žœ!žœ
žœ
˜RJš
œ^˜^Jšœ
žœžœ˜8Jšžœ!žœ!žœ
žœ
˜RJš
œ^˜^Jšœ
žœžœ˜8J˜—š œ˜/Jšžœžœ+˜BJš
œ˜—Jš
œ:™:Jšœžœ*˜2Jšœ	žœ˜Jš
œžœ
žœžœ
žœžœ
žœ˜EJš
œ!žœ
žœžœ
žœžœ
žœ˜DJš
œžœ
žœžœ
žœžœ
žœ˜EJš
œžœ
žœžœ
žœžœ
žœ˜DJš
œ:˜:Jšœžœžœ˜"J˜—Jš
œY˜Yšžœžœ
žœ
žœžœ
ž˜0š
œ˜JšœLžœ˜RJ˜—š
œ˜Jš
œ0˜0šžœ
žœ
ž˜JšœHžœ˜NJš
œ˜Jšžœ
˜—J˜—š
œ˜Jšœžœ4˜<š
œ@˜@Jš
œI˜IJš
œ"˜"Jš
œ˜—Jšœxž™{Jš
œC˜CJšœžœ˜5Jš
œr™ršžœžœ
žœž˜'Jš
œ4˜4Jšžœ
˜—J˜—Jšžœžœ˜2—Jš
œ˜Jšžœ
˜—J™šžœž˜Jš
œ*˜*Jš
œ%˜%Jš
œ1˜1Jšžœ‘)˜B—Jš
œ7˜7J˜J˜—š œžœjžœžœ˜‘
š 
œ#˜0Jš
œC˜Cšžœžœžœžœ˜5Jšžœ
žœ˜,—š
žœžœ
žœžœžœ˜9Jš
œB˜BJš
œ.˜.Jš
žœžœ
žœžœ:žœ
˜mJ˜—šžœ
žœ?˜EJšžœ<˜@—J˜—Jšœžœ+˜DJš
œ˜Jšœžœ˜.Jšœžœ‘˜.Jš
œ˜Jšœžœ˜Jšœžœ˜Jšžœžœ
žœ
žœ˜+Jš
œ4˜4Jš
œS˜Sšžœžœ
žœž˜#Jš
œY˜YJšžœ
˜—šœ	žœžœ
˜Jšžœ˜šžœ˜Jš
œ˜Jšœ6žœ
˜<Jš
œ˜——Jš
œ/˜/J˜J˜—š œžœRžœžœ˜Œ
Jš
œ0˜0Jš
œ*˜*šžœžœ
žœžœ
˜$Jš
œS˜SJšžœ
˜—J˜J˜—š œžœ˜#Jšœžœžœ˜#Jšœžœ˜Jšœžœ"˜>Jšœžœ ˜8Jšœžœ
žœžœ
˜9J–> -- [key: RefTab.Key, val: RefTab.Val] RETURNS [quit: BOOLEAN]šœžœ˜š œ!˜2Jšœžœžœ‘+˜XJšœžœ.˜<Jš
œ#˜#Jš
œW˜WJšœ1žœ˜@Jšœžœ
˜!š
œ&˜&Jš
œR˜RJš
œ"˜"Jš
œ˜—Jšžœ>žœ
žœI˜”
šžœžœ
žœž˜'Jš
œ.˜.Jš
œ2˜2Jš
œA˜AJšžœ
˜—Jš
œA˜AJšœžœ˜5J˜—Jš œ4˜FJš
œ7˜7Jšœ™
žœ
˜ž
šœžœ˜+Jš
žœžœžœ
žœžœ˜A—Jš
œ/˜/šžœžœ
žœž˜'Jš
œ4˜4Jšžœ
˜—šžœžœ
žœž˜'Jš
œ6˜6Jšžœ
˜—JšœGžœžœ.žœ
˜₯
Jš
œΑ
™Α
Jš
œ6˜6Jš
œ7˜7Jš
œ˜J˜—šŸ
œžœ˜%Jšœžœ"žœžœ˜:Jšœ:žœžœžœ˜˜
Jš	žœžœ
žœ
žœ‘K˜rJšžœX˜^J˜J˜—š œžœžœžœžœžœ˜JJšžœžœ
žœ
žœ	˜!Jšžœžœ
žœ
žœ	˜!Jšžœžœ
žœ	˜0Jšžœ=˜CJ˜J˜—š œžœžœžœžœžœ˜^Jšœ	žœ˜&Jšœžœ5˜BšžœžœžœD˜]Jšžœžœ
žœ,žœ
˜F—šžœžœžœ?˜XJšžœžœ
žœ,žœ
˜F—Jš
œ˜J˜—šŸœžœ˜#J˜Jšžœžœžœžœžœžœžœžœžœžœžœžœžœ
žœžœ˜Α
Jš
œE˜EJšœ,žœ
˜:J˜Jš
œ˜J˜—šŸ
œžœ˜"J˜Jšœ
žœA˜MJšœ	žœ'˜4Jšžœ
žœ:žœ
žœ
˜XJš
œ)˜)Jšœ,žœ;˜kJ˜Jš
œ˜J˜—š 
œžœ˜%J˜Jš
œE˜EJšœ,žœ
˜:J˜Jš
œ˜J˜—šŸœžœžœ˜1J˜—š œ$˜5Kšœžœ	˜&Kšœžœ
žœžœ	˜"šžœžœ
žœž˜!Kš
œG˜GKšžœ%žœ˜JKšžœžœ
žœ
˜Kšžœ
˜—K˜K˜—š œ$˜9Kšœžœ	˜&šžœžœ
žœž˜!Kš
œ:˜:Kšžœžœ
žœ
˜Kšžœ
˜—K˜K˜—š œ˜Kš
œ˜Kšœ%žœ˜;Kšœ	žœ
žœžœ
˜Jšœ<žœžœžœ˜‘
šžœžœ
žœž˜$Kš
œ"˜"Kšœžœžœ:˜MKš
œ,˜,Kš
œQ˜QKšœIžœžœ˜eKšœ
žœ˜Kšžœ
˜—Jš
œ™š
œ(˜(Jš
œ%˜%Jš
œ&˜&Jšœžœ
˜Jš
œ˜J˜—Jš
œ7˜7J˜K˜——™Jš
 œžœ
žœžœžœ˜VJš 
œžœ
žœžœžœžœžœžœžœžœžœ˜˜
Jš œžœ
žœžœžœžœžœžœžœžœžœ˜š
š œžœ
žœžœžœžœžœžœžœžœ˜‘
š	žœžœ!žœžœ
ž˜:JšžœBžœ
žœžœ˜XJšžœ
˜—š	žœžœ!žœžœ
ž˜:JšžœBžœ
žœžœ˜XJšžœ
˜—Jšžœžœ˜Jš
œ˜J˜—Jšœžœ
žœ,˜G—™Jš
œ/˜/Jš
œ/˜/Jš
œ3˜3Jš
œ/˜/Jš
œ-˜-Jš
œ3˜3Jš
œ/˜/Jš
œ5˜5K˜Kšžœ
˜K˜——…—„―Β