-- RouteChannelIO.mesa
-- Written by IOProcsGen March 17, 1988 6:44:33 pm PST
DIRECTORY
RoutePrivate USING [RoutingAreaParms, NetRec, RoutingLayer, Net, RoutingAreaParmsRec],
RouteChannel USING [TrackRec, ChanTBSide, ChanParms, InternPin, RoutingChannelPins, ChanSide, ChanPinRec, ChannelDataRec, RoutingChannelSidesRec, InternPinRec, ChanPin, ChanPinList, RoutingChannelSides, RoutingChannelTracksRec, PinPosition, RoutingChannelTracks, SegmentRec, Segment, ChannelData, InternPinList, MPinsOnCh, MaxTracks, ChanParmsRec, Track, ChanLRSide, PinPositionRec, RoutingChannelPinsRec],
RTBasic USING [PQRect, PQRectList],
RouteDiGraph USING [Node, GraphRec, ArcList, NodeRec, Graph],
Rope USING [ROPE],
Route USING [DesignRulesRec, ResultDataRec, DesignRules, PinRec, Pin, ResultData, PinList],
IO,
RefIOPrivate USING [RegisterTypeProcs, NameToRefProc, RefToNameProc, Error],
SafeStorage USING [GetReferentType, Type];

RouteChannelIO: CEDAR PROGRAM
IMPORTS IO, RefIOPrivate, SafeStorage
~ BEGIN

ROPE: TYPE ~ Rope.ROPE;


Init: PROC ~{
elPQRect: RTBasic.PQRect;
vPQRectList: RTBasic.PQRectList _ LIST [elPQRect];
elT2581: REF ANY;
vArcList: RouteDiGraph.ArcList _ LIST [elT2581];
elPin: Route.Pin;
vPinList: Route.PinList _ LIST [elPin];
elChanPin: RouteChannel.ChanPin;
vChanPinList: RouteChannel.ChanPinList _ LIST [elChanPin];
elInternPin: RouteChannel.InternPin;
vInternPinList: RouteChannel.InternPinList _ LIST [elInternPin];
elROPE: ROPE;
vT2486: LIST OF ROPE _ LIST [elROPE];
type: SafeStorage.Type;
type _ CODE[Route.ResultDataRec];
RefIOPrivate.RegisterTypeProcs[type, " 51688 21688 24843 48577", ReadResultData, WriteResultData];
type _ SafeStorage.GetReferentType[vT2486];
RefIOPrivate.RegisterTypeProcs[type, " 32927 22523 58564 33033", ReadT2486, WriteT2486];
type _ SafeStorage.GetReferentType[vInternPinList];
RefIOPrivate.RegisterTypeProcs[type, " 3892 1107 49791 29566", ReadInternPinList, WriteInternPinList];
type _ CODE[RouteChannel.InternPinRec];
RefIOPrivate.RegisterTypeProcs[type, " 17834 29454 62958 38739", ReadInternPin, WriteInternPin];
type _ CODE[Route.PinRec];
RefIOPrivate.RegisterTypeProcs[type, " 53024 27553 24843 49913", ReadPin, WritePin];
type _ CODE[Route.DesignRulesRec];
RefIOPrivate.RegisterTypeProcs[type, " 49110 26708 24843 45999", ReadDesignRules, WriteDesignRules];
type _ CODE[RoutePrivate.RoutingAreaParmsRec];
RefIOPrivate.RegisterTypeProcs[type, " 61692 58598 41274 43664", ReadRoutingAreaParms, WriteRoutingAreaParms];
type _ CODE[RouteChannel.ChannelDataRec];
RefIOPrivate.RegisterTypeProcs[type, " 25885 43716 62958 46790", ReadChannelData, WriteChannelData];
type _ CODE[RouteChannel.ChanParmsRec];
RefIOPrivate.RegisterTypeProcs[type, " 21645 31952 62958 42550", ReadChanParms, WriteChanParms];
type _ CODE[RouteChannel.RoutingChannelPinsRec];
RefIOPrivate.RegisterTypeProcs[type, " 8310 29774 62958 29215", ReadRoutingChannelPins, WriteRoutingChannelPins];
type _ CODE[RouteChannel.PinPositionRec];
RefIOPrivate.RegisterTypeProcs[type, " 15784 17812 62958 36689", ReadPinPosition, WritePinPosition];
type _ SafeStorage.GetReferentType[vChanPinList];
RefIOPrivate.RegisterTypeProcs[type, " 1859 42197 49687 21052", ReadChanPinList, WriteChanPinList];
type _ CODE[RouteChannel.ChanPinRec];
RefIOPrivate.RegisterTypeProcs[type, " 8391 39453 62958 29296", ReadChanPin, WriteChanPin];
type _ CODE[RouteChannel.SegmentRec];
RefIOPrivate.RegisterTypeProcs[type, " 65055 48011 62958 20424", ReadSegment, WriteSegment];
type _ CODE[RoutePrivate.NetRec];
RefIOPrivate.RegisterTypeProcs[type, " 65525 34657 41274 47497", ReadNet, WriteNet];
type _ SafeStorage.GetReferentType[vPinList];
RefIOPrivate.RegisterTypeProcs[type, " 3797 27719 54562 13336", ReadPinList, WritePinList];
type _ CODE[RouteDiGraph.NodeRec];
RefIOPrivate.RegisterTypeProcs[type, " 50156 63500 53198 15889", ReadNode, WriteNode];
type _ SafeStorage.GetReferentType[vArcList];
RefIOPrivate.RegisterTypeProcs[type, " 2436 54738 32260 56644", ReadArcList, WriteArcList];
type _ CODE[RouteChannel.RoutingChannelTracksRec];
RefIOPrivate.RegisterTypeProcs[type, " 20180 27999 62958 41085", ReadRoutingChannelTracks, WriteRoutingChannelTracks];
type _ CODE[RouteChannel.TrackRec];
RefIOPrivate.RegisterTypeProcs[type, " 2118 62936 62958 23023", ReadTrack, WriteTrack];
type _ CODE[RouteChannel.RoutingChannelSidesRec];
RefIOPrivate.RegisterTypeProcs[type, " 21198 35447 62958 42103", ReadRoutingChannelSides, WriteRoutingChannelSides];
type _ SafeStorage.GetReferentType[vPQRectList];
RefIOPrivate.RegisterTypeProcs[type, " 27157 7959 21062 39753", ReadPQRectList, WritePQRectList];
type _ CODE[RouteDiGraph.GraphRec];
RefIOPrivate.RegisterTypeProcs[type, " 56018 12104 53198 21750", ReadGraph, WriteGraph];
};

ReadResultData: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
vResultData: Route.ResultData _ NEW[Route.ResultDataRec];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
vResultData.polyLength _ IO.GetInt[s];
vResultData.metalLength _ IO.GetInt[s];
vResultData.metal2Length _ IO.GetInt[s];
vResultData.polyToMetal _ IO.GetInt[s];
vResultData.metalToMetal2 _ IO.GetInt[s];
vResultData.numTrunkTracks _ IO.GetInt[s];
vResultData.numIncompletes _ IO.GetInt[s];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
vResultData.routingRect.x1 _ IO.GetInt[s];
vResultData.routingRect.y1 _ IO.GetInt[s];
vResultData.routingRect.x2 _ IO.GetInt[s];
vResultData.routingRect.y2 _ IO.GetInt[s];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
{c: [0..2) _ IO.GetCard[s]-1;vResultData.moreAreaRequired _ VAL[c]};
TRUSTED {vResultData.incompleteNets _ NARROW[eachNameProc[vResultData , @vResultData.incompleteNets]]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vResultData];
};

WriteResultData: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vResultData: Route.ResultData _ NARROW[ref];
IO.PutChar[s, '[ ];
IO.PutF[s, "%d ", IO.int[vResultData.polyLength]];
IO.PutF[s, "%d ", IO.int[vResultData.metalLength]];
IO.PutF[s, "%d ", IO.int[vResultData.metal2Length]];
IO.PutF[s, "%d ", IO.int[vResultData.polyToMetal]];
IO.PutF[s, "%d ", IO.int[vResultData.metalToMetal2]];
IO.PutF[s, "%d ", IO.int[vResultData.numTrunkTracks]];
IO.PutF[s, "%d ", IO.int[vResultData.numIncompletes]];
IO.PutChar[s, '[ ];
IO.PutF[s, "%d ", IO.int[vResultData.routingRect.x1]];
IO.PutF[s, "%d ", IO.int[vResultData.routingRect.y1]];
IO.PutF[s, "%d ", IO.int[vResultData.routingRect.x2]];
IO.PutF[s, "%d ", IO.int[vResultData.routingRect.y2]];
IO.PutChar[s, '] ];
IO.PutF[s, "%d ", IO.card[ORD[vResultData.moreAreaRequired]+1]];
eachRefProc[vResultData.incompleteNets];
IO.PutChar[s, '] ];
};

ReadT2486: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
elROPE: ROPE;
vT2486: LIST OF ROPE _ LIST [elROPE];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
TRUSTED {vT2486.first _ NARROW[eachNameProc[vT2486 , @vT2486.first]]};
TRUSTED {vT2486.rest _ NARROW[eachNameProc[vT2486 , @vT2486.rest]]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vT2486];
};

WriteT2486: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vT2486: LIST OF ROPE _ NARROW[ref];
IO.PutChar[s, '[ ];
eachRefProc[vT2486.first];
eachRefProc[vT2486.rest];
IO.PutChar[s, '] ];
};

ReadInternPinList: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
elInternPin: RouteChannel.InternPin;
vInternPinList: RouteChannel.InternPinList _ LIST [elInternPin];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
TRUSTED {vInternPinList.first _ NARROW[eachNameProc[vInternPinList , @vInternPinList.first]]};
TRUSTED {vInternPinList.rest _ NARROW[eachNameProc[vInternPinList , @vInternPinList.rest]]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vInternPinList];
};

WriteInternPinList: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vInternPinList: RouteChannel.InternPinList _ NARROW[ref];
IO.PutChar[s, '[ ];
eachRefProc[vInternPinList.first];
eachRefProc[vInternPinList.rest];
IO.PutChar[s, '] ];
};

ReadInternPin: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
vInternPin: RouteChannel.InternPin _ NEW[RouteChannel.InternPinRec];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
TRUSTED {vInternPin.name _ NARROW[eachNameProc[vInternPin , @vInternPin.name]]};
{c: [0..5) _ IO.GetCard[s]-1;vInternPin.chanSide _ VAL[c]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
vInternPin.location.p _ IO.GetInt[s];
vInternPin.location.q _ IO.GetInt[s];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
vInternPin.pWidth _ IO.GetInt[s];
{c: [0..3) _ IO.GetCard[s]-1;vInternPin.layer _ VAL[c]};
TRUSTED {vInternPin.pin _ NARROW[eachNameProc[vInternPin , @vInternPin.pin]]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vInternPin];
};

WriteInternPin: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vInternPin: RouteChannel.InternPin _ NARROW[ref];
IO.PutChar[s, '[ ];
eachRefProc[vInternPin.name];
IO.PutF[s, "%d ", IO.card[ORD[vInternPin.chanSide]+1]];
IO.PutChar[s, '[ ];
IO.PutF[s, "%d ", IO.int[vInternPin.location.p]];
IO.PutF[s, "%d ", IO.int[vInternPin.location.q]];
IO.PutChar[s, '] ];
IO.PutF[s, "%d ", IO.int[vInternPin.pWidth]];
IO.PutF[s, "%d ", IO.card[ORD[vInternPin.layer]+1]];
eachRefProc[vInternPin.pin];
IO.PutChar[s, '] ];
};

ReadPin: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
vPin: Route.Pin _ NEW[Route.PinRec];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
vPin.min _ IO.GetInt[s];
vPin.max _ IO.GetInt[s];
vPin.depth _ IO.GetInt[s];
vPin.layer _ IO.GetInt[s];
{c: [0..5) _ IO.GetCard[s]-1;vPin.side _ VAL[c]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vPin];
};

WritePin: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vPin: Route.Pin _ NARROW[ref];
IO.PutChar[s, '[ ];
IO.PutF[s, "%d ", IO.int[vPin.min]];
IO.PutF[s, "%d ", IO.int[vPin.max]];
IO.PutF[s, "%d ", IO.int[vPin.depth]];
IO.PutF[s, "%d ", IO.int[vPin.layer]];
IO.PutF[s, "%d ", IO.card[ORD[vPin.side]+1]];
IO.PutChar[s, '] ];
};

ReadDesignRules: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
vDesignRules: Route.DesignRules _ NEW[Route.DesignRulesRec];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
vDesignRules.trunkLayer _ IO.GetInt[s];
vDesignRules.branchLayer _ IO.GetInt[s];
{c: [0..2) _ IO.GetCard[s]-1;vDesignRules.trunkDirection _ VAL[c]};
{c: [0..2) _ IO.GetCard[s]-1;vDesignRules.branchDirection _ VAL[c]};
vDesignRules.trunkWidth _ IO.GetInt[s];
vDesignRules.trunkSpacing _ IO.GetInt[s];
vDesignRules.trunkToContact _ IO.GetInt[s];
vDesignRules.trunkToTrunk _ IO.GetInt[s];
vDesignRules.trunkOffset _ IO.GetInt[s];
vDesignRules.branchWidth _ IO.GetInt[s];
vDesignRules.branchSpacing _ IO.GetInt[s];
vDesignRules.branchToContact _ IO.GetInt[s];
vDesignRules.branchToBranch _ IO.GetInt[s];
vDesignRules.branchOffset _ IO.GetInt[s];
vDesignRules.contactSize _ IO.GetInt[s];
vDesignRules.contactToContact _ IO.GetInt[s];
vDesignRules.pinSpacing _ IO.GetInt[s];
vDesignRules.trunkToEdge _ IO.GetInt[s];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vDesignRules];
};

WriteDesignRules: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vDesignRules: Route.DesignRules _ NARROW[ref];
IO.PutChar[s, '[ ];
IO.PutF[s, "%d ", IO.int[vDesignRules.trunkLayer]];
IO.PutF[s, "%d ", IO.int[vDesignRules.branchLayer]];
IO.PutF[s, "%d ", IO.card[ORD[vDesignRules.trunkDirection]+1]];
IO.PutF[s, "%d ", IO.card[ORD[vDesignRules.branchDirection]+1]];
IO.PutF[s, "%d ", IO.int[vDesignRules.trunkWidth]];
IO.PutF[s, "%d ", IO.int[vDesignRules.trunkSpacing]];
IO.PutF[s, "%d ", IO.int[vDesignRules.trunkToContact]];
IO.PutF[s, "%d ", IO.int[vDesignRules.trunkToTrunk]];
IO.PutF[s, "%d ", IO.int[vDesignRules.trunkOffset]];
IO.PutF[s, "%d ", IO.int[vDesignRules.branchWidth]];
IO.PutF[s, "%d ", IO.int[vDesignRules.branchSpacing]];
IO.PutF[s, "%d ", IO.int[vDesignRules.branchToContact]];
IO.PutF[s, "%d ", IO.int[vDesignRules.branchToBranch]];
IO.PutF[s, "%d ", IO.int[vDesignRules.branchOffset]];
IO.PutF[s, "%d ", IO.int[vDesignRules.contactSize]];
IO.PutF[s, "%d ", IO.int[vDesignRules.contactToContact]];
IO.PutF[s, "%d ", IO.int[vDesignRules.pinSpacing]];
IO.PutF[s, "%d ", IO.int[vDesignRules.trunkToEdge]];
IO.PutChar[s, '] ];
};

ReadRoutingAreaParms: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
vRoutingAreaParms: RoutePrivate.RoutingAreaParms _ NEW[RoutePrivate.RoutingAreaParmsRec];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
{c: [0..3) _ IO.GetCard[s]-1;vRoutingAreaParms.routerUsed _ VAL[c]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
vRoutingAreaParms.routingRect.x1 _ IO.GetInt[s];
vRoutingAreaParms.routingRect.y1 _ IO.GetInt[s];
vRoutingAreaParms.routingRect.x2 _ IO.GetInt[s];
vRoutingAreaParms.routingRect.y2 _ IO.GetInt[s];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
vRoutingAreaParms.widestPin _ IO.GetInt[s];
vRoutingAreaParms.widestTrunk _ IO.GetInt[s];
vRoutingAreaParms.widestBranch _ IO.GetInt[s];
vRoutingAreaParms.numTracksToUse _ IO.GetInt[s];
vRoutingAreaParms.lambda _ IO.GetInt[s];
vRoutingAreaParms.metalLayer _ IO.GetInt[s];
vRoutingAreaParms.metal2Layer _ IO.GetInt[s];
vRoutingAreaParms.polyLayer _ IO.GetInt[s];
TRUSTED {vRoutingAreaParms.viaTable _ NARROW[eachNameProc[vRoutingAreaParms , @vRoutingAreaParms.viaTable]]};
TRUSTED {vRoutingAreaParms.entityTable _ NARROW[eachNameProc[vRoutingAreaParms , @vRoutingAreaParms.entityTable]]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vRoutingAreaParms];
};

WriteRoutingAreaParms: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vRoutingAreaParms: RoutePrivate.RoutingAreaParms _ NARROW[ref];
IO.PutChar[s, '[ ];
IO.PutF[s, "%d ", IO.card[ORD[vRoutingAreaParms.routerUsed]+1]];
IO.PutChar[s, '[ ];
IO.PutF[s, "%d ", IO.int[vRoutingAreaParms.routingRect.x1]];
IO.PutF[s, "%d ", IO.int[vRoutingAreaParms.routingRect.y1]];
IO.PutF[s, "%d ", IO.int[vRoutingAreaParms.routingRect.x2]];
IO.PutF[s, "%d ", IO.int[vRoutingAreaParms.routingRect.y2]];
IO.PutChar[s, '] ];
IO.PutF[s, "%d ", IO.int[vRoutingAreaParms.widestPin]];
IO.PutF[s, "%d ", IO.int[vRoutingAreaParms.widestTrunk]];
IO.PutF[s, "%d ", IO.int[vRoutingAreaParms.widestBranch]];
IO.PutF[s, "%d ", IO.int[vRoutingAreaParms.numTracksToUse]];
IO.PutF[s, "%d ", IO.int[vRoutingAreaParms.lambda]];
IO.PutF[s, "%d ", IO.int[vRoutingAreaParms.metalLayer]];
IO.PutF[s, "%d ", IO.int[vRoutingAreaParms.metal2Layer]];
IO.PutF[s, "%d ", IO.int[vRoutingAreaParms.polyLayer]];
eachRefProc[vRoutingAreaParms.viaTable];
eachRefProc[vRoutingAreaParms.entityTable];
IO.PutChar[s, '] ];
};

ReadChannelData: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
vChannelData: RouteChannel.ChannelData _ NEW[RouteChannel.ChannelDataRec];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
TRUSTED {vChannelData.constraints _ NARROW[eachNameProc[vChannelData , @vChannelData.constraints]]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'( THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '( expected at %d", IO.int[IO.GetIndex[s]]]];
FOR i: RouteChannel.ChanSide IN RouteChannel.ChanSide DO
TRUSTED {vChannelData.chanSides[i] _ NARROW[eachNameProc[vChannelData , @vChannelData.chanSides[i]]]};
ENDLOOP;
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#') THEN RefIOPrivate.Error[IO.PutFR["Syntax error: ') expected at %d", IO.int[IO.GetIndex[s]]]];
TRUSTED {vChannelData.chanTracks _ NARROW[eachNameProc[vChannelData , @vChannelData.chanTracks]]};
TRUSTED {vChannelData.chanPins _ NARROW[eachNameProc[vChannelData , @vChannelData.chanPins]]};
TRUSTED {vChannelData.chanParms _ NARROW[eachNameProc[vChannelData , @vChannelData.chanParms]]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vChannelData];
};

WriteChannelData: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vChannelData: RouteChannel.ChannelData _ NARROW[ref];
IO.PutChar[s, '[ ];
eachRefProc[vChannelData.constraints];
IO.PutChar[s, '( ];
FOR i: RouteChannel.ChanSide IN RouteChannel.ChanSide DO
eachRefProc[vChannelData.chanSides[i]];
ENDLOOP;
IO.PutChar[s, ') ];
eachRefProc[vChannelData.chanTracks];
eachRefProc[vChannelData.chanPins];
eachRefProc[vChannelData.chanParms];
IO.PutChar[s, '] ];
};

ReadChanParms: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
vChanParms: RouteChannel.ChanParms _ NEW[RouteChannel.ChanParmsRec];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
vChanParms.maxToConvert _ IO.GetInt[s];
vChanParms.emptyTrackLimit _ IO.GetInt[s];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vChanParms];
};

WriteChanParms: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vChanParms: RouteChannel.ChanParms _ NARROW[ref];
IO.PutChar[s, '[ ];
IO.PutF[s, "%d ", IO.int[vChanParms.maxToConvert]];
IO.PutF[s, "%d ", IO.int[vChanParms.emptyTrackLimit]];
IO.PutChar[s, '] ];
};

ReadRoutingChannelPins: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
vRoutingChannelPins: RouteChannel.RoutingChannelPins _ NEW[RouteChannel.RoutingChannelPinsRec];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
vRoutingChannelPins.cEnd1 _ IO.GetInt[s];
vRoutingChannelPins.cEnd2 _ IO.GetInt[s];
vRoutingChannelPins.count _ IO.GetInt[s];
vRoutingChannelPins.size _ IO.GetInt[s];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'( THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '( expected at %d", IO.int[IO.GetIndex[s]]]];
FOR i: RouteChannel.MPinsOnCh IN RouteChannel.MPinsOnCh DO
TRUSTED {vRoutingChannelPins.sides[i] _ NARROW[eachNameProc[vRoutingChannelPins , @vRoutingChannelPins.sides[i]]]};
ENDLOOP;
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#') THEN RefIOPrivate.Error[IO.PutFR["Syntax error: ') expected at %d", IO.int[IO.GetIndex[s]]]];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vRoutingChannelPins];
};

WriteRoutingChannelPins: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vRoutingChannelPins: RouteChannel.RoutingChannelPins _ NARROW[ref];
IO.PutChar[s, '[ ];
IO.PutF[s, "%d ", IO.int[vRoutingChannelPins.cEnd1]];
IO.PutF[s, "%d ", IO.int[vRoutingChannelPins.cEnd2]];
IO.PutF[s, "%d ", IO.int[vRoutingChannelPins.count]];
IO.PutF[s, "%d ", IO.int[vRoutingChannelPins.size]];
IO.PutChar[s, '( ];
FOR i: RouteChannel.MPinsOnCh IN RouteChannel.MPinsOnCh DO
eachRefProc[vRoutingChannelPins.sides[i]];
ENDLOOP;
IO.PutChar[s, ') ];
IO.PutChar[s, '] ];
};

ReadPinPosition: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
vPinPosition: RouteChannel.PinPosition _ NEW[RouteChannel.PinPositionRec];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
vPinPosition.pinIndex _ IO.GetInt[s];
vPinPosition.pLoc _ IO.GetInt[s];
{c: [0..2) _ IO.GetCard[s]-1;vPinPosition.blocked _ VAL[c]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'( THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '( expected at %d", IO.int[IO.GetIndex[s]]]];
FOR i: RouteChannel.ChanTBSide IN RouteChannel.ChanTBSide DO
TRUSTED {vPinPosition.pins[i] _ NARROW[eachNameProc[vPinPosition , @vPinPosition.pins[i]]]};
ENDLOOP;
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#') THEN RefIOPrivate.Error[IO.PutFR["Syntax error: ') expected at %d", IO.int[IO.GetIndex[s]]]];
TRUSTED {vPinPosition.innerPins _ NARROW[eachNameProc[vPinPosition , @vPinPosition.innerPins]]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vPinPosition];
};

WritePinPosition: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vPinPosition: RouteChannel.PinPosition _ NARROW[ref];
IO.PutChar[s, '[ ];
IO.PutF[s, "%d ", IO.int[vPinPosition.pinIndex]];
IO.PutF[s, "%d ", IO.int[vPinPosition.pLoc]];
IO.PutF[s, "%d ", IO.card[ORD[vPinPosition.blocked]+1]];
IO.PutChar[s, '( ];
FOR i: RouteChannel.ChanTBSide IN RouteChannel.ChanTBSide DO
eachRefProc[vPinPosition.pins[i]];
ENDLOOP;
IO.PutChar[s, ') ];
eachRefProc[vPinPosition.innerPins];
IO.PutChar[s, '] ];
};

ReadChanPinList: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
elChanPin: RouteChannel.ChanPin;
vChanPinList: RouteChannel.ChanPinList _ LIST [elChanPin];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
TRUSTED {vChanPinList.first _ NARROW[eachNameProc[vChanPinList , @vChanPinList.first]]};
TRUSTED {vChanPinList.rest _ NARROW[eachNameProc[vChanPinList , @vChanPinList.rest]]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vChanPinList];
};

WriteChanPinList: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vChanPinList: RouteChannel.ChanPinList _ NARROW[ref];
IO.PutChar[s, '[ ];
eachRefProc[vChanPinList.first];
eachRefProc[vChanPinList.rest];
IO.PutChar[s, '] ];
};

ReadChanPin: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
vChanPin: RouteChannel.ChanPin _ NEW[RouteChannel.ChanPinRec];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
{c: [0..5) _ IO.GetCard[s]-1;vChanPin.pinSide _ VAL[c]};
vChanPin.qLoc _ IO.GetInt[s];
vChanPin.pWidth _ IO.GetInt[s];
{c: [0..5) _ IO.GetCard[s]-1;vChanPin.kindOfPin _ VAL[c]};
TRUSTED {vChanPin.pinPosition _ NARROW[eachNameProc[vChanPin , @vChanPin.pinPosition]]};
vChanPin.trackConstraint _ IO.GetInt[s];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'( THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '( expected at %d", IO.int[IO.GetIndex[s]]]];
FOR i: RouteChannel.ChanLRSide IN RouteChannel.ChanLRSide DO
TRUSTED {vChanPin.conctSeg[i] _ NARROW[eachNameProc[vChanPin , @vChanPin.conctSeg[i]]]};
ENDLOOP;
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#') THEN RefIOPrivate.Error[IO.PutFR["Syntax error: ') expected at %d", IO.int[IO.GetIndex[s]]]];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'( THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '( expected at %d", IO.int[IO.GetIndex[s]]]];
FOR i: RouteChannel.ChanLRSide IN RouteChannel.ChanLRSide DO
TRUSTED {vChanPin.altConctSeg[i] _ NARROW[eachNameProc[vChanPin , @vChanPin.altConctSeg[i]]]};
ENDLOOP;
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#') THEN RefIOPrivate.Error[IO.PutFR["Syntax error: ') expected at %d", IO.int[IO.GetIndex[s]]]];
TRUSTED {vChanPin.pin _ NARROW[eachNameProc[vChanPin , @vChanPin.pin]]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vChanPin];
};

WriteChanPin: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vChanPin: RouteChannel.ChanPin _ NARROW[ref];
IO.PutChar[s, '[ ];
IO.PutF[s, "%d ", IO.card[ORD[vChanPin.pinSide]+1]];
IO.PutF[s, "%d ", IO.int[vChanPin.qLoc]];
IO.PutF[s, "%d ", IO.int[vChanPin.pWidth]];
IO.PutF[s, "%d ", IO.card[ORD[vChanPin.kindOfPin]+1]];
eachRefProc[vChanPin.pinPosition];
IO.PutF[s, "%d ", IO.int[vChanPin.trackConstraint]];
IO.PutChar[s, '( ];
FOR i: RouteChannel.ChanLRSide IN RouteChannel.ChanLRSide DO
eachRefProc[vChanPin.conctSeg[i]];
ENDLOOP;
IO.PutChar[s, ') ];
IO.PutChar[s, '( ];
FOR i: RouteChannel.ChanLRSide IN RouteChannel.ChanLRSide DO
eachRefProc[vChanPin.altConctSeg[i]];
ENDLOOP;
IO.PutChar[s, ') ];
eachRefProc[vChanPin.pin];
IO.PutChar[s, '] ];
};

ReadSegment: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
vSegment: RouteChannel.Segment _ NEW[RouteChannel.SegmentRec];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'( THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '( expected at %d", IO.int[IO.GetIndex[s]]]];
FOR i: RouteChannel.ChanLRSide IN RouteChannel.ChanLRSide DO
TRUSTED {vSegment.exteriorPins[i] _ NARROW[eachNameProc[vSegment , @vSegment.exteriorPins[i]]]};
ENDLOOP;
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#') THEN RefIOPrivate.Error[IO.PutFR["Syntax error: ') expected at %d", IO.int[IO.GetIndex[s]]]];
TRUSTED {vSegment.interiorPins _ NARROW[eachNameProc[vSegment , @vSegment.interiorPins]]};
{c: [0..3) _ IO.GetCard[s]-1;vSegment.routingLayer _ VAL[c]};
vSegment.qWidth _ IO.GetInt[s];
TRUSTED {vSegment.constraintNode _ NARROW[eachNameProc[vSegment , @vSegment.constraintNode]]};
vSegment.trackNum _ IO.GetInt[s];
vSegment.trackConstraint _ IO.GetInt[s];
vSegment.secTrackConstraint _ IO.GetInt[s];
TRUSTED {vSegment.nextSeg _ NARROW[eachNameProc[vSegment , @vSegment.nextSeg]]};
TRUSTED {vSegment.net _ NARROW[eachNameProc[vSegment , @vSegment.net]]};
vSegment.part _ IO.GetInt[s];
{c: [0..2) _ IO.GetCard[s]-1;vSegment.failed _ VAL[c]};
{c: [0..2) _ IO.GetCard[s]-1;vSegment.exitBreak _ VAL[c]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vSegment];
};

WriteSegment: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vSegment: RouteChannel.Segment _ NARROW[ref];
IO.PutChar[s, '[ ];
IO.PutChar[s, '( ];
FOR i: RouteChannel.ChanLRSide IN RouteChannel.ChanLRSide DO
eachRefProc[vSegment.exteriorPins[i]];
ENDLOOP;
IO.PutChar[s, ') ];
eachRefProc[vSegment.interiorPins];
IO.PutF[s, "%d ", IO.card[ORD[vSegment.routingLayer]+1]];
IO.PutF[s, "%d ", IO.int[vSegment.qWidth]];
eachRefProc[vSegment.constraintNode];
IO.PutF[s, "%d ", IO.int[vSegment.trackNum]];
IO.PutF[s, "%d ", IO.int[vSegment.trackConstraint]];
IO.PutF[s, "%d ", IO.int[vSegment.secTrackConstraint]];
eachRefProc[vSegment.nextSeg];
eachRefProc[vSegment.net];
IO.PutF[s, "%d ", IO.int[vSegment.part]];
IO.PutF[s, "%d ", IO.card[ORD[vSegment.failed]+1]];
IO.PutF[s, "%d ", IO.card[ORD[vSegment.exitBreak]+1]];
IO.PutChar[s, '] ];
};

ReadNet: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
vNet: RoutePrivate.Net _ NEW[RoutePrivate.NetRec];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
TRUSTED {vNet.name _ NARROW[eachNameProc[vNet , @vNet.name]]};
vNet.num _ IO.GetInt[s];
vNet.branchWidth _ IO.GetInt[s];
vNet.trunkWidth _ IO.GetInt[s];
TRUSTED {vNet.pinList _ NARROW[eachNameProc[vNet , @vNet.pinList]]};
TRUSTED {vNet.internPinList _ NARROW[eachNameProc[vNet , @vNet.internPinList]]};
TRUSTED {vNet.netData _ NARROW[eachNameProc[vNet , @vNet.netData]]};
{c: [0..2) _ IO.GetCard[s]-1;vNet.mayExit _ VAL[c]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vNet];
};

WriteNet: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vNet: RoutePrivate.Net _ NARROW[ref];
IO.PutChar[s, '[ ];
eachRefProc[vNet.name];
IO.PutF[s, "%d ", IO.int[vNet.num]];
IO.PutF[s, "%d ", IO.int[vNet.branchWidth]];
IO.PutF[s, "%d ", IO.int[vNet.trunkWidth]];
eachRefProc[vNet.pinList];
eachRefProc[vNet.internPinList];
eachRefProc[vNet.netData];
IO.PutF[s, "%d ", IO.card[ORD[vNet.mayExit]+1]];
IO.PutChar[s, '] ];
};

ReadPinList: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
elPin: Route.Pin;
vPinList: Route.PinList _ LIST [elPin];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
TRUSTED {vPinList.first _ NARROW[eachNameProc[vPinList , @vPinList.first]]};
TRUSTED {vPinList.rest _ NARROW[eachNameProc[vPinList , @vPinList.rest]]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vPinList];
};

WritePinList: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vPinList: Route.PinList _ NARROW[ref];
IO.PutChar[s, '[ ];
eachRefProc[vPinList.first];
eachRefProc[vPinList.rest];
IO.PutChar[s, '] ];
};

ReadNode: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
vNode: RouteDiGraph.Node _ NEW[RouteDiGraph.NodeRec];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
TRUSTED {vNode.nodeInfo _ NARROW[eachNameProc[vNode , @vNode.nodeInfo]]};
vNode.superiorParity _ IO.GetInt[s];
vNode.inferiorParity _ IO.GetInt[s];
TRUSTED {vNode.superiorArcs _ NARROW[eachNameProc[vNode , @vNode.superiorArcs]]};
TRUSTED {vNode.inferiorArcs _ NARROW[eachNameProc[vNode , @vNode.inferiorArcs]]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vNode];
};

WriteNode: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vNode: RouteDiGraph.Node _ NARROW[ref];
IO.PutChar[s, '[ ];
eachRefProc[vNode.nodeInfo];
IO.PutF[s, "%d ", IO.int[vNode.superiorParity]];
IO.PutF[s, "%d ", IO.int[vNode.inferiorParity]];
eachRefProc[vNode.superiorArcs];
eachRefProc[vNode.inferiorArcs];
IO.PutChar[s, '] ];
};

ReadArcList: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
elT2581: REF ANY;
vArcList: RouteDiGraph.ArcList _ LIST [elT2581];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
TRUSTED {vArcList.first _ NARROW[eachNameProc[vArcList , @vArcList.first]]};
TRUSTED {vArcList.rest _ NARROW[eachNameProc[vArcList , @vArcList.rest]]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vArcList];
};

WriteArcList: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vArcList: RouteDiGraph.ArcList _ NARROW[ref];
IO.PutChar[s, '[ ];
eachRefProc[vArcList.first];
eachRefProc[vArcList.rest];
IO.PutChar[s, '] ];
};

ReadRoutingChannelTracks: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
vRoutingChannelTracks: RouteChannel.RoutingChannelTracks _ NEW[RouteChannel.RoutingChannelTracksRec];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
vRoutingChannelTracks.count _ IO.GetInt[s];
vRoutingChannelTracks.maxCount _ IO.GetInt[s];
vRoutingChannelTracks.size _ IO.GetInt[s];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'( THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '( expected at %d", IO.int[IO.GetIndex[s]]]];
FOR i: RouteChannel.MaxTracks IN RouteChannel.MaxTracks DO
TRUSTED {vRoutingChannelTracks.tracks[i] _ NARROW[eachNameProc[vRoutingChannelTracks , @vRoutingChannelTracks.tracks[i]]]};
ENDLOOP;
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#') THEN RefIOPrivate.Error[IO.PutFR["Syntax error: ') expected at %d", IO.int[IO.GetIndex[s]]]];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vRoutingChannelTracks];
};

WriteRoutingChannelTracks: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vRoutingChannelTracks: RouteChannel.RoutingChannelTracks _ NARROW[ref];
IO.PutChar[s, '[ ];
IO.PutF[s, "%d ", IO.int[vRoutingChannelTracks.count]];
IO.PutF[s, "%d ", IO.int[vRoutingChannelTracks.maxCount]];
IO.PutF[s, "%d ", IO.int[vRoutingChannelTracks.size]];
IO.PutChar[s, '( ];
FOR i: RouteChannel.MaxTracks IN RouteChannel.MaxTracks DO
eachRefProc[vRoutingChannelTracks.tracks[i]];
ENDLOOP;
IO.PutChar[s, ') ];
IO.PutChar[s, '] ];
};

ReadTrack: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
vTrack: RouteChannel.Track _ NEW[RouteChannel.TrackRec];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
vTrack.oldTrackNum _ IO.GetInt[s];
vTrack.trackNum _ IO.GetInt[s];
vTrack.trackPos _ IO.GetInt[s];
vTrack.maxFeatureOnTrack _ IO.GetInt[s];
TRUSTED {vTrack.firstSeg _ NARROW[eachNameProc[vTrack , @vTrack.firstSeg]]};
{c: [0..2) _ IO.GetCard[s]-1;vTrack.blocked _ VAL[c]};
{c: [0..2) _ IO.GetCard[s]-1;vTrack.keep _ VAL[c]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vTrack];
};

WriteTrack: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vTrack: RouteChannel.Track _ NARROW[ref];
IO.PutChar[s, '[ ];
IO.PutF[s, "%d ", IO.int[vTrack.oldTrackNum]];
IO.PutF[s, "%d ", IO.int[vTrack.trackNum]];
IO.PutF[s, "%d ", IO.int[vTrack.trackPos]];
IO.PutF[s, "%d ", IO.int[vTrack.maxFeatureOnTrack]];
eachRefProc[vTrack.firstSeg];
IO.PutF[s, "%d ", IO.card[ORD[vTrack.blocked]+1]];
IO.PutF[s, "%d ", IO.card[ORD[vTrack.keep]+1]];
IO.PutChar[s, '] ];
};

ReadRoutingChannelSides: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
vRoutingChannelSides: RouteChannel.RoutingChannelSides _ NEW[RouteChannel.RoutingChannelSidesRec];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
vRoutingChannelSides.routeAreaCoord _ IO.GetInt[s];
{c: [0..5) _ IO.GetCard[s]-1;vRoutingChannelSides.extSide _ VAL[c]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'( THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '( expected at %d", IO.int[IO.GetIndex[s]]]];
FOR i: RoutePrivate.RoutingLayer IN RoutePrivate.RoutingLayer DO
TRUSTED {vRoutingChannelSides.barrierList[i] _ NARROW[eachNameProc[vRoutingChannelSides , @vRoutingChannelSides.barrierList[i]]]};
ENDLOOP;
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#') THEN RefIOPrivate.Error[IO.PutFR["Syntax error: ') expected at %d", IO.int[IO.GetIndex[s]]]];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
vRoutingChannelSides.enclosingBarrier.c1.p _ IO.GetInt[s];
vRoutingChannelSides.enclosingBarrier.c1.q _ IO.GetInt[s];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
vRoutingChannelSides.enclosingBarrier.c2.p _ IO.GetInt[s];
vRoutingChannelSides.enclosingBarrier.c2.q _ IO.GetInt[s];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vRoutingChannelSides];
};

WriteRoutingChannelSides: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vRoutingChannelSides: RouteChannel.RoutingChannelSides _ NARROW[ref];
IO.PutChar[s, '[ ];
IO.PutF[s, "%d ", IO.int[vRoutingChannelSides.routeAreaCoord]];
IO.PutF[s, "%d ", IO.card[ORD[vRoutingChannelSides.extSide]+1]];
IO.PutChar[s, '( ];
FOR i: RoutePrivate.RoutingLayer IN RoutePrivate.RoutingLayer DO
eachRefProc[vRoutingChannelSides.barrierList[i]];
ENDLOOP;
IO.PutChar[s, ') ];
IO.PutChar[s, '[ ];
IO.PutChar[s, '[ ];
IO.PutF[s, "%d ", IO.int[vRoutingChannelSides.enclosingBarrier.c1.p]];
IO.PutF[s, "%d ", IO.int[vRoutingChannelSides.enclosingBarrier.c1.q]];
IO.PutChar[s, '] ];
IO.PutChar[s, '[ ];
IO.PutF[s, "%d ", IO.int[vRoutingChannelSides.enclosingBarrier.c2.p]];
IO.PutF[s, "%d ", IO.int[vRoutingChannelSides.enclosingBarrier.c2.q]];
IO.PutChar[s, '] ];
IO.PutChar[s, '] ];
IO.PutChar[s, '] ];
};

ReadPQRectList: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
elPQRect: RTBasic.PQRect;
vPQRectList: RTBasic.PQRectList _ LIST [elPQRect];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
vPQRectList.first.c1.p _ IO.GetInt[s];
vPQRectList.first.c1.q _ IO.GetInt[s];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
vPQRectList.first.c2.p _ IO.GetInt[s];
vPQRectList.first.c2.q _ IO.GetInt[s];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
TRUSTED {vPQRectList.rest _ NARROW[eachNameProc[vPQRectList , @vPQRectList.rest]]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vPQRectList];
};

WritePQRectList: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vPQRectList: RTBasic.PQRectList _ NARROW[ref];
IO.PutChar[s, '[ ];
IO.PutChar[s, '[ ];
IO.PutChar[s, '[ ];
IO.PutF[s, "%d ", IO.int[vPQRectList.first.c1.p]];
IO.PutF[s, "%d ", IO.int[vPQRectList.first.c1.q]];
IO.PutChar[s, '] ];
IO.PutChar[s, '[ ];
IO.PutF[s, "%d ", IO.int[vPQRectList.first.c2.p]];
IO.PutF[s, "%d ", IO.int[vPQRectList.first.c2.q]];
IO.PutChar[s, '] ];
IO.PutChar[s, '] ];
eachRefProc[vPQRectList.rest];
IO.PutChar[s, '] ];
};

ReadGraph: PUBLIC PROC[s: IO.STREAM, eachNameProc: RefIOPrivate.NameToRefProc] RETURNS [ref: REF] ~ {
vGraph: RouteDiGraph.Graph _ NEW[RouteDiGraph.GraphRec];
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'[ THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '[ expected at %d", IO.int[IO.GetIndex[s]]]];
TRUSTED {vGraph.graphInfo _ NARROW[eachNameProc[vGraph , @vGraph.graphInfo]]};
TRUSTED {vGraph.nodeList _ NARROW[eachNameProc[vGraph , @vGraph.nodeList]]};
TRUSTED {vGraph.arcList _ NARROW[eachNameProc[vGraph , @vGraph.arcList]]};
TRUSTED {vGraph.superiorNodes _ NARROW[eachNameProc[vGraph , @vGraph.superiorNodes]]};
TRUSTED {vGraph.inferiorNodes _ NARROW[eachNameProc[vGraph , @vGraph.inferiorNodes]]};
[] _ IO.SkipWhitespace[s];
IF IO.GetChar[s]#'] THEN RefIOPrivate.Error[IO.PutFR["Syntax error: '] expected at %d", IO.int[IO.GetIndex[s]]]];
RETURN[vGraph];
};

WriteGraph: PUBLIC PROC[s: IO.STREAM, ref: REF, eachRefProc: RefIOPrivate.RefToNameProc] ~ {
vGraph: RouteDiGraph.Graph _ NARROW[ref];
IO.PutChar[s, '[ ];
eachRefProc[vGraph.graphInfo];
eachRefProc[vGraph.nodeList];
eachRefProc[vGraph.arcList];
eachRefProc[vGraph.superiorNodes];
eachRefProc[vGraph.inferiorNodes];
IO.PutChar[s, '] ];
};

Init[];
END.
��
��

"Cedar" style�
code�K�6��	K�VK��K�#K�=K�K�[K�K�LK�*K��K�K�%�K�K�K�K��
K�K�2K�K�0K�K�'K� K�:K�$K�@K�
K�%K�K�!K�bK�+K�XK�3K�fK�'K�`K�K�TK�"K�dK�.K�nK�)K�dK�'K�`K�0K�qK�)K�dK�1K�cK�%K�[K�%K�\K�!K�TK�-K�[K�"K�VK�-K�[K�2K�vK�#K�WK�1K�tK�0K�aK�#K�XK�K���jK�9K�K�qK�&K�'K�(K�'K�)K�*K�*K�K�qK�*K�*K�*K�*K�K�qK�DK�gK�K�qK�K�K���aK�,K�K�2K�3K�4K�3K�5K�6K�6K�K�6K�6K�6K�6K�K�@K�(K�K�K���eK�
K�%K�K�qK�FK�DK�K�qK�K�K���\K�#K�K�K�K�K�K���mK�$K�@K�K�qK�^K�\K�K�qK�K�K���dK�9K�K�"K�!K�K�K���iK�DK�K�qK�PK�;K�K�qK�%K�%K�K�qK�!K�8K�NK�K�qK�K�K���`K�1K�K�K�7K�K�1K�1K�K�-K�4K�K�K�K���cK�$K�K�qK�K�K�K�K�1K�K�qK�
K�K���ZK�K�K�$K�$K�&K�&K�-K�K�K���kK�<K�K�qK�'K�(K�CK�DK�'K�)K�+K�)K�(K�(K�*K�,K�+K�)K�(K�-K�'K�(K�K�qK�K�K���bK�.K�K�3K�4K�?K�@K�3K�5K�7K�5K�4K�4K�6K�8K�7K�5K�4K�9K�3K�4K�K�K���pK�YK�K�qK�DK�K�qK�0K�0K�0K�0K�K�qK�+K�-K�.K�0K�(K�,K�-K�+K�mK�sK�K�qK�K�K���gK�?K�K�@K�K�<K�<K�<K�<K�K�7K�9K�:K�<K�4K�8K�9K�7K�(K�+K�K�K���kK�JK�K�qK�dK�K�q�8K�fK��K�K�qK�bK�^K�`K�K�qK�K�K���bK�5K�K�&K��8K�'K��K�K�%K�#K�$K�K�K���iK�DK�K�qK�'K�*K�K�qK�K�K���`K�1K�K�3K�6K�K�K���rK�_K�K�qK�)K�)K�)K�(K�K�q�:K�sK��K�K�qK�K�qK�K�K���iK�CK�K�5K�5K�5K�4K��:K�*K��K�K�K�K���kK�JK�K�qK�%K�!K�<K�K�q�<K�\K��K�K�qK�`K�K�qK�K�K���bK�5K�K�1K�-K�8K��<K�"K��K�K�$K�K�K���kK� K�:K�K�qK�XK�VK�K�qK�K�K���bK�5K�K� K�K�K�K���gK�>K�K�qK�8K�K�K�:K�XK�(K�K�q�<K�XK��K�K�qK�K�q�<K�^K��K�K�qK�HK�K�qK�K�K���^K�-K�K�4K�)K�+K�6K�"K�4K��<K�"K��K�K��<K�%K��K�K�K�K�K���gK�>K�K�qK�K�q�<K�`K��K�K�qK�ZK�=K�K�^K�!K�(K�+K�PK�HK�K�7K�:K�K�qK�K�K���^K�-K�K��<K�&K��K�K�#K�9K�+K�%K�-K�4K�7K�K�K�)K�3K�6K�K�K���cK�2K�K�qK�>K�K� K�K�DK�PK�DK�4K�K�qK�
K�K���ZK�%K�K�K�$K�,K�+K�K� K�K�0K�K�K���gK�K�'K�K�qK�LK�JK�K�qK�K�K���^K�&K�K�K�K�K�K���dK�5K�K�qK�IK�$K�$K�QK�QK�K�qK�K�K���[K�'K�K�K�0K�0K� K� K�K�K���gK�K�0K�K�qK�LK�JK�K�qK�K�K���^K�-K�K�K�K�K�K���tK�eK�K�qK�+K�.K�*K�K�q�:K�{K��K�K�qK�K�qK�K�K���kK�GK�K�7K�:K�6K��:K�-K��K�K�K�K���eK�8K�K�qK�"K�K�K�(K�LK�6K�3K�K�qK�K�K���\K�)K�K�.K�+K�+K�4K�K�2K�/K�K�K���sK�bK�K�qK�3K�DK�K�q�@K��
K��K�K�qK�K�qK�K�qK�:K�:K�K�qK�K�qK�:K�:K�K�qK�K�qK�K�qK�K�K���jK�EK�K�?K�@K��@K�1K��K�K�K�K�FK�FK�K�K�FK�FK�K�K�K�K���jK�K�2K�K�qK�K�qK�K�qK�&K�&K�K�qK�K�qK�&K�&K�K�qK�K�qK�SK�K�qK�K�K���aK�.K�K�K�K�2K�2K�K�K�2K�2K�K�K�K�K�K���eK�8K�K�qK�NK�LK�JK�VK�VK�K�qK�K�K���\K�)K�K�K�K�K�"K�"K�K�K��K�K��������o