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;
debugging: BOOLEAN _ FALSE;
shftAAddr: Rapunzel.Address;
shftBAddr: Rapunzel.Address;


Fault: PUBLIC ERROR [bH: BindHandle, code: Rapunzel.FaultCode, address: Rapunzel.Address] = CODE;


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];

IF (simulation)
THEN {
word _ mem[phys MOD memMod];
}
ELSE {
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];

IF (simulation)
THEN {
mem[phys MOD memMod] _ word;
}
ELSE {
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;
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;
};


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[];

}...

"RapunzelServiceImpl.mesa
Copyright (C) 1986 by Xerox Corporation.  All rights reserved.
Bill Jackson (bj) September 22, 1986 6:31:14 pm PDT
Willie-Sue, March 18, 1987 1:09:10 pm PST
Types & Magic #'s
Global State
IF NOT (phys IN [lowerBound..upperBound])
THEN ERROR Fault[bH, nonexistent, addr];
IF NOT (phys IN [lowerBound..upperBound])
THEN ERROR Fault[bH, nonexistent, addr];
returnLength => resLength _ this.returnLength.returnLength * SIZE[Rapunzel.Result];
res: Rapunzel.PokeShortResult ¬ NULL;
res: Rapunzel.PokeShortResult ¬ NULL;
Κ
α˜š
œ™Jš
œ>™>Jš
œ3™3Jš
œ)™)—J˜š
Οk	˜	Jšœ	œ	˜Jšœœ˜Jšœœ!˜-Jšœ	œ˜Jšœœ˜Jšœœ˜J˜	—J˜šΟnœ˜Jšœ˜#Jšœ
˜Jšœ
˜—J˜š
œ™J˜J˜ ˜ J˜—J˜$Jšœ#œΟc˜>šœ#œŸ˜QJ˜—Jšœœ˜šœœ˜J˜—Jš	œœœœ
œ
˜3Jšœœ˜J˜—š
œ™J˜J˜	J˜Jšœœœ
˜Jšœœœ
˜Jš
œ˜Jš
œ˜J˜—J˜šžœœ
œIœ
˜aJ˜—J˜šžœœœ
œœœœ
œ˜>J˜J˜J˜—šžœœœ
œœœ
œ˜5J˜J˜J˜—J˜šžœœœ
œ	œ
œ˜;šœœ˜Jšœ
œ
˜—Jšœ	œ˜Jšœœ˜&Jšœ	œ	˜J˜J˜—J˜šž
œœœ
œœœœ˜VJšœœ˜&J˜šœ
˜šœ˜šœ
œœ™)Jšœ
œ™(—Jšœœ	˜J˜
—šœ˜šœ
œœ˜.Jš
œ
œœœœ˜W—J˜J˜——J˜J˜—šž
œœœ
œœœ˜MJšœœ˜&J˜šœ
˜šœ˜šœ
œœ™)Jšœ
œ™(—Jšœ	œ˜J˜
—šœ˜šœ
œœ˜.Jš
œ
œœœœ˜W—J˜J˜——J˜—J˜šžœœ
œ5˜NJš
œ˜Icodeš
œ˜Kš
œ˜J˜—šž	œœ
œ,˜BJšœ
œ˜%J˜*J˜!J˜J˜J˜—šž	œœ
œG˜]J˜*J˜J˜J˜J˜—šžœœ
œ,˜AJšœ
œ˜$J˜J˜)J˜"J˜%J˜J˜J˜J˜—šžœœ
œF˜[J˜)J˜J˜0J˜3J˜J˜—šžœœ
œ4œ
˜VJš	œ
œœ
œ
œ˜9Jšœœœœ
œœ˜RJšœ	œ
œ˜'Jšœœ
œœ˜.J˜J˜-J˜Jšœœ
œ˜Bšœœ
œ˜ J˜)J˜Jšœ
˜—J˜J˜—šžœœ
œ4œ
˜UJš	œ
œœ
œ
œ˜8Jšœœœœ
œœ˜QJšœ	œ
œ˜'Jšœœ
œœ˜.J˜J˜,J˜Jšœœ
œ˜Ašœœ
œ˜ J˜J˜&J˜)J˜J˜Jšœ
˜—J˜J˜—šžœœ
œ6œ
œ
œ˜uJ˜-Jšœœ
˜'š	œœ
œœ
˜,J˜J˜)Jšœ
˜—J˜—J˜šžœœ
œœ
œ
œ˜MJšœ
œ
œ
œ˜<Jšœœœœ
œœ˜TJšœ	œ
œ˜'Jšœœ
œ
˜Jšœœ
˜Jšœ
œ˜Jšœ
œ˜š
˜J˜šœœ
˜Jš
œS™SJš
œ;˜;Jšœœ
˜&—Jšœ
˜—J˜Jšœ
œ˜$Jšœœ
œ˜IJ˜Jšœ%œ˜-šœœ
˜"Jš
œ&˜&Kš
œ˜šœœ
˜˜J˜3Jšœ œ
˜%J˜ šœ
œ˜J˜J˜J˜—Jš
œ'˜'Jš
œ˜J˜—˜J˜3Jš
œ%™%šœ
œ˜J˜J˜.J˜—J˜.Jšœ!œ˜(Jš
œ˜J˜—˜
J˜2Jš
œ%™%šœ
œ˜J˜J˜-J˜—J˜>J˜?Jšœ œ˜'Jš
œ˜J˜—š
œ
˜
Jš
œ2˜2Jš
œ6˜6Kš
œ,˜,šœ
œ˜Jš
œ˜Jš
œ1˜1J˜—Jš
œ&˜&Jš
œ˜šœœ
œ˜%Jšœ œ
˜%J˜J˜Jš
œ ˜ Jš
œ'˜'Jš
œ˜Jšœ
˜—J˜—š
œ˜Jš
œ3˜3Jš
œ7˜7Kš
œ-˜-šœ
œ˜Jš
œ˜Jš
œ2˜2J˜—Jš
œ'˜'Jš
œ˜šœœ
œ˜%Jš
œ*˜*Jš
œ˜šœœ
˜#˜J˜2J˜J˜J˜—Jšœœ˜+—Jšœ
˜—J˜—Jšœœ
˜Jšœœ˜+—Jšœ
˜—J˜J˜—J˜šžœœ
œœ
œ
œ˜^Jšœ	œ
œ˜'Jšœœœ˜Jšœœ˜J˜J˜—šžœœ
œœ
œ
œ
˜\Jšœ	œ
œ˜'Jšœœœ˜Jšœœ˜J˜J˜—šžœœ
œœ
œ
œ˜YJšœ	œ
œ˜'Jšœœœ˜Jšœœ˜J˜—J˜šžœœ˜Jšœœ
˜%J˜Jšœœ˜
Jšœ'œ˜,Jšœœœ
œ
˜ J˜J˜—šžœœ˜J˜-Jšœœœ
œ
˜ J˜—J˜J˜J˜J˜J˜—…—!„.‡