<> <> <> <> DIRECTORY ESCAlpha USING [ alpha ], Heap USING [ systemZone ], Inline USING [ HighHalf, LowHalf, LongNumber ], Mopcodes USING [ zESC ], Put USING [ LongNumber, Text ], System USING [ NetworkAddress ], Rapunzel; RapunzelServiceImpl: PROGRAM IMPORTS Heap, Inline, Put, Rapunzel EXPORTS Rapunzel = { OPEN Rapunzel; <> pMemFetch: ESCAlpha.alpha = 3EH; pMemSmash: ESCAlpha.alpha = 3FH; firstPhysical: Rapunzel.Address = 0; lowestGuarded: Rapunzel.Address = (LONG[12]*256*256); -- 1.5MB lastPhysical: Rapunzel.Address = ((LONG[32]*256*256)-1); -- 2^(5+8+8) words = 4MB lowerBound: CARDINAL = 0; upperBound: CARDINAL = 1023; Mem: TYPE = ARRAY [lowerBound..upperBound] OF WORD; memMod: CARDINAL = 1024; <> mem: Mem; nilHandle: BindHandle; simulation: BOOLEAN _ FALSE; historyBuffer: BOOLEAN _ FALSE; debugging: BOOLEAN _ FALSE; shftAAddr: Rapunzel.Address; shftBAddr: Rapunzel.Address; Fault: PUBLIC ERROR [ bH: BindHandle, code: Rapunzel.FaultCode, address: Rapunzel.Address ] = CODE; HistoryBufferFetch: PROC [ p: LONG CARDINAL ] RETURNS [ b: WORD ] = MACHINE CODE { < { Fault[bH, xx, xx] } ];>> }; HistoryBufferSmash: PROC [ p: LONG CARDINAL, b: WORD ] = MACHINE CODE { < { Fault[bH, xx, xx] } ];>> }; MemFetch: PROC [ LONG CARDINAL ] RETURNS [ WORD ] = MACHINE CODE { Mopcodes.zESC, pMemFetch }; MemSmash: PROC [ LONG CARDINAL, WORD ] = MACHINE CODE { Mopcodes.zESC, pMemSmash }; Display: PROC [ lead: LONG STRING, value: LONG CARDINAL ] = { IF ( NOT debugging ) THEN RETURN; Put.Text[NIL, lead]; Put.LongNumber[NIL, value, [base: 8]]; Put.Text[NIL, "B\n"]; }; PeekOpCode: PROC [ bH: BindHandle, addr: LONG CARDINAL ] RETURNS [ word: WORD ] = INLINE { phys: CARDINAL = Inline.LowHalf[addr]; SELECT TRUE FROM ( simulation ) => { <> word _ mem[phys MOD memMod]; } ( historyBuffer ) => { word _ HistoryBufferFetch[addr]; } ENDCASE => { IF NOT ( addr IN [lowestGuarded..lastPhysical] ) THEN ERROR Fault[bH, IF ( addr < lowestGuarded ) THEN protection ELSE nonexistent, addr]; word _ MemFetch[addr]; }; }; PokeOpCode: PROC [ bH: BindHandle, addr: LONG CARDINAL, word: WORD ] = INLINE { phys: CARDINAL = Inline.LowHalf[addr]; SELECT TRUE FROM ( simulation ) => { <> mem[phys MOD memMod] _ word; } ( historyBuffer ) => { HistoryBufferSmash[addr, word]; } ENDCASE => { IF NOT ( addr IN [lowestGuarded..lastPhysical] ) THEN ERROR Fault[bH, IF ( addr < lowestGuarded ) THEN protection ELSE nonexistent, addr]; MemSmash[addr, word]; }; }; SetShftAddrs: PUBLIC PROC [ bH: BindHandle, shftA, shftB: Rapunzel.Address ] = { shftAAddr _ shftA; shftBAddr _ shftB; }; PeekShort: PUBLIC PROC [ bH: BindHandle, address: Rapunzel.Address ] RETURNS [ result: Rapunzel.Short ] = { Display["PeekShort - address: ", address]; result _ PeekOpCode[bH, address]; Display[" result: ", result]; }; PokeShort: PUBLIC PROC [ bH: BindHandle, address: Rapunzel.Address, value: Rapunzel.Short ] = { Display["PokeShort - address: ", address]; Display[" value: ", value]; PokeOpCode[bH, address, value]; }; PeekLong: PUBLIC PROC [ bH: BindHandle, address: Rapunzel.Address ] RETURNS [ result: Rapunzel.Long ] = { xx: Inline.LongNumber; Display["PeekLong - address: ", address]; xx.high _ PeekOpCode[bH, address]; xx.low _ PeekOpCode[bH, (address+1)]; result _ xx.lc; Display[" result: ", result]; }; PokeLong: PUBLIC PROC [ bH: BindHandle, address: Rapunzel.Address, value: Rapunzel.Long ] = { Display["PokeLong - address: ", address]; Display[" value: ", value]; PokeOpCode[bH, address, Inline.HighHalf[value]]; PokeOpCode[bH, (address+1), Inline.LowHalf[value]]; }; PeekSeqShort: PUBLIC PROC [ bH: BindHandle, address: Rapunzel.Address, count: CARDINAL ] RETURNS [ results: LONG POINTER TO Rapunzel.SeqShort ] = { Chunk: TYPE = RECORD [ SEQUENCE COMPUTED Rapunzel.SeqShortIndex OF Rapunzel.Short ]; zone: UNCOUNTED ZONE = Heap.systemZone; chunk: LONG POINTER = zone.NEW [Chunk[count]]; Display["PeekSeqShort - address: ", address]; Display[" count: ", count]; results _ zone.NEW [Rapunzel.SeqShort _ DESCRIPTOR[chunk, count]]; FOR i: CARDINAL IN [0..count) DO results[i] _ PeekOpCode[bH, (address+i)]; Display[" ", results[i]]; ENDLOOP; }; PeekSeqLong: PUBLIC PROC [ bH: BindHandle, address: Rapunzel.Address, count: CARDINAL ] RETURNS [ results: LONG POINTER TO Rapunzel.SeqLong ] = { Chunk: TYPE = RECORD [ SEQUENCE COMPUTED Rapunzel.SeqShortIndex OF Rapunzel.Long ]; zone: UNCOUNTED ZONE = Heap.systemZone; chunk: LONG POINTER = zone.NEW [Chunk[count]]; Display["PeekSeqLong - address: ", address]; Display[" count: ", count]; results _ zone.NEW [Rapunzel.SeqLong _ DESCRIPTOR[chunk, count]]; FOR i: CARDINAL IN [0..count) DO xx: Inline.LongNumber; xx.high _ PeekOpCode[bH, address+2*i]; xx.low _ PeekOpCode[bH, (address+2*i+1)]; results[i] _ xx.lc; Display[" ", results[i]]; ENDLOOP; }; PokeSeqShort: PUBLIC PROC [ bH: BindHandle, address: Rapunzel.Address, valueSeq: LONG POINTER TO Rapunzel.SeqShort ] = { Display["PokeSeqShort - address: ", address]; Display[" count: ", LENGTH[valueSeq^]]; FOR i: CARDINAL IN [0..LENGTH[valueSeq^]) DO Display[" ", valueSeq[i]]; PokeOpCode[bH, (address+i), valueSeq[i]]; ENDLOOP; }; DoCmds: PUBLIC PROC [ bH: BindHandle, cmdSeq: LONG POINTER TO Rapunzel.SeqCmd ] RETURNS [ resultSeq: LONG POINTER TO Rapunzel.SeqResult ] = { Chunk: TYPE = RECORD [SEQUENCE COMPUTED Rapunzel.SeqResultIndex OF Rapunzel.Result]; zone: UNCOUNTED ZONE = Heap.systemZone; chunk: LONG POINTER; resLength: CARDINAL; resIndex: CARDINAL _ 0; cmdIndex: CARDINAL _ 0; BEGIN this: Rapunzel.Cmd = cmdSeq[0]; WITH this: this SELECT FROM < resLength _ this.returnLength.returnLength * SIZE[Rapunzel.Result];>> returnLength => resLength _ this.returnLength.returnLength; ENDCASE => resLength _ cmdSeq^.LENGTH; END; chunk _ zone.NEW [Chunk[resLength]]; resultSeq _ zone.NEW [Rapunzel.SeqResult _ DESCRIPTOR[chunk, resLength]]; Display["DoCmds -- count: ", cmdSeq^.LENGTH]; WHILE ( cmdIndex < cmdSeq^.LENGTH ) DO this: Rapunzel.Cmd = cmdSeq[cmdIndex]; cmdIndex _ cmdIndex + 1; WITH this: this SELECT FROM peekShort => { address: Rapunzel.Address = this.peekShort.address; res: Rapunzel.PeekShortResult ¬ NULL; res _ [PeekOpCode[bH, address]]; IF ( debugging ) THEN { Display[" address: ", address]; Display[" peekShort: ", res]; }; resultSeq[resIndex] _ [peekShort[res]]; resIndex _ resIndex + 1; }; pokeShort => { address: Rapunzel.Address = this.pokeShort.address; <> IF ( debugging ) THEN { Display[" address: ", address]; Display[" pokeShort: ", this.pokeShort.value]; }; PokeOpCode[bH, address, this.pokeShort.value]; resultSeq[resIndex] _ [pokeShort[NULL]]; resIndex _ resIndex + 1; }; pokeLong => { address: Rapunzel.Address = this.pokeLong.address; <> IF ( debugging ) THEN { Display[" address: ", address]; Display[" pokeShort: ", this.pokeLong.value]; }; PokeOpCode[bH, address, Inline.HighHalf[this.pokeLong.value]]; PokeOpCode[bH, address+1, Inline.LowHalf[this.pokeLong.value]]; resultSeq[resIndex] _ [pokeLong[NULL]]; resIndex _ resIndex + 1; }; shftRead => { address: Rapunzel.Address = this.shftRead.address; numRepeats: Rapunzel.Short = this.shftRead.numRepeats; res: Rapunzel.ShftReadResult = [numRepeats]; IF ( debugging ) THEN { Display[" address: ", address]; Display[" shiftRead - numRepeats: ", numRepeats]; }; resultSeq[resIndex] _ [shftRead[res]]; resIndex _ resIndex + 1; FOR j: CARDINAL IN [0..numRepeats) DO res: Rapunzel.PeekShortResult ¬ NULL; [] _ PeekOpCode[bH, shftAAddr]; [] _ PeekOpCode[bH, shftBAddr]; res _ [PeekOpCode[bH, address]]; resultSeq[resIndex] _ [peekShort[res]]; resIndex _ resIndex + 1; ENDLOOP; }; shftWrite => { address: Rapunzel.Address = this.shftWrite.address; numRepeats: Rapunzel.Short = this.shftWrite.numRepeats; res: Rapunzel.ShftWriteResult = [numRepeats]; IF ( debugging ) THEN { Display[" address: ", address]; Display[" shiftWrite - numRepeats: ", numRepeats]; }; resultSeq[resIndex] _ [shftWrite[res]]; resIndex _ resIndex + 1; FOR j: CARDINAL IN [0..numRepeats) DO writeVal: Rapunzel.Cmd = cmdSeq[cmdIndex]; cmdIndex _ cmdIndex + 1; WITH writeVal: writeVal SELECT FROM pokeShort => { PokeOpCode[bH, address, writeVal.pokeShort.value]; [] _ PeekOpCode[bH, shftAAddr]; [] _ PeekOpCode[bH, shftBAddr]; }; ENDCASE => ERROR Fault[bH, nonexistent, 0]; ENDLOOP; }; returnLength => NULL; ENDCASE => ERROR Fault[bH, nonexistent, 0]; ENDLOOP; }; WriteSequential: PUBLIC PROC [ bH: BindHandle, startingAddress: Address, count: CARDINAL, seq: LONG POINTER TO Rapunzel.SeqLong ] = { FOR i: CARDINAL IN [0..count) DO address: Rapunzel.Address = startingAddress + 2*i; value: Long = seq[i]; PokeOpCode[bH, address, Inline.HighHalf[value]]; PokeOpCode[bH, address+1, Inline.LowHalf[value]]; ENDLOOP; }; FreePeekSeqShortResults: PUBLIC PROC [ bH: BindHandle, resultSeq: LONG POINTER TO SeqShort ] = { zone: UNCOUNTED ZONE = Heap.systemZone; zone.FREE [@(resultSeq^.BASE)]; zone.FREE [@(resultSeq)]; }; FreePeekSeqLongResults: PUBLIC PROC [ bH: BindHandle, resultSeq: LONG POINTER TO SeqLong ] = { zone: UNCOUNTED ZONE = Heap.systemZone; zone.FREE [@(resultSeq^.BASE)]; zone.FREE [@(resultSeq)]; }; FreeDoCmdsResults: PUBLIC PROC [ bH: BindHandle, resultSeq: LONG POINTER TO SeqResult ] = { zone: UNCOUNTED ZONE = Heap.systemZone; zone.FREE [@(resultSeq^.BASE)]; zone.FREE [@(resultSeq)]; }; Init: PROC = { trash: System.NetworkAddress _ TRASH; mem _ ALL[0]; nilHandle _ Rapunzel.RemoteBind[trash, NIL]; IF ( nilHandle # NIL ) THEN ERROR; }; Shutdown: PROC = { nilHandle _ Rapunzel.RemoteUnbind[nilHandle]; IF ( nilHandle # NIL ) THEN ERROR; }; Init[]; }.