--routeUtilities.mesa

DIRECTORY  ZoneAllocDefs, RouteDefs, IODefs;

RouteUtilities:PROGRAM IMPORTS ZoneAllocDefs, IODefs EXPORTS RouteDefs=BEGIN
OPEN RouteDefs;


Error:SIGNAL=CODE;

channels:PUBLIC RectangleListPtr_NIL;
problem:PUBLIC Problem_[cells:NIL,chipSize:[0,0],wirelist:NIL];
example:PUBLIC INTEGER_1;
chipmonk,plot,print:PUBLIC BOOLEAN;
inters:PUBLIC RectangleListPtr_NIL;
topology:PUBLIC TopologyListPtr_NIL;
paths:PUBLIC PathwayListPtr_NIL;
layout:PUBLIC SiliconListPtr_NIL;
rectangles:PUBLIC RectangleListPtr_NIL;

EnumerateChannels:PUBLIC PROCEDURE[c:PROCEDURE[RectanglePtr]]=
{FOR l:RectangleListPtr_channels,l.t UNTIL l=NIL DO c[l.h]; ENDLOOP};

EnumerateInters:PUBLIC PROCEDURE[c:PROCEDURE[RectanglePtr]]=
{FOR l:RectangleListPtr_inters,l.t UNTIL l=NIL DO c[l.h]; ENDLOOP};

EnumerateRectangles:PUBLIC PROCEDURE[c:PROCEDURE[RectanglePtr]]=
{FOR l:RectangleListPtr_rectangles,l.t UNTIL l=NIL DO c[l.h]; ENDLOOP};

EnumerateCells:PUBLIC PROCEDURE[call:PROCEDURE[CellPtr]]=
{FOR l:CellListPtr_problem.cells,l.t UNTIL l=NIL DO call[l.h]; ENDLOOP};

EnumerateAllSignals:PUBLIC PROCEDURE[call:PROCEDURE[CellPtr,SignalPtr]]=BEGIN
FOR l:CellListPtr_problem.cells,l.t UNTIL l=NIL DO
  FOR l2:SignalListPtr_l.h.signals,l2.t UNTIL l2=NIL
   DO call[l.h,l2.h]; ENDLOOP; ENDLOOP;
END;

EnumerateSignals:PUBLIC PROCEDURE[c:CellPtr,x:PROCEDURE[CellPtr,SignalPtr]]=
  {FOR l:SignalListPtr_c.signals,l.t UNTIL l=NIL DO x[c,l.h]; ENDLOOP};

EnumerateConns:PUBLIC PROCEDURE[r:RectanglePtr,
      c:PROCEDURE[RectanglePtr,ConnPtr]]=
{FOR l:ConnListPtr_r.conns, l.t UNTIL l=NIL DO c[r,l.h]; ENDLOOP};

EnumerateEvents:PUBLIC PROCEDURE[r:RectanglePtr,
    c:PROCEDURE[RectanglePtr,EventPtr]]=
{FOR l:EventListPtr_r.events, l.t UNTIL l=NIL DO c[r,l.h]; ENDLOOP};

EnumerateRuns:PUBLIC PROCEDURE[r:RectanglePtr,
    c:PROCEDURE[RectanglePtr,RunPtr]]=
{FOR l:RunListPtr_r.runs,l.t UNTIL l=NIL DO c[r,l.h]; ENDLOOP};

EnumerateAllRuns:PUBLIC PROCEDURE[c:PROCEDURE[RectanglePtr,RunPtr]]=BEGIN
  temp:PROCEDURE[r:RectanglePtr]={EnumerateRuns[r,c]};
  EnumerateChannels[temp];
  END;

EnumerateAllConns:PUBLIC PROCEDURE[call:PROCEDURE[RectanglePtr,ConnPtr]]=BEGIN
Cm1:PROCEDURE[rect:RectanglePtr]={EnumerateConns[rect,call]};
EnumerateChannels[Cm1];
END;

EnumerateSilicon:PUBLIC PROCEDURE[call:PROCEDURE[SiliconPtr]]=BEGIN
FOR l:SiliconListPtr_layout,l.t UNTIL l=NIL
  DO IF l.h.pos#outOfSight THEN call[l.h]; ENDLOOP;
END;

Return:PUBLIC PROCEDURE={ShowChar['
]};

ShowString:PUBLIC PROCEDURE[s:STRING]=BEGIN
IF ~chipmonk THEN IODefs.WriteString[s];
END;

ShowChar:PUBLIC PROCEDURE[c:CHARACTER]=BEGIN
IF ~chipmonk THEN IODefs.WriteChar[c];
END;


ShowLabel:PUBLIC PROCEDURE[s:STRING]=BEGIN
Return[]; Return[]; ShowString[s]; Return[];
END;

ShowCircuit:PUBLIC PROCEDURE[c:Circuit] RETURNS[CHARACTER]=BEGIN
s:INTEGER=c-1;
RETURN[SELECT c FROM
  0=>'0, IN [1..26)=>'A + s, ENDCASE=>'2];
END;

ShowDecimal:PUBLIC PROCEDURE[i:INTEGER,s:STRING_NIL]=BEGIN
IF chipmonk THEN RETURN;
IF s#NIL THEN IODefs.WriteString[s];
IODefs.WriteDecimal[i];
END;

SameString:PUBLIC PROCEDURE[a,b:STRING] RETURNS[BOOLEAN]=BEGIN
IF a.length#b.length THEN RETURN[FALSE];
FOR i:CARDINAL IN [0..a.length)
  DO IF a[i]#b[i] THEN RETURN[FALSE]; ENDLOOP;
RETURN[TRUE];
END;

Clear:PUBLIC PROCEDURE[s:STRING]=BEGIN
FOR i:CARDINAL IN [0..s.length_s.maxlength) DO s[i]_' ; ENDLOOP;
END;

ShowPoint:PUBLIC PROCEDURE[s:STRING,x,y:INTEGER]=BEGIN OPEN IODefs;
IF chipmonk THEN RETURN;
WriteString[s];
WriteChar['[];
WriteDecimal[x];
WriteString[" , "];
WriteDecimal[y];
WriteChar[']];
END;

ShowWire:PUBLIC PROCEDURE[s:SiliconPtr]=BEGIN
ShowString[SELECT s.level FROM
    red=>" red ", blue=>" blue", ENDCASE=>" both"];
ShowPoint[" loc ",s.pos.x,s.pos.y];
ShowPoint["  ",s.pos2.x,s.pos2.y];
END;

WritePoint:PUBLIC PROCEDURE[x,y:INTEGER]=BEGIN OPEN IODefs;
IF chipmonk THEN RETURN;
WriteChar['[];
WriteDecimal[x];
WriteString[" , "];
WriteDecimal[y];
WriteChar[']];
END;

MakeType:PUBLIC PROCEDURE[n,e,s,w:BOOLEAN] RETURNS[InterType]=BEGIN
RETURN[(IF n THEN 1 ELSE 0)+(IF e THEN 4 ELSE 0)
 +(IF s THEN 2 ELSE 0)+(IF w THEN 8 ELSE 0)];
END;

-- ALLOCATIONS

ListEntry:TYPE=RECORD[a:LONG POINTER,b:LONG POINTER TO ListEntry];

zone:UNCOUNTED ZONE;

ReturnStorage:PUBLIC PROCEDURE=
  {zone_ZoneAllocDefs.DestroyAnXMZone[zone]};

InitStorage:PUBLIC PROCEDURE=
  {zone_ZoneAllocDefs.GetAnXMZone[]};

cntList:INTEGER_4000;
AllocateList:PUBLIC PROCEDURE RETURNS[LONG POINTER]=BEGIN
  x:LONG POINTER TO ListEntry_zone.NEW[ListEntry];
  IF (cntList_cntList-1)<0 THEN Error;
  x^_[NIL,NIL];
  RETURN[x];
  END;
FreeList:PUBLIC PROCEDURE[y:LONG POINTER]=
 {x:LONG POINTER TO ListEntry_y;
 zone.FREE[@x]; cntEvent_cntEvent+1};

cntEvent:INTEGER_500;
AllocateEvent:PUBLIC PROCEDURE RETURNS[x:EventPtr]=
 {x_zone.NEW[Event_[]]; IF (cntEvent_cntEvent-1)<0 THEN Error};
FreeEvent:PUBLIC PROCEDURE[x:EventPtr]=
 {zone.FREE[@x]; cntEvent_cntEvent+1};

cntNet:INTEGER_600;
AllocateNet:PUBLIC PROCEDURE RETURNS[x:NetPtr]=
 {x_zone.NEW[Net_[]]; IF (cntNet_cntNet-1)<0 THEN Error};
FreeNet:PUBLIC PROCEDURE[x:NetPtr]=
 {zone.FREE[@x]; cntNet_cntNet+1};

cntPathway:INTEGER_300;
AllocatePathway:PUBLIC PROCEDURE RETURNS[x:PathwayPtr]=
 {x_zone.NEW[Pathway_[]]; IF (cntPathway_cntPathway-1)<0 THEN Error};
FreePathway:PUBLIC PROCEDURE[x:PathwayPtr]=
 {zone.FREE[@x]; cntPathway_cntPathway+1};

cntJunction:INTEGER_300;
AllocateJunction:PUBLIC PROCEDURE RETURNS[x:JunctionPtr]=
 {x_zone.NEW[Junction_[]]; IF (cntJunction_cntJunction-1)<0 THEN Error};
FreeJunction:PUBLIC PROCEDURE[x:JunctionPtr]=
 {zone.FREE[@x]; cntJunction_cntJunction+1};

cntCell:INTEGER_125;
AllocateCell:PUBLIC PROCEDURE RETURNS[x:CellPtr]=
 {x_zone.NEW[Cell_[]]; IF (cntCell_cntCell-1)<0 THEN Error};
FreeCell:PUBLIC PROCEDURE[x:CellPtr]=
 {zone.FREE[@x]; cntCell_cntCell+1};

cntSignal:INTEGER_1000;
AllocateSignal:PUBLIC PROCEDURE RETURNS[x:SignalPtr]=
 {x_zone.NEW[Signal_[]]; IF (cntSignal_cntSignal-1)<0 THEN Error};
FreeSignal:PUBLIC PROCEDURE[x:SignalPtr]=
 {zone.FREE[@x]; cntSignal_cntSignal+1};

cntSilicon:INTEGER_4000;
AllocateSilicon:PUBLIC PROCEDURE RETURNS[x:SiliconPtr]=
 {x_zone.NEW[Silicon_[]]; IF (cntSilicon_cntSilicon-1)<0 THEN Error};
FreeSilicon:PUBLIC PROCEDURE[x:SiliconPtr]=
 {zone.FREE[@x]; cntSilicon_cntSilicon+1};

cntPath:INTEGER_1000;
AllocatePath:PUBLIC PROCEDURE RETURNS[x:PathPtr]=
 {x_zone.NEW[Path_[]]; IF (cntPath_cntPath-1)<0 THEN Error};
FreePath:PUBLIC PROCEDURE[x:PathPtr]=
 {zone.FREE[@x]; cntPath_cntPath+1};

cntRectangle:INTEGER_400;
AllocateRectangle:PUBLIC PROCEDURE RETURNS[x:RectanglePtr]=
 {x_zone.NEW[Rectangle_[]]; IF (cntRectangle_cntRectangle-1)<0 THEN Error};
FreeRectangle:PUBLIC PROCEDURE[x:RectanglePtr]=
 {zone.FREE[@x]; cntRectangle_cntRectangle+1};

cntPlace:INTEGER_400;
AllocatePlace:PUBLIC PROCEDURE RETURNS[x:PlacePtr]=
 {x_zone.NEW[Place_[]]; IF (cntPlace_cntPlace-1)<0 THEN Error};
FreePlace:PUBLIC PROCEDURE[x:PlacePtr]=
 {zone.FREE[@x]; cntPlace_cntPlace+1};

cntGrid:INTEGER_300;
AllocateGrid:PUBLIC PROCEDURE RETURNS[x:GridPtr]=
 {x_zone.NEW[Grid_[]]; IF (cntGrid_cntGrid-1)<0 THEN Error};
FreeGrid:PUBLIC PROCEDURE[x:GridPtr]=
 {zone.FREE[@x]; cntGrid_cntGrid+1};

cntTopology:INTEGER_500;
AllocateTopology:PUBLIC PROCEDURE RETURNS[x:TopologyPtr]=
 {x_zone.NEW[Topology_[]]; IF (cntTopology_cntTopology-1)<0 THEN Error};
FreeTopology:PUBLIC PROCEDURE[x:TopologyPtr]=
 {zone.FREE[@x]; cntTopology_cntTopology+1};

cntConn:INTEGER_500;
AllocateConn:PUBLIC PROCEDURE RETURNS[x:ConnPtr]=
 {x_zone.NEW[Conn_[]]; IF (cntConn_cntConn-1)<0 THEN Error};
FreeConn:PUBLIC PROCEDURE[x:ConnPtr]=
 {zone.FREE[@x]; cntConn_cntConn+1};

cntRun:INTEGER_500;
AllocateRun:PUBLIC PROCEDURE RETURNS[x:RunPtr]=
 {x_zone.NEW[Run_[]]; IF (cntRun_cntRun-1)<0 THEN Error};
FreeRun:PUBLIC PROCEDURE[x:RunPtr]=
 {zone.FREE[@x]; cntRun_cntRun+1};

cntIWire:INTEGER_1000;
AllocateIWire:PUBLIC PROCEDURE RETURNS[x:IWirePtr]=
 {x_zone.NEW[IWire_[]]; IF (cntIWire_cntIWire-1)<0 THEN Error};
FreeIWire:PUBLIC PROCEDURE[x:IWirePtr]=
 {zone.FREE[@x]; cntIWire_cntIWire+1};

END.

AllocateList:PUBLIC PROCEDURE RETURNS[LONG POINTER]=BEGIN
ans:LONG POINTER TO ListEntry_freeList;
freeList_ans.b;
ans^_[NIL,NIL];
RETURN[ans];
END;

FreeList:PUBLIC PROCEDURE[x:POINTER]=BEGIN
ans:POINTER TO ListEntry=x;
ans^_[NIL,freeList];
freeList_ans;
END;