<> <> <> <<>> DIRECTORY Convert, IO, PGACoordXlate, Rope; PGACoordXlateImpl: CEDAR PROGRAM IMPORTS Convert, IO, Rope EXPORTS PGACoordXlate ~ BEGIN <> PGACoord: TYPE = PGACoordXlate.PGACoord; Letter: TYPE = PGACoordXlate.Letter; Index: TYPE = PGACoordXlate.Index; SignalPins: TYPE = PGACoordXlate.SignalPins; Table: TYPE = REF TableRec; TableRec: TYPE = RECORD[ fixed: LIST OF SignalPins, seq: SEQUENCE size: NAT OF PGACoord]; -- coord rng is elem 0 <> RopeToPGACoord: PUBLIC PROC[rope: IO.ROPE] RETURNS [coord: PGACoord] = { char: CHAR _ rope.Fetch[]; int: INT _ Convert.IntFromRope[rope.Substr[1]]; coord _ [CharToLetter[char], int]}; PGACoordToRope: PUBLIC PROC[coord: PGACoord] RETURNS [rope: IO.ROPE] = { rope _ IO.PutFR["%g%02g", IO.char[LetterToChar[coord.let]], IO.int[coord.idx]]}; <> PinToPGACoord: PUBLIC PROC[key: ATOM, pin: NAT] RETURNS [coord: PGACoord] = { table: Table _ GetTable[ key]; RETURN[table[pin]]}; PGACoordToPin: PUBLIC PROC[key: ATOM, coord: PGACoord] RETURNS [pin: NAT_0] = { table: Table _ GetTable[ key]; FOR i: NAT IN [1..table.size) DO IF table[i]=coord THEN RETURN[i] ENDLOOP}; PGAFixedPins: PUBLIC PROC[key: ATOM] RETURNS [fixed: LIST OF SignalPins _ NIL] = { RETURN[CopySignalPinList[GetTable[key].fixed]]}; GetTable: PROC[key: ATOM] RETURNS[table: Table] = { table _ SELECT key FROM $PGA176A => table176, $PGA300A => table300, $PGA240A => table240, ENDCASE => ERROR}; CopySignalPinList: PROC[sigs: LIST OF SignalPins _ NIL] RETURNS[copy: LIST OF SignalPins _ NIL]= { IF sigs=NIL THEN RETURN[NIL]; RETURN[CONS[[sigs.first.nm, CopyPins[sigs.first.pins]], CopySignalPinList[sigs.rest]]]}; CopyPins: PROC[pins: LIST OF NAT] RETURNS[copy: LIST OF NAT _ NIL]= { IF pins=NIL THEN RETURN[NIL]; RETURN[CONS[pins.first, CopyPins[pins.rest]]]}; <> table176: Table _ NIL; Init176: PROC = { Def: PROC[let: Letter, elems: LIST OF NAT] = { FOR col: Index IN Index WHILE elems#NIL DO IF elems.first#0 THEN { IF table176[elems.first]#[z, 25] THEN ERROR; table176[elems.first] _ [let, col]}; elems _ elems.rest ENDLOOP}; gnd: SignalPins _ [nm: "Gnd", pins: LIST [146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176]]; vdd: SignalPins _ [nm: "Vdd", pins: LIST [147, 149, 151, 155, 157, 159, 163, 165, 167, 171, 173, 175]]; table176 _ NEW[TableRec[176+1]]; table176.fixed _ LIST[gnd, vdd]; FOR pin: NAT IN [1..table176.size) DO table176[pin] _ [z, 25] ENDLOOP; table176[0] _ [q, 15]; Def[ a,LIST[142, 1, 3, 6, 9, 12, 15, 16, 19, 20, 22, 25, 28, 31, 34]]; Def[ b,LIST[139,143, 2, 5, 8, 11, 14, 17, 21, 23, 26, 29, 32, 35, 37]]; Def[ c,LIST[136,140,144, 4, 7, 10, 13, 18, 24, 27, 30, 33, 36, 38, 39]]; Def[ d,LIST[133,137,141,145,146,147,148,149,150,151,152,153, 40, 41, 42]]; Def[ e,LIST[130,134,138,176, 0, 0, 0, 0, 0, 0, 0,154, 43, 44, 45]]; Def[ f,LIST[128,131,135,175, 0, 0, 0, 0, 0, 0, 0,155, 46, 47, 48]]; Def[ g,LIST[127,129,132,174, 0, 0, 0, 0, 0, 0, 0,156, 49, 50, 51]]; Def[ h,LIST[124,125,126,173, 0, 0, 0, 0, 0, 0, 0,157, 54, 53, 52]]; Def[ j,LIST[123,122,121,172, 0, 0, 0, 0, 0, 0, 0,158, 60, 57, 55]]; Def[ k,LIST[120,119,118,171, 0, 0, 0, 0, 0, 0, 0,159, 63, 59, 56]]; Def[ l,LIST[117,116,115,170, 0, 0, 0, 0, 0, 0, 0,160, 66, 62, 58]]; Def[ m,LIST[114,113,112,169,168,167,166,165,164,163,162,161, 69, 65, 61]]; Def[ n,LIST[111,110,108,105,102, 99, 96, 90, 85, 82, 79, 76, 72, 68, 64]]; Def[ p,LIST[109,107,104,101, 98, 95, 93, 89, 86, 83, 80, 77, 74, 71, 67]]; Def[ q,LIST[106,103,100, 97, 94, 92, 91, 88, 87, 84, 81, 78, 75, 73, 70]]; ValidateTable[table176]}; <> table300: Table _ NIL; Init300: PROC = { Def: PROC[let: Letter, elems: LIST OF NAT] = { FOR col: Index IN Index WHILE elems#NIL DO IF elems.first#0 THEN { IF table300[elems.first]#[z, 25] THEN ERROR; table300[elems.first] _ [let, col]}; elems _ elems.rest ENDLOOP}; gnd: SignalPins _ [nm: "Gnd", pins: LIST [270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300]]; vdd: SignalPins _ [nm: "Vdd", pins: LIST [269, 271, 273, 275, 277, 279, 281, 283, 285, 287, 289, 291, 293, 295, 297, 299]]; table300 _ NEW[TableRec[300+1]]; table300.fixed _ LIST[gnd, vdd]; FOR pin: NAT IN [1..table300.size) DO table300[pin] _ [z, 25] ENDLOOP; table300[0] _ [v, 20]; Def[ a,LIST[263, 7, 11, 12, 16, 19, 22, 25, 29, 30, 37, 38, 42, 45, 48, 51, 55, 56, 60, 62]]; Def[ b,LIST[261, 5, 2, 8, 13, 17, 20, 24, 28, 33, 34, 39, 43, 47, 50, 54, 59, 65, 72, 74]]; Def[ c,LIST[257,266,267, 3, 9, 14, 18, 23, 27, 32, 35, 40, 44, 49, 53, 58, 64, 66, 69, 78]]; Def[ d,LIST[256,260,265, 1, 4, 10, 15, 21, 26, 31, 36, 41, 46, 52, 57, 63, 68, 70, 75, 79]]; Def[ e,LIST[252,255,259,264,268, 6,269,270,271,272,273,274,275,276, 61, 67, 71, 76, 80, 83]]; Def[ f,LIST[249,251,254,258,262, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 73, 77, 81, 84, 86]]; Def[ g,LIST[247,248,250,253,300, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,277, 82, 85, 87, 89]]; Def[ h,LIST[243,244,245,246,299, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,278, 88, 90, 91, 92]]; Def[ j,LIST[239,240,241,242,298, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,279, 93, 94, 95, 96]]; Def[ k,LIST[238,235,236,237,297, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,280, 98, 99,100, 97]]; Def[ l,LIST[231,234,233,232,296, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,281,103,102,101,104]]; Def[ m,LIST[230,229,228,227,295, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,282,108,107,106,105]]; Def[ n,LIST[226,225,224,222,294, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,283,113,111,110,109]]; Def[ p,LIST[223,221,219,216,293, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,284,119,116,114,112]]; Def[ q,LIST[220,218,215,211,207, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,128,124,120,117,115]]; Def[ r,LIST[217,214,210,205,201,195,292,291,290,289,288,287,286,285,140,134,130,125,121,118]]; Def[ s,LIST[213,209,204,202,197,191,186,180,175,170,165,160,155,149,144,138,135,131,126,122]]; Def[ t,LIST[212,203,200,198,192,187,183,178,174,169,166,161,157,152,148,143,137,133,132,123]]; Def[ u,LIST[208,206,199,193,188,184,181,177,173,168,167,162,158,154,151,147,142,136,139,127]]; Def[ v,LIST[196,194,190,189,185,182,179,176,172,171,164,163,159,156,153,150,146,145,141,129]]; ValidateTable[table300]}; <> table240: Table _ NIL; Init240: PROC = { Def: PROC[let: Letter, elems: LIST OF NAT] = { FOR col: Index IN Index WHILE elems#NIL DO IF elems.first#0 THEN { IF table240[elems.first]#[z, 25] THEN ERROR; table240[elems.first] _ [let, col]}; elems _ elems.rest ENDLOOP}; unused: LIST OF NAT; table240 _ NEW[TableRec[240+1]]; table240.fixed _ NIL; FOR pin: NAT IN [1..table240.size) DO table240[pin] _ [z, 25] ENDLOOP; table240[0] _ [q, 15]; Def[ a,LIST[107, 80, 77, 74, 71, 68, 65, 62, 59, 56, 53, 50, 47, 44, 17]]; Def[ b,LIST[110, 92, 89, 83, 79, 73, 67, 61, 52, 41, 35, 29, 26, 13, 14]]; Def[ c,LIST[113, 98, 95, 86, 82, 76, 70, 58, 49, 38, 32, 23, 20, 10, 11]]; Def[ d,LIST[116,103,101, 87, 84, 75, 60, 45, 46, 34, 31, 22, 21, 7, 8]]; Def[ e,LIST[119,104,100, 94, 85, 78, 57, 39, 40, 28, 25, 19, 16, 4, 5]]; Def[ f,LIST[122,109,106, 97, 91, 88, 64, 55, 37, 24, 33, 15, 9, 1, 2]]; Def[ g,LIST[125,115,112,114,111,108,105, 43, 42, 18, 12, 6, 3,238,239]]; Def[ h,LIST[128,124,121,129,118,117,123, 66, 30,240,237,231,234,235,236]]; Def[ j,LIST[131,127,130,135,141,132,150,126, 27,216,219,228,225,232,233]]; Def[ k,LIST[134,133,136,138,147,159,168,162,210,201,213,217,222,229,230]]; Def[ l,LIST[137,139,142,153,156,165,171,192,189,195,207,208,214,226,227]]; Def[ m,LIST[140,145,148,157,163,169,174,183,186,198,204,202,211,223,224]]; Def[ n,LIST[143,151,154,160,166,172,177,180,187,193,196,199,205,220,221]]; Def[ p,LIST[146,152,158,164,170,175,178,181,184,190,194,200,206,212,218]]; Def[ q,LIST[149,155,161,167,173,176,179,182,185,188,191,197,203,209,215]]; unused_LIST[ 36, 48, 51, 54, 63, 69, 72, 81, 90, 93, 96, 99,102,120,144]; ValidateTable[table240, unused]}; <> Signal: SIGNAL[i: NAT] = CODE; CharToLetter: PROC[char: CHAR] RETURNS [let: Letter] = { nat: NAT; IF char IN['a..'z] THEN char _ char -'a +'A; nat _ SELECT char FROM IN ['A..'I) => char-0-'A, IN ('I..'O) => char-1-'A, IN ('O..'Z] => char-2-'A, ENDCASE => ERROR; let _ VAL[nat]}; LetterToChar: PROC[let: Letter] RETURNS [char: CHAR] = { char _ SELECT let FROM IN [a..h] => 'A + let.ORD, IN [j..n] => 'A + let.ORD+1, IN [p..z] => 'A + let.ORD+2, ENDCASE => ERROR}; ValidateTable: PROC[table: Table, unused: LIST OF NAT _ NIL] = { FOR i: NAT IN [1..table.size) DO IF table[i]=[z, 25] THEN IF unused=NIL OR unused.first#i THEN Signal[i] ELSE unused _ unused.rest ELSE FOR j: NAT IN (i..table.size) DO IF table[i]=table[j] THEN ERROR ENDLOOP ENDLOOP; IF unused#NIL THEN ERROR}; Init176[]; Init300[]; Init240[]; END.