<> <> <> <> <> <> <<>> DIRECTORY BitOps, Core, CoreCreate, Rope; Ports: CEDAR DEFINITIONS = BEGIN <> <> <> <> <> PortList: TYPE = LIST OF Port; Port: TYPE = REF PortRec; <<>> <> <<>> <> <> < [d: Drive _ none, l: Level _ L],>> < [d: Drive _ none, b: BOOL _ FALSE],>> < [ls: LevelSequence _ NIL, dt: SELECT driveType: DriveType FROM>> < [d: Drive _ none],>> < [ds: DriveSequence _ NIL],>> <> < [bs: BoolSequence _ NIL, dt: SELECT driveType: DriveType FROM>> < [d: Drive _ none],>> < [ds: DriveSequence _ NIL],>> <> < [>> <> <> <> < [d: Drive _ none],>> < [ds: DriveSequence _ NIL],>> <> < [>> <> <> <> < [d: Drive _ none],>> < [ds: DriveSequence _ NIL],>> <> < [>> <> <> <> < [d: Drive _ none],>> < [ds: DriveSequence _ NIL],>> <> < [composite: SEQUENCE size: NAT OF Port],>> <> <<>> PortRec: TYPE = RECORD [ levelType: LevelType _ composite, driveType: DriveType _ aggregate, d: Drive _ none, l: Level _ L, b: BOOL _ FALSE, ds: DriveSequence _ NIL, ls: LevelSequence _ NIL, bs: BoolSequence _ NIL, fieldStart: [0..64) _ 0, c: BitOps.BitWord _ BitOps.BitWordZero, lc: BitOps.BitDWord _ BitOps.BitDWordZero, q: BitOps.BitQWord _ BitOps.BitQWordZero, composite: SEQUENCE size: NAT OF Port]; LevelType: TYPE = {l, ls, b, bs, c, lc, q, composite}; DriveType: TYPE = {aggregate, separate}; Drive: TYPE = { inspect, -- allows test port to receive value expect, -- allows test port to specify expected value none, --in a test port it means neither driven nor checked; in an eval port it means no strength at all chargeWeak, chargeMediumWeak, charge, chargeMediumStrong, chargeStrong, force, -- weakest drive level, allows test procs to check if device has tristated driveWeak, driveMediumWeak, drive, driveMediumStrong, driveStrong, infinite -- drive for nodes which have infinite current sources }; Level: TYPE = {L, H, X}; DriveSequence: TYPE = REF DriveSequenceRec; DriveSequenceRec: TYPE = RECORD [drives: PACKED SEQUENCE size: NAT OF Drive]; LevelSequence: TYPE = REF LevelSequenceRec; LevelSequenceRec: TYPE = RECORD [levels: PACKED SEQUENCE size: NAT OF Level]; BoolSequence: TYPE = REF BoolSequenceRec; BoolSequenceRec: TYPE = RECORD [bools: PACKED SEQUENCE size: NAT OF BOOL]; PortData: TYPE = REF PortDataRec; PortDataRec: TYPE = RECORD [ levelType: LevelType, driveType: DriveType, drive: Drive, drives: DriveSequence]; levelTypeNames: ARRAY LevelType OF Rope.ROPE; levelNames: ARRAY Level OF Rope.ROPE; driveTypeNames: ARRAY DriveType OF Rope.ROPE; driveNames: ARRAY Drive OF Rope.ROPE; <> FindLevelType: PROC [levelTypeID: Rope.ROPE] RETURNS [levelType: LevelType]; FindLevel: PROC [levelID: Rope.ROPE] RETURNS [level: Level]; FindDriveType: PROC [driveTypeID: Rope.ROPE] RETURNS [driveType: DriveType]; FindDrive: PROC [driveID: Rope.ROPE] RETURNS [drive: Drive]; CreatePort: PROC [cellType: Core.CellType, testerPort: BOOL _ FALSE] RETURNS [port: Port]; <> <<>> RenewPort: PROC [cellType: Core.CellType, port: Port, testerPort: BOOL _ FALSE]; <<>> WirePortType: PROC [cellType: Core.CellType, wire: Core.Wire] RETURNS [levelType: LevelType, driveType: DriveType]; PortLeaves: PROC [port: Port] RETURNS [leaves: CARDINAL]; CopyPortValue: PROC [from: Port, to: Port]; <> CheckPortValue: PROC [root: Core.Wire, truth: Port, question: Port]; CheckPortValueEqual: PROC [root: Core.Wire, truth: Port, question: Port]; <> <<>> CheckError: SIGNAL [msg: Rope.ROPE]; <> InitPort: PROC [wire: Core.Wire, levelType: LevelType _ b, driveType: DriveType _ aggregate, initDrive: Drive _ none, initDrives: DriveSequence _ NIL] RETURNS [sameWire: Core.Wire]; InitPorts: PROC [ct: Core.CellType, initType: LevelType _ l, initDrive: Drive _ none, n0, n1, n2, n3, n4, n5, n6, n7, n8, n9, n10: CoreCreate.WR _ NIL]; InitPortList: PROC [ct: Core.CellType, initType: LevelType _ l, initDrive: Drive _ none, ports: LIST OF CoreCreate.WR]; InitTesterDrive: PROC [wire: Core.Wire, initDrive: Drive _ none, initDrives: DriveSequence _ NIL]; <> InitTesterDrives: PROC [ct: Core.CellType, initDrive: Drive _ none, n0, n1, n2, n3, n4, n5, n6, n7, n8, n9, n10: CoreCreate.WR _ NIL]; InitTesterDriveList: PROC [ct: Core.CellType, initDrive: Drive _ none, ports: LIST OF CoreCreate.WR]; ITDList: PROC [public: Core.Wire, indicies: LIST OF NAT, initDrive: Drive]; IPList: PROC [public: Core.Wire, indicies: LIST OF NAT, levelType: LevelType, initDrive: Drive _ none]; PortIndex: PROC [wire: Core.Wire, name: Rope.ROPE] RETURNS [NAT]; PortIndexes: PROC [wire: Core.Wire, n0, n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11: Rope.ROPE _ NIL] RETURNS [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11: NAT _ LAST[NAT]]; <> <> <<>> SetPortLevelType: PROC [wire: Core.Wire, levelType: LevelType _ b] RETURNS [sameWire: Core.Wire]; SetPortDriveType: PROC [wire: Core.Wire, driveType: DriveType _ aggregate] RETURNS [sameWire: Core.Wire]; SetPortTesterDriveType: PROC [wire: Core.Wire, driveType: DriveType _ aggregate] RETURNS [sameWire: Core.Wire]; SetInitialPortDrive: PROC [wire: Core.Wire, initDrive: Drive _ none, initDrives: DriveSequence _ NIL] RETURNS [sameWire: Core.Wire]; SetInitialPortTesterDrive: PROC [wire: Core.Wire, initDrive: Drive _ none, initDrives: DriveSequence _ NIL] RETURNS [sameWire: Core.Wire]; SetPorts: PROC [r: Core.Wire, n: LIST OF Rope.ROPE, lt: LevelType _ b, cdt: DriveType _ aggregate, cd: Drive _ none, cds: DriveSequence _ NIL, tdt: DriveType _ aggregate, td: Drive _ none, tds: DriveSequence _ NIL]; <> <> <> <> <> <<>> BindPort: PROC [rootWire: Core.WireSeq, rootPort: Port, name: Rope.ROPE] RETURNS [p: Port]; <> BindPorts: PROC [rootWire: Core.WireSeq, rootPort: Port, n0, n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11: Rope.ROPE _ NIL] RETURNS [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11: Port _ NIL]; <> <> <<>> <> GetDrive, GD: PROC [p: Port] RETURNS [v: Drive]; PutDrive, PD: PROC [p: Port, v: Drive]; GetDriveSequence, GDS: PROC [p: Port, i: NAT] RETURNS [v: Drive]; PutDriveSequence, PDS: PROC [p: Port, i: NAT, v: Drive]; <> GetLevel, GL: PROC [p: Port] RETURNS [v: Level]; PutLevel, PL: PROC [p: Port, v: Level, d: Drive _ drive]; GetLevelSequence, GLS: PROC [p: Port, i: NAT] RETURNS [v: Level]; PutLevelSequence, PLS: PROC [p: Port, i: NAT, v: Level, d: Drive _ drive]; GetBool, GB: PROC [p: Port] RETURNS [v: BOOL]; PutBool, PB: PROC [p: Port, v: BOOL, d: Drive _ drive]; GetBoolSequence, GBS: PROC [p: Port, i: NAT] RETURNS [v: BOOL]; PutBoolSequence, PBS: PROC [p: Port, i: NAT, v: BOOL, d: Drive _ drive]; GetWord, GW: PROC [p: Port] RETURNS [v: BitOps.BitWord]; PutWord, PW: PROC [p: Port, v: BitOps.BitWord, d: Drive _ drive]; GetDWord, GDW: PROC [p: Port] RETURNS [v: BitOps.BitDWord]; PutDWord, PDW: PROC [p: Port, v: BitOps.BitDWord, d: Drive _ drive]; GetQWord, GQW: PROC [p: Port] RETURNS [v: BitOps.BitQWord]; PutQWord, PQW: PROC [p: Port, v: BitOps.BitQWord, d: Drive _ drive]; <> <> <<>> Not: PROC [src, dst: Port]; Copy: PROC [src, dst: Port]; Set: PROC [p: Port, v: Level]; AnyX: PROC [p: Port] RETURNS [BOOL]; ToRope: PROC [p: Port, size: NAT _ 0, base: NAT _ 16] RETURNS [r: Rope.ROPE]; <> Size: PROC [p: Port] RETURNS [size: NAT]; <> EachPortPairProc: TYPE = PROC [onePort: Port, anotherPort: Port] RETURNS [subElements: BOOL _ TRUE, quit: BOOL _ FALSE]; VisitPortPair: PROC [onePort: Port, anotherPort: Port, eachPortPair: EachPortPairProc] RETURNS [quit: BOOL]; <> EachWirePortPairProc: TYPE = PROC [wire: Core.Wire, port: Port] RETURNS [subElements: BOOL _ TRUE, quit: BOOL _ FALSE]; VisitBinding: PROC [wire: Core.Wire, port: Port, eachWirePortPair: EachWirePortPairProc] RETURNS [quit: BOOL]; <> <<>> GetFullPortName: PROC [port: Port, rootPort: Port, rootWire: Core.Wire] RETURNS [name: Rope.ROPE]; <> <> ConversionError: SIGNAL; ToBool: PROC [a: Level] RETURNS [b: BOOL]; <> ToLevel: PROC [a: BOOL] RETURNS [b: Level]; NotL: PROC [a: Level] RETURNS [b: Level]; AndL: PROC [a, b: Level] RETURNS [c: Level]; OrL: PROC [a, b: Level] RETURNS [c: Level]; XorL: PROC [a, b: Level] RETURNS [c: Level]; SumL: PROC [a, b, c: Level] RETURNS [carry, s: Level]; NotLS: PROC [a, b: LevelSequence]; CopyLS: PROC [from, to: LevelSequence]; SetLS: PROC [seq: LevelSequence, level: Level]; HasX: PROC [ls: Ports.LevelSequence] RETURNS [BOOL _ FALSE]; LSToRope, LevelSequenceToRope: PROC [container: LevelSequence, size: NAT _ 0, base: NAT _ 16] RETURNS [val: Rope.ROPE]; <> LSToC: PROC [ls: LevelSequence] RETURNS [c: CARDINAL]; <> <<>> CToLS: PROC [c: CARDINAL, ls: LevelSequence]; <> <<>> LSToLC: PROC [ls: LevelSequence] RETURNS [lc: LONG CARDINAL]; <> <<>> LCToLS: PROC [lc: LONG CARDINAL, ls: LevelSequence]; <> <<>> LSToQ: PROC [ls: LevelSequence] RETURNS [q: BitOps.BitQWord]; <> <<>> QToLS: PROC [q: BitOps.BitQWord, ls: LevelSequence]; <> <<>> END.