-- RapunzelServiceImpl.mesa
	-- Copyright Ó 1986, 1988 by Xerox Corporation.  All rights reserved.
	-- Bill Jackson (bj) January 11, 1988 11:51:19 am PST
	-- Willie-Sue, April 9, 1987 6:54:04 pm PDT

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;
	-- Types & Magic #'s
		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;
	-- Global State
		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 {
		-- b _ IOPOps.GetByte[p ! IOPOps.Error => { Fault[bH, xx, xx] } ];
		};
		
	HistoryBufferSmash: PROC [ p: LONG CARDINAL, b: WORD ] = MACHINE CODE {
		-- IOPOps.PutByte[p, b ! IOPOps.Error => { 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 ) => {
				-- IF NOT (phys IN [lowerBound..upperBound]) THEN ERROR Fault[bH, nonexistent, addr];
				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 ) => {
				-- IF NOT (phys IN [lowerBound..upperBound]) THEN ERROR Fault[bH, nonexistent, addr];
				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
				-- returnLength => 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;
					-- res: Rapunzel.PokeShortResult ¬ NULL;
					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;
					-- res: Rapunzel.PokeShortResult ¬ NULL;
					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[];
	}.