{File name ndbLisp.mc -- modified for Punt testing
Description: DandeLion InterLisp Emulator
Purcell: 15-Aug-85 18:52:11 {improve 64K atoms in \interp}
Purcell: June 8, 1981 Created
Last edited: Lichtenberg 9-Jun-85 18:25:01 %4 tried to make ufn call work right
Last edited: Lichtenberg 28-Jul-85 18:27:46 %x% CANCELBR[$] --> ReadCANCELBR[$]
Last edited: Purcell, 3-Feb-85 14:17:41 {%3} apply2 moved from Xufn.
Last edited: Purcell, 3-Feb-85 14:17:41 {%2} Daybreak starts at 0 with 1 trap.
Last edited: Charnley, 23-Mar-84 10:34:55 added L1 set in FNX
Last edited: Charnley, 8-Dec-83 14:12:11 added sink1 org
Last edited: Charnley, 17-Oct-83 16:50:25
Last edited: Purcell 31-Jul-83 17:32:28 fix FNXCross not to depend on S which may be distorted by SCar5
Last Edited: Lichtenberg 31-Jul-83 18:13:40 :: Steve: read comment where you made last change - had to add a click
Last edited: Charnley, 20-Jul-83 11:45:32
Last edited: Charnley, April 14, 1983 11:04 AM; MUL tail added
Last edited: Purcell, April 6, 1983 6:34 PM; Fugato
Last edited: Purcell, March 6, 1983 6:18 PM pad base of stack twice not once
Last edited: Purcell, February 5, 1983 11:42 AM;
Last edited: Purcell, December 27, 1982 9:52 PM; segmentcrossing
Last edited: Purcell, July 27, 1982 12:34 PM}
{use DandeLisp.df, Dandelion.df and Mesa.df for defs}
SetTask[0];
{*************************}
{Traps and Errors: do hard reset}
{*************************}
sink2:
c2;
sink3:
c3;
sink1: at[B0sink1],
uRx ← Rx, CANCELBR[$, 0F], c1;
uTT ← TT, c2;
Rx ← 23, c3;
rhRio ← 5, c1;
Rio ← 0, c2;
, c3;
MAR ← [rhRio, Rio + 0], c1;
MDR ← PV, c2;
, c3;
Rx ← Rx LRot8, c1;
Rx{9000=2328h} ← Rx +28, c2;
Q ← Rx +Q{error#}, GOTO[MPWait], c3;
ErrTrap: Rx ← RRot1 ErrnIBnStkp, ClrIntErr, CANCELBR[$, 0F], c1, at[0];
ErrLoop: Xbus ← Rx LRot0, XwdDisp, c2;
DISP2[CSParErr], c3;
CSParErr: Q ← 0+1, GOTO[sink2], c1, at[0,4,CSParErr];{MP9001}
Q ← 5, {GOTO[sink2],} c1, at[1,4,CSParErr];;{MP9005}
Noop,c2;
GOTO[Germ], c3;{%2}
StackErr: Q ← 2, {CANCELBR[sink2, 3],%M}GOTO[sink2], c1, at[2,4,CSParErr];{MP9002}
IBEmptyErr: Q ← 3, {CANCELBR[sink2, 3],%M}GOTO[sink2], c1, at[3,4,CSParErr];{MP9003}
{*************************
IVAR, IVARX, PVAR, PVARX, FVAR, FVARX, STOREN 25% 4 clicks
**************************}
{L0 set to low nible of opcode; set L3 to 0-3 for I,P,F or S var}
IVAR: MAR ← S ← [rhS, S + 1], GOTO[IVar1], L3 ← 0, c1, opcode[100'b];{40}
MAR ← S ← [rhS, S + 1], GOTO[IVar1], L3 ← 0, c1, opcode[101'b];
MAR ← S ← [rhS, S + 1], GOTO[IVar1], L3 ← 0, c1, opcode[102'b];
MAR ← S ← [rhS, S + 1], GOTO[IVar1], L3 ← 0, c1, opcode[103'b];
MAR ← S ← [rhS, S + 1], GOTO[IVar1], L3 ← 0, c1, opcode[104'b];
MAR ← S ← [rhS, S + 1], GOTO[IVar1], L3 ← 0, c1, opcode[105'b];
MAR ← S ← [rhS, S + 1], GOTO[IVar1], L3 ← 0, c1, opcode[106'b];
IVARX: MAR ← S ← [rhS, S + 1], GOTO[IVar1], L3 ← 0, c1, opcode[107'b];
PVAR: MAR ← S ← [rhS, S + 1], GOTO[PVar1], L3 ← 1, c1, opcode[110'b];{48}
MAR ← S ← [rhS, S + 1], GOTO[PVar1], L3 ← 1, c1, opcode[111'b];
MAR ← S ← [rhS, S + 1], GOTO[PVar1], L3 ← 1, c1, opcode[112'b];
MAR ← S ← [rhS, S + 1], GOTO[PVar1], L3 ← 1, c1, opcode[113'b];
MAR ← S ← [rhS, S + 1], GOTO[PVar1], L3 ← 1, c1, opcode[114'b];
MAR ← S ← [rhS, S + 1], GOTO[PVar1], L3 ← 1, c1, opcode[115'b];
MAR ← S ← [rhS, S + 1], GOTO[PVar1], L3 ← 1, c1, opcode[116'b];
PVARX: MAR ← S ← [rhS, S + 1], GOTO[PVar1], L3 ← 1, c1, opcode[117'b];
FVAR: MAR ← S ← [rhS, S + 1], L2 ← 0, c1, opcode[120'b];{50}
uTOSH ← MDR ← TOSH, DISP3[VnoCar0, 4], L3 ← 4, c2;
MAR ← S ← [rhS, S + 1], L2 ← 1, c1, opcode[121'b];
uTOSH ← MDR ← TOSH, DISP3[VnoCar0, 4], L3 ← 4, c2;
MAR ← S ← [rhS, S + 1], L2 ← 2, c1, opcode[122'b];
uTOSH ← MDR ← TOSH, DISP3[VnoCar0, 4], L3 ← 4, c2;
MAR ← S ← [rhS, S + 1], L2 ← 3, c1, opcode[123'b];
uTOSH ← MDR ← TOSH, DISP3[VnoCar0, 4], L3 ← 4, c2;
MAR ← S ← [rhS, S + 1], L2 ← 4, c1, opcode[124'b];
uTOSH ← MDR ← TOSH, DISP3[VnoCar0, 4], L3 ← 4, c2;
MAR ← S ← [rhS, S + 1], L2 ← 5, c1, opcode[125'b];
uTOSH ← MDR ← TOSH, DISP3[VnoCar0, 4], L3 ← 4, c2;
MAR ← S ← [rhS, S + 1], L2 ← 6, c1, opcode[126'b];
uTOSH ← MDR ← TOSH, DISP3[VnoCar0, 4], L3 ← 4, c2;
FVARX: MAR ← S ← [rhS, S + 1], L2 ← 7, c1, opcode[127'b];
uTOSH ← MDR ← TOSH, DISP3[VnoCar0, 4], L3 ← 4, c2;
@COPYN: MAR ← S ← [rhS, S + 1], GOTO[SVar1], L3 ← 5, c1, opcode[75'b];
IVar1: MDR ← TOSH, DISP3[VnoCar0], c2;
PVar1: MDR ← TOSH, DISP3[VnoCar0, 1], c2;
SVar1: MDR ← TOSH, DISP3[VnoCar0, 5], c2;
{place these intructions for dispatch at VCar1 and for pageCross dispatch}
S ← S + 0FF + 1, GOTO[VCar1], c3, at[2,8,VnoCar0];
S ← S + 0FF + 1, GOTO[VCar1], c3, at[3,8,VnoCar0];
S ← S + 0FF + 1, GOTO[VCar1], L3 ← 4, c3, at[6,8,VnoCar0];
S ← S + 0FF + 1, GOTO[VCar1], c3, at[7,8,VnoCar0];
VCar1: MAR ← [rhS, S + 0], L3Disp, {retry the stack ref} c1;
MDR ← TOSH, DISP3[VnoCar0], c2;
Q ← uIVar, L2Disp, GOTO[V2], c3, at[0,8,VnoCar0];
Q ← PV, L2Disp, GOTO[V2], c3, at[1,8,VnoCar0];
Q ← PV, L2Disp, GOTO[V2], c3, at[4,8,VnoCar0];
Q ← S - ib, c3, at[5,8,VnoCar0];
MAR ← S ← [rhS, S + 1], c1;
MDR←TOS, Rx←Q, L2←3, CANCELBR[VarX, 3],WriteOK, c2;
V2: MAR ← S ← [rhS, S + 1], DISP4[Voff, 8], c1;
Voff: MDR←TOS, Rx←Q+ 0, L2←2, CANCELBR[Var, 2],WriteOK, c2, at[8, 10, Voff];
MDR←TOS, Rx←Q+2, L2←2, CANCELBR[Var,2],WriteOK, c2, at[9,10, Voff];
MDR←TOS, Rx←Q+4, L2←2, CANCELBR[Var,2],WriteOK, c2, at[0A,10, Voff];
MDR←TOS, Rx←Q+ 6, L2←2, CANCELBR[Var,2],WriteOK, c2, at[0B,10, Voff];
MDR←TOS, Rx←Q+8, L2←2, CANCELBR[Var,2],WriteOK, c2, at[0C,10, Voff];
MDR←TOS, Rx←Q+0A, L2←2,CANCELBR[Var,2],WriteOK, c2, at[0D,10, Voff];
MDR←TOS, Rx←Q+0C, L2←2, CANCELBR[Var,2],WriteOK, c2, at[0E,10, Voff];
VoffX: MDR←TOS, Rx←Q+ ib, L2←3, CANCELBR[VarX, 3],WriteOK, c2, at[0F,10, Voff];
Var: rhRx ← nRhS, GOTO[Var2], c3;
VarX: rhRx ← nRhS, GOTO[Var2], c3;
Var2: MAR ← [rhRx, Rx + 0], L3Disp, c1;
[] ← S xor uStkLimO, ZeroBranch, DISP3[IVar3, 2], c2;
IVar3: TOSH ← MD, L2Disp, BRANCH[Var4, StkOvr1], c3, at[2, 8, IVar3];
PVar3: TOSH ← MD, L2Disp, BRANCH[Var4, StkOvr1], c3, at[3, 8, IVar3];
SVar3: TOSH ← MD, L2Disp, BRANCH[Var4, StkOvr1], c3, at[7, 8, IVar3];
Var4: MAR ← Q ← [rhRx, Rx + 1], BRANCH[$, varPcX, 0E{2}], c1;
PC ← PC + PC16, L2 ← L2.0, IBDisp, DISP2[varEnd], c2;
varPcX: PC ← PC + 1, L2 ← L2.0, IBDisp, DISP2[varEnd], c2;
DNI.TOSg: {common tail}
varEnd: TOS ← MD, L2 ← L2.0, DISPNI[OpTable], c3, at[0, 4, varEnd];
varEndCar: Q ← 80'd, GOTO[sink1], {"impossible"} c3, at[2, 4, varEnd];{MP9080}
{Stack Limit:}
StkOvr1: MAR ← Q ← [rhRx, Rx + 1], BRANCH[$, varPcXov, 0E{2}], c1;
PC ← PC + PC16, CANCELBR[varEndOv, 2], c2;
varPcXov: PC ← PC + 1, CANCELBR[varEndOv, 2], c2;
varEndOv: TOS ← MD, GOTO[StackOverflow], c3;
{*******************************
PVAR←, PVARX←, IVARX← 4% 2 clicks
*******************************}
SPVAR: MAR ← Q ← [rhPV, PV + 0 + 1], GOTO[SVar], c1, opcode[130'b];{58}
MAR ← Q ← [rhPV, PV + 2 + 1], GOTO[SVar], c1, opcode[131'b];
MAR ← Q ← [rhPV, PV + 4 + 1], GOTO[SVar], c1, opcode[132'b];
MAR ← Q ← [rhPV, PV + 6 + 1], GOTO[SVar], c1, opcode[133'b];
MAR ← Q ← [rhPV, PV + 8 + 1], GOTO[SVar], c1, opcode[134'b];
MAR ← Q ← [rhPV, PV + 0A + 1], GOTO[SVar], c1, opcode[135'b];
MAR ← Q ← [rhPV, PV + 0C + 1], GOTO[SVar], c1, opcode[136'b];
SVar: MDR ← TOS, Rx←Q, rhRx←nRhS, BRANCH[SVNoCar, SVCarry, 1], c2;
SVCarry: Rx ← Q + 0FF +1, c3;
MAR ← [rhRx, Rx + 0], c1;
MDR ← TOS, c2;
SVNoCar: PC ← PC + PC16, GOTO[SVTail], c3;
@STOREN:
MAR ← Q ← [rhS, S - ib], c1, opcode[74'b];
MDR ← TOS, Rx←Q, rhRx←nRhS, BRANCH[STXNoC, STXCar, 1], c2;
STXCar: Rx ← Q - 0FF -1, GOTO[STCar1], c3;
STCar1: MAR ← [rhRx, Rx + 0], c1;
MDR ← TOS, c2;
STXNoC: PC ← PC + 1, GOTO[SVTail], c3;
@SPVARX: MAR ← Q ← [rhPV, PV + ib + 1], c1, opcode[137'b];{5F}
MDR ← TOS, Rx←Q, rhRx←nRhS, BRANCH[SVXNoC, SVXCar, 1], c2;
SVXCar: Rx ← Q + 0FF +1, GOTO[SVCar1], c3;
@SIVARX: rhRx←nRhS, {1% 3 clicks} c1, opcode[142'b];{62}
Rx ← uIVar, c2;
Rx ← Rx + ib + 1, GOTO[SVCar1], c3;
SVCar1: MAR ← [rhRx, Rx + 0], c1;
MDR ← TOS, c2;
SVXNoC: PC ← PC + 1, c3;
SVTail: MAR ← [rhRx, Rx - 1], L2 ← L2.0, c1;
MDR ← TOSH, IBDisp, DISP2[DNI.nop], WriteOK, c2;
DNI.nop: {common tail}
L2 ← L2.0, DISPNI[OpTable], c3;
CantGetHere:
Q ← 88'd, GOTO[sink1], c3, at[2, 4, DNI.nop];
{*******************************
GVAR 3% 5 clicks
*******************************}
GVAR: MAR ← S ← [rhS, S + 1], c1, opcode[140'b];{60}
MDR ← TOSH, TT ← ib, BRANCH[$, GVCross, 1], c2;
GVnoCross: TT ← TT LRot8, c3;
MAR ← S ← [rhS, S + 1], c1;
MDR ← TOS, rhTT ← uValHigh, CANCELBR[$, 2], WriteOK, c2;
TT ← (TT or ib) LShift1, c3;
Map ← Q ← [rhTT,TT], L0 ← L0.RedoGV, c1;
L1 ← L1.PopOnly, c2;
Rx ← rhRx ← MD, ReadXRefBr, c3;
MAR← [rhRx, Q + 0], ReadBRANCH[GVMap,$], c1, at[L0.RedoGV,10,RMapFixCaller];
[] ← S xor uStkLimO, ZeroBranch, c2;
TOSH ← MD, BRANCH[$, GVStkOvr], c3;
MAR ← Q ← [rhRx, Q + 1], L2 ← L2.0, c1;
PC ← PC + 1 + PC16, IBDisp, CANCELBR[DNI.TOSg, 0], c2;
GVMap: CALL[RLMapFix]{will return to RedoGV}, c2;
{Stack Limit:}
GVStkOvr: MAR ← Q ← [rhRx, Q + 1], c1;
PC ← PC + 1 + PC16, CANCELBR[$,2], c2;
TOS ← MD, GOTO[StackOverflow], c3;
{page cross}
GVCross: S ← S + 0FF + 1, c3;
MAR ← [rhS, S + 0], c1;
MDR ← TOSH, GOTO[GVnoCross], c2;
{*******************************
PVARd← 2% 4 clicks
*******************************}
SPVARd: MAR ← Q ← [rhPV, PV + 0 + 1], GOTO[SVarD], c1, opcode[270'b];{B8}
MAR ← Q ← [rhPV, PV + 2 + 1], GOTO[SVarD], c1, opcode[271'b];
MAR ← Q ← [rhPV, PV + 4 + 1], GOTO[SVarD], c1, opcode[272'b];
MAR ← Q ← [rhPV, PV + 6 + 1], GOTO[SVarD], c1, opcode[273'b];
MAR ← Q ← [rhPV, PV + 8 + 1], GOTO[SVarD], c1, opcode[274'b];
MAR ← Q ← [rhPV, PV + 0A + 1], GOTO[SVarD], c1, opcode[275'b];
MAR ← Q ← [rhPV, PV + 0C + 1], GOTO[SVarD], c1, opcode[276'b];
SVarD: MDR ← TOS, Rx ← Q, rhRx ← nRhS, BRANCH[$, SVDCarry, 1], c2;
SVDcont: PC ← PC + PC16, c3;
MAR ← [rhRx, Rx - 1], c1;
MDR ← TOSH, CANCELBR[$, 2], WriteOK, c2;
Noop, c3;
MAR ← [rhS, S + 0], c1;
S ← S - 1, c2;
TOS ← MD, c3;
MAR ← [rhS, S + 0], L2 ← L2.0, c1;
S ← S - 1, IBDisp, c2;
DNI.TOSHg: {common tail}
TOSH ← MD, L2 ← L2.0, DISPNI[OpTable], c3;
SVDCarry: Rx ← Rx + 0FF +1, c3;
MAR ← [rhRx, Rx + 0], c1;
MDR ← TOS, GOTO[SVDcont], c2;
{*************************
GETBASEN 3% 3 clicks
**************************}
GETBASEN:
TT ← TOS + ib, CarryBr, L2 ← L2.0, c1, opcode[310'b];{C8}
Rx{TOSH+1} ← TOSH+1, BRANCH[$, GBNseg], c2;
rhTT ← TOSH LRot0, c3;
MapGBN: Map ← Q ← [rhTT,TT], L0 ← L0.RedoGBN, c1;
PC ← PC + 1, L1 ← L1.DecDec, c2;
Rx ← rhRx ← MD, ReadXRefBr, c3;
MAR← [rhRx,Q+0], ReadBRANCH[GBNMap,$], c1,at[L0.RedoGBN,10,RMapFixCaller];
TOSH ← smallpl, IBDisp, GOTO[DNI.TOSg], c2;
{ TOS ← MD, L2 ← L2.0, DISPNI[OpTable], c3;}
GBNMap: CANCELBR[RLMapFix, 3]{will return to RedoGBN}, c2;
GBNseg: rhTT ← Rx{TOSH+1} LRot0, GOTO[MapGBN], c3;
{*************************
GETBASEPTRN (base, 1st byte=offset)
**************************}
GETBASEPTRN:
TT ← TOS + ib, CarryBr, c1, opcode[311'b];{C9}
Rx{TOSH+1} ← TOSH+1, BRANCH[$, BPseg], c2;
rhTT ← TOSH LRot0, c3;
MapBP: Map ← Q ← [rhTT,TT], L0 ← L0.RedoBP, c1;
PC ← PC + 1, L1 ← L1.DecDec, c2;
Rx ← rhRx ← MD, ReadXRefBr, c3;
MAR← [rhRx, Q + 0], ReadBRANCH[BPMap,$], c1,at[L0.RedoBP,10,RMapFixCaller];
TOSH ← 0FF, c2;
TOSH ← MD and TOSH, c3;
MAR← [rhRx, Q + 1], L2 ← L2.0, c1;
IBDisp, CANCELBR[DNI.TOSg, 0], c2;
BPMap: CALL[RLMapFix]{will return to RedoBP}, c2;
BPseg: rhTT ← Rx{TOSH+1} LRot0, GOTO[MapBP], c3;
{*************************
GETBASEBYTE: {ptr, disp} 3% 4.5 clicks
**************************}
GETBASEBYTE: {ptr, disp}
MAR ← [rhS, S], S ← S -1, c1, opcode[302'b];{C2}
Ybus ← TOSH xor smallpl, NZeroBr, CANCELBR[$,2], c2;
TT ← MD{ptr}, BRANCH[$, ufnBY], c3;
MAR ← [rhS, S], S ← S - 1, L1 ← L1.PushOnly, c1;
Rx ← TOS RShift1, YDisp, BRANCH[$, BYCarry, 1], c2;
BYret: rhTT ← MD{ptrH}, TT ← TT + Rx, CarryBr, BRANCH[BYeven, $, 0E], c3;
BYodd: Map ← [rhTT, TT], BRANCH[$, BYOseg], c1;
Q ← {u}0FF, L0 ← L0.BYRedoO, c2;
Rx ← rhRx ← MD, ReadXRefBr, c3;
MAR ← [rhRx, TT + 0], ReadBRANCH[BYMapUDO,$], c1, at[L0.BYRedoO,10, RMapFixCaller];
PC ← PC + PC16, L2 ← L2.0, IBDisp, c2;
TOS ← MD and Q, L2 ← L2.0, DISPNI[OpTable], c3;
{**}
BYeven: Map ← [rhTT, TT], BRANCH[$, BYEseg], c1;
Noop, c2;
Rx ← rhRx ← MD, ReadXRefBr, c3;
{**}
MAR← [rhRx, TT + 0], L0 ← L0.BYRedoE, ReadBRANCH[BYMapUDE,$], c1, at[L0.BYRedoE,10, RMapFixCaller];
Q ← ~0FF, L2 ← L2.0, c2;
TOS ← MD and Q, c3;
TOS ← TOS LRot8, GOTO[IB.pc1], c1;
ufnBY: Rx ← 302'b, CANCELBR[ufn2incS, 3] c1;
BYMapUDE: CALL[RLMapFix], c2;
BYMapUDO: CALL[RLMapFix], c2;
{page cross:}
BYCarry: S ← S - 0FF, CANCELBR[$, 0F], c3;
MAR ← [rhS, S + 0], c1;
S ← S - 1, GOTO[BYret], Ybus ← TOS, YDisp, c2;
BYOseg: Q ← rhTT + 1, LOOPHOLE[byteTiming], c2;
rhTT ← Q LRot0, GOTO[BYodd], c3;
BYEseg: Q ← rhTT + 1, LOOPHOLE[byteTiming], c2;
rhTT ← Q LRot0, GOTO[BYeven], c3;
{*************************
PUTBASEN: {ptr, val => ptr} 1% 4 clicks
**************************}
PUTBASEN: MAR ← [rhS, S], S ← S - 1, c1, opcode[315'b];{CD}
Ybus ← TOSH xor smallpl, NZeroBr, CANCELBR[$, 2], c2;
Rx ← MD{ptr}, BRANCH[$, ufnPUTB], c3;
MAR ← [rhS, S], S ← S - 1, L0 ← L0.RedoW, c1;
{uuRx ←}TT ← Rx + ib {+1}, CarryBr, BRANCH[$, PBCar, 1], c2;
PBCont: Q{ptrH} ← rhTT ← MD{ptrH}, BRANCH[$, PBSeg], c3;
PBsegok: Map ← {TT ←} [rhTT, TT +0{- 1}], {Xbus ← ib,} c1;
uuRx{ptr} ← Rx, PC ← PC + 1, L1 ← L1.PushDec2, c2;
Rx ← rhRx ← MD, XwdDisp{XDirtyDisp}, c3;
RedoW: MAR ← [rhRx, TT + 0], DISP2[PBMap], c1,at[L0.RedoW,10,WMapFixCaller];
MDR ← TOS, TOSH ← Q{ptrH}, IBDisp, L2 ← L2.0, c2, at[PgDirty, 4, PBMap];
DNI.funny:
TOS ← uuRx{ptr}, L2 ← L2.0, DISPNI[OpTable], c3;
CALL[WLMapFix], {will return to RedoW} c2, at[PgClean, 4, PBMap];
CALL[WLMapFix], {will return to RedoW} c2, at[PgProt, 4, PBMap];
CALL[WLMapFix], {will return to RedoW} c2, at[PgVacant, 4, PBMap];
ufnPUTB: Rx ← 315'b, GOTO[ufn2incS] c1;
{memory reference is good, but S is +0FF instead of -1}
PBCar: Noop, BRANCH[$, PBCarSeg], c3;
MAR ← S{S - 0FF} ← [rhS, 0 + 0], c1;
S ← S - 1, GOTO[PBCont], c2;
PBCarSeg: MAR ← S{S - 0FF} ← [rhS, 0 + 0], c1;
S ← S - 1, Xbus ← 1, XDisp, GOTO[PBCont], c2;
PBSeg: Q ← Q+1, c1;
rhTT ← Q{ptrH+1} LRot0, c2;
Q ← Q - 1, GOTO[PBsegok], c3;
{*************************}
PUTBASEPTRN: {(ptr, val => ptr) 2% 5 clicks}
MAR ← [rhS, S], S ← S -1, c1, opcode[316'b];{CE}
PC ← PC + 1, CANCELBR[$, 2], c2;
Rx ← MD{ptr}, c3;
MAR ← [rhS, S + 0], L0 ← L0.RedoPBP, c1;
{uuRx ← Rx,} TT ← Rx + ib {+ 1},CarryBr, c2;
Q{ptrH} ← rhTT ← MD{ptrH}, BRANCH[$, PBPSeg], c3;
PBPok: Map ← [rhTT, TT+0], c1;
uuRx ← Rx, S ← S +{-} 1, L1 ← L1.DecDec{PushDec2}, c2;
Rx ← rhRx ← MD, XwdDisp{XDirtyDisp}, c3;
{fiddle with S to make Cin one for uuRx ← Rx}
RedoPBP: MAR ← [rhRx, TT + 1], DISP2[PBPMap], c1,at[L0.RedoPBP,10,WMapFixCaller];
MDR ← TOS, CANCELBR[$, 2], WriteOK, c2, at[PgDirty, 4, PBPMap];
S ← S-2, c3;
MAR ← [rhRx, TT + 0], L2 ← L2.0, c1;
MDR ← TOSH, TOSH ← Q{ptrH}, IBDisp, GOTO[DNI.funny], c2;
{ TOS ← uuRx{ptr}, DISPNI[OpTable], c3;}
CANCELBR[WLMapFix, 3], {return to RedoPBP} c2, at[PgClean, 4, PBPMap];
CANCELBR[WLMapFix, 3], {return to RedoPBP} c2, at[PgProt, 4, PBPMap];
CANCELBR[WLMapFix, 3], {return to RedoPBP} c2, at[PgVacant, 4, PBPMap];
PBPSeg: Q ← Q+1, c1;
rhTT ← Q{ptrH+1} LRot0, c2;
Q ← Q - 1, GOTO[PBPok], c3;
{*************************}
PUTBASEBYTE: {ptr, disp, val => val} {3% 9{7}clicks}
MAR ← [rhS, S], S ← S -1, c1, opcode[307'b];{C7}{S = S - 1}
Ybus ← TOSH xor smallpl, NZeroBr, CANCELBR[$, 2], c2;
Rx ← MD{disp}, BRANCH[$, ufnPBY], c3;
MAR ← [rhS, S + 0], c1;
S ← S -1, c2;{S = S - 2}
Q ← MD{dispH}, c3;
MAR ← [rhS, S], S ← S -1, c1;{S = S - 3}
Ybus ← Q xor smallpl, NZeroBr, CANCELBR[$,2], c2;
uRx ← Rx, TT ← MD{ptr}, BRANCH[$, ufnPBY1], c3;
MAR ← [rhS, S], S ← S - 1, L1 ← L1.Push2OK, c1;{S = S - 4}
Rx ← Rx RShift1, YDisp, BRANCH[$, PBYCarry, 1], c2;
PBYret: rhTT ← MD{ptrH}, TT ← TT + Rx, CarryBr, BRANCH[$, oddS, 0E], c3;
evenS: Map ← [rhTT, TT], BRANCH[$, PBYESeg], c1;
Q ← 0FF, L0 ← L0.WBYRedoE, c2;
Rx ← rhRx ← MD, XwdDisp{XDirtyDisp}, c3;
WBYRedoE: MAR ← [rhRx, TT + 0], DISP2[WBYMapUDE], c1, at[L0.WBYRedoE,10,WMapFixCaller];
TOS ← TOS LRot8, c2, at[PgDirty, 4, WBYMapUDE];
joinY: Q ← MD and Q, c3;
Q ← Q or TOS, c1;
TOS ← TOS LRot8 xor TOS, c2;
TOS ← TOS and 0FF, c3;
MAR ← [rhRx, TT + 0], L2 ← L2.0, c1;
MDR ← Q, IBDisp, GOTO[DNI.pc1], c2;
{ PC ← PC + PC16, L2 ← L2.0, DISPNI[OpTable], c3;}
oddS: Map ← {Q ←} [rhTT, TT], BRANCH[$, PBYOSeg], c1;
L0 ← L0.WBYRedoO, c2;
Rx ← rhRx ← MD, XwdDisp{XDirtyDisp}, c3;
WBYRedoO: MAR ← [rhRx, TT + 0], DISP2[WBYMapUDO], c1, at[L0.WBYRedoO,10,WMapFixCaller];
Q ← ~0FF, GOTO[joinY], c2, at[PgDirty, 4, WBYMapUDO];
ufnPBY: Rx ← 307'b, CANCELBR[ufn2incS, 3] c1;
ufnPBY1: Rx ← 307'b, GOTO[ufn2inc3S], c1;
CALL[WLMapFix], c2, at[PgClean, 4, WBYMapUDE];
CALL[WLMapFix], c2, at[PgProt, 4, WBYMapUDE];
CALL[WLMapFix], c2, at[PgVacant, 4, WBYMapUDE];
CALL[WLMapFix], c2, at[PgClean, 4, WBYMapUDO];
CALL[WLMapFix], c2, at[PgProt, 4, WBYMapUDO];
CALL[WLMapFix], c2, at[PgVacant, 4, WBYMapUDO];
{page cross:}
PBYCarry: S ← S - 0FF, CANCELBR[$, 0F], c3;
MAR ← [rhS, S + 0], c1;
S ← S - 1, GOTO[PBYret], Xbus ← uRx, XDisp, c2;
PBYESeg: Q ← rhTT + 1, LOOPHOLE[byteTiming], c2;
rhTT ← Q LRot0, GOTO[evenS], c3;
PBYOSeg: Q ← rhTT + 1, LOOPHOLE[byteTiming], c2;
rhTT ← Q LRot0, GOTO[oddS], c3;
{*************************
ADDBASE (ptr, disp) 1% 3 clicks
**************************}
ADDBASE: MAR ← [rhS, S], S ← S -1, c1, opcode[320'b];{D0}
Ybus ← TOSH xor smallpl, NZeroBr, CANCELBR[$,2], c2;
Rx ← MD, BRANCH[$, ufnAB], c3;
MAR ← [rhS, S + 0], {S ← S -1,} c1;
TOS ← TOS + Rx, CarryBr, c2;
TOSH ← MD, BRANCH[adBnoc, adBcar], c3;
adBnoc: GOTO[addBtail], c1;
adBcar: TOSH ← TOSH + 1, GOTO[addBtail], c1;
addBtail: S ← S - 1, IBDisp, L2 ← L2.0, c2;
DNI.pc1: {common tail}
PC ← PC + PC16, L2 ← L2.0, DISPNI[OpTable] c3;
ufnAB: Rx ← 320'b, GOTO[ufn2incS], c1;
{*************************
HILOC, LOLOC 2% 1 click
**************************}
HILOC: TOS ← TOSH, GOTO[LoLoc1], c1, opcode[322'b];{D2}
LOLOC: Noop, c1, opcode[323'b];{D3}
LoLoc1: TOSH ← smallpl, IBDisp, L2 ← L2.0, GOTO[DNI.pc1], c2;
{*************************
COPY 3% 2 clicks
**************************}
COPY: MAR ← S ← [rhS, S + 1], c1, opcode[144'b];{64}
CopyRet: MDR ← TOSH, S ← S + 1, BRANCH[$, CopyCarry, 1], c2;
Ybus ← S xor uStkLimO, ZeroBranch, c3;
MAR ← [rhS, S + 0], BRANCH[$, CopyStkLim], c1;
MDR ← TOS, IBDisp, L2 ← L2.0, GOTO[DNI.pc1], c2;
{page cross:}
CopyCarry: S ← S + 0FF, c3;
MAR ← [rhS, S + 0], GOTO[CopyRet], c1;
{Stack Limit:}
CopyStkLim: MDR ← TOS, c2;
PC ← PC + PC16, GOTO[StackOverflow], c3;
{*************************
NIL, KT, ZERO, ONE, SIC, SNIC 15 % 2 clicks
SICX, ACONST, ATOMNUMBER 5 % 3 clicks
**************************}
LinkCross: PV ← Q{PV - 9 + 100h} - 0FF - 1, c3;
MAR ← Q{PV- 9} ← [rhPV, PV + 0], GOTO[link2], c1;
MYALINK: MAR ← Q{PV- 9} ← [rhPV, PV - 9], L3 ← L3.pls1, c1, opcode[146'b];
link2: PV ← Q + 9, BRANCH[$, LinkCross, 1], c2;
Q ← MD, XLDisp, L2 ← L2.0, c3;
MAR ← S ← [rhS, S + 2], BRANCH[linkE, linkO, 0E], c1;
linkE: STK ← MDR ← TOS, TOS ← Q - 0A, DISP2[NoCar], c2;
linkO: STK ← MDR ← TOS, TOS ← Q - 0B, DISP2[NoCar], c2;
ACONST: Rx ← ib, L3 ← L3.atm3, c1, opcode[147'b];{67}
Rx ← Rx LRot8, GOTO[xx], c2;
ATOMN: Rx ← ib, L3 ← L3.pls3, GOTO[sic2], c1, opcode[160'b];{70}
SICX: Rx ← ib, L3 ← L3.pls3, c1, opcode[156'b];{6E}
sic2: Rx ← Rx LRot8, GOTO[xx], c2;
xx: Q ← Rx or ib, Cin←pc16, {prepare for inc3} c3;
MAR ← S ← [rhS, S + 2], c1;
STK ← MDR ← TOS, TOS ← Q, L2 ← L2.0, DISP2[NoCar], c2;
NIL: MAR ← S ← [rhS, S + 2], L3 ← L3.atm1, c1, opcode[150'b];{68}
L3Zero: STK ← MDR ← TOS, TOS ← 0, L2 ← L2.0, DISP2[NoCar], c2;
KT: MAR ← S ← [rhS, S + 2], L3 ← L3.atm1, c1, opcode[151'b];{69}
STK ← MDR ← TOS, TOS ← KTval, L2 ← L2.0, DISP2[NoCar], c2;
ZERO: MAR ← S ← [rhS, S + 2], L3 ← L3.pls1, c1, opcode[152'b];{6A}
STK ← MDR ← TOS, TOS ← 0, L2 ← L2.0, DISP2[NoCar], c2;
ONE: MAR ← S ← [rhS, S + 2], L3 ← L3.pls1, c1, opcode[153'b];{6B}
STK ← MDR ← TOS, TOS ← 1, L2 ← L2.0, DISP2[NoCar], c2;
SIC: MAR ← S ← [rhS, S + 2], L3 ← L3.pls2, c1, opcode[154'b];{6C}
uTOS ← MDR ← TOS, TOS ← ib, L2 ← L2.0, DISP2[NoCar], c2;
SNIC: Q ← ib, {shorten ?%!} c1, opcode[155'b];{6D}
Q ← Q - 0FF - 1, c2;
Noop, c3;
MAR ← S ← [rhS, S + 2], L3 ← L3.neg2, c1;
uTOS ← MDR ← TOS, TOS ← Q, L2 ← L2.0, DISP2[NoCar], c2;
Carry: S ← S + 0FF + 1, L3Disp, c3, at[2,4,NoCar];
MAR ← [rhS, S + 0], BRANCH[saveS, saveU, 0B], c1;
saveU: MDR ← uTOS, L2 ← L2.0, GOTO[NoCar], c2;
saveS: MDR ← STK, L2 ← L2.0, GOTO[NoCar], c2;
NoCar: Ybus ← S xor uStkLimO, ZeroBranch, L3Disp, c3, at[0,4,NoCar];
MAR ← [rhS, S - 1], Xbus←0, XC2npcDisp, L3Disp, DISP4[SicTosh, 8], c1;
MDR ← TOSH, TOSH ← 0{atom}, IBDisp, DISP4[Kinc, 6], WriteOK, c2, at[8, 10, SicTosh];
MDR ← TOSH, TOSH ← 0{atom}, DISP4[KincL, 6], WriteOK, c2, at[9, 10, SicTosh];
MDR ← TOSH, TOSH ← smallpl, IBDisp, DISP4[Kinc, 6], WriteOK, c2, at[0A, 10, SicTosh];
MDR ← TOSH, TOSH ← smallpl, DISP4[KincL, 6], WriteOK, c2, at[0B, 10, SicTosh];
MDR ← TOSH, TOSH ← smallpl, IBDisp, CANCELBR[inc2, 0F], WriteOK, c2, at[0C, 10, SicTosh];
MDR ← TOSH, TOSH ← smallpl, CANCELBR[incL2, 0F], WriteOK, c2, at[0D, 10, SicTosh];
MDR ← TOSH, TOSH ← smallneg, IBDisp, CANCELBR[inc2, 0F], WriteOK, c2, at[0E, 10, SicTosh];
MDR ← TOSH, TOSH ← smallneg, CANCELBR[incL2, 0F], WriteOK, c2, at[0F, 10, SicTosh];
inc2: PC ← PC + 1, L2 ← L2.0, DISPNI[OpTable], c3;
incL2: PC ← PC + 1, L2 ← L2.0, GOTO[StackOverflow], c3;
inc1: PC ← PC + PC16, L2 ← L2.0, DISPNI[OpTable], c3, at[6,10, Kinc];
PC ← PC + PC16, L2 ← L2.0, DISPNI[OpTable], c3, at[7,10, Kinc];
incL1: PC ← PC + PC16, GOTO[StackOverflow], c3, at[6,10, KincL];
PC ← PC + PC16, GOTO[StackOverflow], c3, at[7,10, KincL];
inc3: PC ← PC + 1, L2 ← L2.0, DISPNI[OpTable], c3, at[0E,10, Kinc];
PC ← PC + 2, L2 ← L2.0, DISPNI[OpTable], c3, at[0F,10, Kinc];
incL3: PC ← PC + 1, GOTO[StackOverflow], c3, at[0E,10, KincL];
PC ← PC + 2, GOTO[StackOverflow], c3, at[0F,10, KincL];
{*************************
GCONST
**************************}
{uPCCrossL will be off no matter what: suceed, fault, stkOver}
GCONST: MAR ← S ← [rhS, S + 1], c1, opcode[157'b];{6F}
uTOSH ← MDR ← TOSH, TOSH ← ib, BRANCH[$, GCCarry, 1], c2;
GCNoCarry: Rx ← ib, L0 ← L0.RedoGC, c3;
MAR ← PC ← [rhPC, PC + 2], L1 ← L1.TrapGC{fault trap}, c1;
Rx ← Rx LRot8, BRANCH[$, GCPCCarry, 1], c2;
GCPCNoC: IB ← MD, Q ← Rx, c3;
GCok: MAR ← S ← [rhS, S + 1], c1;
MDR ← TOS, TOS ← Q or ib, CANCELBR[$, 2], WriteOK, c2;
Ybus ← S xor uStkLimO, ZeroBranch, L2 ← L2.0, c3;
MAR ← [rhPC, PC + 1], BRANCH[$, GConStkLim], c1;
RefillNE1: AlwaysIBDisp, L0 ← L0.NERefill.Set, DISP2[NoRCross], c2;
{exceptions:}{if page cross succeedes update UvPCpageL and uPCCrossL}
GCCarry: S ← S + 0FF + 1, c3;
MAR ← [rhS, S + 0], c1;
MDR ← uTOSH, GOTO[GCNoCarry], c2;
GCPCCarry: Q ← 0FF + 1, L1 ← L1.TrapGC{fault trap}, c3;
TT ← UvPCpageL, GOTO[UpdatePC2], c1;
{uPCCrossL will be off no matter what: suceed, fault, stkOver}
GCCross: uPCCrossL ← TT{0 low}, PC ← MD, rhPC ← MD, ReadXRefBr, c3, at[L0.RedoGC,10,ECross];
MAR ← Q ← [rhPC, Q + 0], ReadBRANCH[GCMap, $], c1;
UvPCpageL ← TT, PC ← Q, GOTO[GCPCNoC], c2;
{PC page cross plus map update: save Rx}
GCMap: uRx ← Rx, {returns at GCRedo} c2;
Rx ← PC, Xbus ← PC LRot0,XwdDisp, GOTO[RLMapFix1], c3;
{%x% was CANCELBR[$], should probably be ReadCANCELBR}
GCRedo: MAR ← PC ← [rhPC, Q + 0], ReadCANCELBR[$], c1, at[L0.RedoGC, 10, RMapFixCaller];
Q ← uRx, c2;
UvPCpageL ← TT, IB ← MD, GOTO[GCok], c3;
GCTrap: TOSH ← uTOSH, c1, at[L1.TrapGC,10,Fix];
PC ← Q{PC}{++} - 2, c2;
S ← S -1, GOTO[NoFixes], c3;
{Stack Limit:}
GConStkLim: Noop, CANCELBR[$, 2], c2;
Noop, GOTO[StackOverflow], c3;
{*************************
POP 5% 2 click
**************************}
POP: MAR ← [rhS, S], S ← S - 1, c1, opcode[277'b];{BF}
PC ← PC + PC16, CANCELBR[$, 2], c2;
TOS ← MD, c3;
MAR ← [rhS, S + 0], c1;
S ← S - 1, IBDisp, L2 ← L2.0, GOTO[DNI.TOSHg], c2;
{*************************
SWAP
**************************}
{SWAP: MAR ← [rhS, S - 1], c1, opcode[375'b];{FD}
PC ← PC + PC16, MDR ← TOSH, CANCELBR[$, 2], WriteOK, c2;
TOSH ← MD, c3;
MAR ← [rhS, S + 0], c1;
MDR ← TOS, IBDisp, L2 ← L2.0, GOTO[DNI.TOSg], c2;%M}
SWAP: opcode[375'b],
MAR ← [rhS, S - 1], c1;
CANCELBR[$, 2], c2;
Rx ← MD, c3;
MAR ← [rhS, S - 1], c1;
MDR ← TOSH, CANCELBR[$, 2], WriteOK, c2;
TOSH ← Rx, c3;
MAR ← [rhS, S + 0], c1;
PC ← PC + PC16, c2;
Rx ← MD, c3;
MAR ← [rhS, S + 0], c1;
MDR ← TOS, IBDisp, L2 ← L2.0, c2;
TOS ← Rx, L2 ← L2.0, DISPNI[OpTable], c3;
{*************************
NOP
**************************}
NOP: PC ← PC + PC16, GOTO[IB.nop], c1, opcode[376'b];{FE}
{*************************
EQ 3% 3 clicks
**************************}
EQ: MAR ← [rhS, S], S ← S - 1, c1, opcode[360'b];{F0}
PC ← PC + PC16, CANCELBR[$, 2], c2;
Rx ← MD xor TOS, c3;
MAR ← [rhS, S + 0], c1;
S ← S - 1, c2;
TT ← MD xor TOSH, c3;
Ybus ← Rx or TT, ZeroBr, L2 ← L2.0, c1;
TOSH ← 0{atm}, IBDisp, BRANCH[eqNIL, eqKT], c2;
eqNIL: TOS ← 0{NIL}, L2 ← L2.0, DISPNI[OpTable], c3;
eqKT: TOS ← KTval, L2 ← L2.0, DISPNI[OpTable], c3;
{***********************}
APPLY: {(S) Flush top of stack} opcode[016'b],{0E}
MAR ← [rhS, S - 1], L3{ib's}←0, c1;
applyTl: TT ← 0FF + 1{400=AT.INTERPRETER%}, CANCELBR[$ ,2], c2;
Q ← MD{nargsHi}, c3;
MAR ← [rhS, S + 0], c1;
Ybus ← Q xor smallpl, NZeroBr, c2;
{TOSH ← }rhTOSH ← MD{nargs}, BRANCH[$, appUfn], c3;
rhTT ← TOSH{defHi} LRot0, ZeroBr, c1;
TOSH{args2} ← rhTOSH{args} LShift1, BRANCH[$, applyCode], c2;
notCCode: PV ← PV - 6, c3;
MAR ← [rhPV, PV + 0], c1;
MDR ← TOSH{iVar} ← S - TOSH{arg2} - 1, c2;
PV ← PV + 6, c3;
MAR ← [rhS, S - 1], c1;
MDR ← rhTT, CANCELBR[interpret3, 2], WriteOK, c2;
applyCode: TT ← TOS, GOTO[apply2], c3;
{%3}
apply2: MAR ← [rhPV, PV - 6], c1;
MDR ← TOSH{iVar} ← S - TOSH{arg2} - 1, BRANCH[$, SCar9, 1], c2;
SC9Cont: , c3;
uTT ← TT, TT ← TT LShift1, SE ← 1 {%4 wild hack, get rid of the 1 that was shifted in}, NegBr, c1;
{TT ← TT - 1,} BRANCH[appLoDEF, appHiDEF], c2;
appLoDEF:
rhTT ← DEFspace, GOTO[fnMD], c3;
appHiDEF:
rhTT ← DEFspaceHi, GOTO[fnMD], c3;
{%3 end}
appUfn: Q ← 14'd, GOTO[sink2], c1;{MP9014}
{***********************}
FNX: MAR ← Q ← [rhS, S + 1], L0 ← L0.RefillFNX, c1, opcode[015'b];{0D}
STK ← MDR ← TOSH,{ rhTT ← DEFspace,} BRANCH[Cont5, SCar5, 1], c2;
Cont5: TOSH ← ib LShift1, XC2npcDisp, c3;
MAR ← [rhPC, PC + 2], BRANCH[$, noNeed, 0E], L1 ← L1.FNX, c1;
TOSH ← TOSH - 2, BRANCH[$, FNXCross, 1], c2;
TOSH ← Q - TOSH, IB ← MD, GOTO[fnIV], L3{ib's}←3, c3;
noNeed: TOSH ← TOSH - 2, CANCELBR[$, 0E], L1 ← L1.FNX, c2;
TOSH ← Q - TOSH, GOTO[fnIV], L3{ib's}←3, c3;
{***********************}
FN0: MAR ← Q ← [rhS, S + 1], L3{ib's}←2, c1, opcode[010'b];{08}
STK ← TOSH, MDR ← TOSH, TOSH ← 1 + Q +1, BRANCH[Cont1, SCar1, 1], c2;
FN1: MAR ← Q ← [rhS, S + 1], L3{ib's}←2, c1, opcode[011'b];{09}
FN1Ext: STK ← MDR ← TOSH, TOSH ← Q - 0, BRANCH[Cont1, SCar1, 1], c2;
FN2: MAR ← Q ← [rhS, S + 1], L3{ib's}←2, c1, opcode[012'b];{0A}
FVcall: STK ← MDR ← TOSH, TOSH ← Q - 2, BRANCH[Cont1, SCar1, 1], c2;
FN3: MAR ← Q ← [rhS, S + 1], L3{ib's}←2, c1, opcode[013'b];{0B}
STK ← MDR ← TOSH, TOSH ← Q - 4, BRANCH[Cont1, SCar1, 1], c2;
FN4: MAR ← Q ← [rhS, S + 1], L3{ib's}←2, c1, opcode[014'b];{0C}
STK ← MDR ← TOSH, TOSH{iVar} ← Q -6, BRANCH[Cont1, SCar1, 1], c2;
Cont1: {rhTT ← DEFspace}, c3;
fnIV:{ {fix for 16 bit atoms}
Xbus ← ibNA, XLDisp, c1;
BRANCH[FNLoDef, FNHiDef, 1], c2;
FNLoDef: rhTT ← DEFspace, GOTO[fnIVnext], c3;
FNHiDef: rhTT ← DEFspaceHi, GOTO[fnIVnext], c3;
}
{iVar (new) stored as end of old frame}{High half of S to match Q}{Q: Sev; TOSH: iVar(new)}
fnIVnext:
MAR ← [rhPV, PV - 6], c1;
MDR ← TOSH{iVar}, TT ← ib, BRANCH[$, SCar6, 1], c2;
SC6Cont: TT ← TT LRot8, c3;
fnS: {Flush top of stack} {Q: S even}{High half of S to match Q}
MAR ← Q ← [rhS, Q+1],{High half of S to match Q} c1; {Q ← odd}
MDR ← TOS, S ← Q + 2, CANCELBR[$, 2], WriteOK, c2;
TT ← TT or ib {LShift1,}{% dont lose msb yet} c3;
{fix for 16 bit atoms}
uTT ← TT, NegBr, c1;
TT ← LShift1 TT, SE ← 1, BRANCH[FNLoDef, FNHiDef], c2;
FNLoDef: rhTT ← DEFspace, GOTO[fnMD], c3;
FNHiDef: rhTT ← DEFspaceHi, GOTO[fnMD], c3;
{***********************}
fnMD: {MapDef; rhTT,TT{FunDef+1} S{oddEmpty} L3{ib's} PV.iVar=TOSH{iVar} PC:+0}
{uTT ←}{% 64K}{FunDef}TT ← Map ← [rhTT{FunDefs}, TT - 1], L0 ← L0.FCRedo, c1;
TOS ← UvCL, L1 ← L1.FC, c2;
uIVar ← TOSH, Rx ← rhRx ← MD, ReadXRefBr, c3;
{Get def cell high}
MAR ← [rhRx, TT + 0], ReadBRANCH[FCMap, $], c1, at[L0.FCRedo, 10,RMapFixCaller];
Q ← PC and 0FF, L1 ← L1.FCH, c2;
Q ← Q - TOS{UvCL}, rhTT{UvChighL} ← MD, XHDisp{compiled?}, c3;
fnD0: {Get def cell low}
MAR ← [rhRx, TT+1], BRANCH[interpret, $, 2], c1;
Rx{uStkLimO} ← uStkLimO, CANCELBR[$, 2], L0 ← L0.FCHRedo, c2;
uPC ← PC, TT{UvCL} ← MD, L3Disp{deltaPC}, c3;
fnMH: {Map function header}
Map ← [rhTT, TT], BRANCH[incPC1, incPC2, 0E], c1;
incPC1: uTOS{savUvCL} ← TOS, TOS{pc} ← Q + PC16, GOTO[jMH], c2;
incPC2: uTOS{savUvCL} ← TOS, TOS ← Q + 1, GOTO[jMH], c2;
jMH: uTOSH{iVar} ← TOSH, PC ← rhPC ← MD, ReadXRefBr, c3;
{Fetch function header 0} {S: odd, empty}
FCHred: MAR ← Q ← [rhPC, TT + 0], L1 ← L1.FCH, ReadBRANCH[FCHMap, $], c1{, at[L0.FCHRedo, 10,RMapFixCaller]};
TOSH{args} ← RShift1 (S-TOSH{iVar}-1), SE←0, c2;
UvCL ← TT, TT{stk} ← MD, c3;
fnH1: {Fetch function header 1} {TOSH{args} non-neg}
MAR ← PC ← [rhPC, Q + 1], c1;
Q{stkNeed} ← TT{stk} + S, CANCELBR[$, 2], c2;
TT{na} ← MD, XHDisp, GOTO[fnH2], c3;
fnH2: {Regs: TOSH{args}, TOS{PC-UvCL}, Rx{uStkLim0}, Q{stkNeed}, TT{na}, PC{header}, PV{pv}, S{s} }
MAR ← [rhPC, PC + 1], BRANCH[$, LamStar, 2], c1;
Ybus ← Rx{uStkLim0} - Q{stkNeed}, CarryBr, CANCELBR[$, 2], c2;
Rx{pv#} ← MD, XHDisp, BRANCH[FnStkOvr, fnH3], c3;
fnH3: {Fetch function header 3}
MAR ← [rhPC, PC + 2], L0←2, BRANCH[h30, h31, 2], c1;
h30: TOSH{wdsXtr+1} ← TOSH{args} - TT{na} LShift1, SE←1, NegBr, CANCELBR[h4, 2], c2;
h31: TOSH{wdsXtr+1} ← TOSH{args} - TT{na} LShift1, SE←1,NegBr, CANCELBR[h4, 2], c2;
h4: Q{start} ← MD, BRANCH[enough, grow], c3;
grow: {grow the stack if necessary}
MAR ← [rhS, S-1], c1;
MDR ← TT ← 0, CANCELBR[$, 2], WriteOK, c2;
TOSH ← TOSH + 1, c3;
fnG: MAR ← S ← [rhS, S+0], c1;
MDR←TT{zero}, TOSH{wdsXtr}←TOSH+1, NegBr, c2;
S ← S+2, BRANCH[enough, grow], c3;
{(N) trim stack and push uBFmark (once was nargs)} {TOSH{argsXtr} non-neg}
enough: MAR ← S ← [rhS, S - TOSH{wdsXtr+1}], c1;
FnNCont: MDR ← uBFmark, BRANCH[$, FnNCar, 1], c2;
TOSH{UvPCpageLOld} ← UvPCpageL, c3;
fnB: {push IVar)}
MAR ← S ← [rhS, S+1], c1;
MDR ← uIVar, CANCELBR[$, 2], WriteOK, c2;
S ← S+1, c3;
fnF: {push uFXmark}
MAR ← S ← [rhS, S+0], L3Disp{deltaPC}, c1;
MDR ← uFXmark, BRANCH[pcInc0, pcInc2, 0D], WriteOK, c2;
pcInc0: TOSH{pc} ← TOSH{UvPCpageLOld} + TOS{PC+UvCL}, NegBr, GOTO[savPv], c3;
pcInc2: TOSH{pc} ← TOSH{UvPCpageLOld} + TOS{PC+UvCL}+1, NegBr, GOTO[savPv], c3;
savPv: {Alink ← oldPvar}
MAR ← S ← [rhS, S+1], BRANCH[$, NegPcError], c1;
MDR ← PV{old}, S ← S+1, CANCELBR[$, 2], WriteOK, c2;
TOS{start-1} ← (Q{start} - 1) RShift1, SE←0, c3;
{(P) Clear PC16, Store relative byte PC = 2*[UvPCpageL-UvCL+(PC and 0FF)]+PC16}
{ MD TOS ← UvCL, }
{ D: Q ← PC and 0FF, }
{ Q{PC-UvCL} ← Q - TOS, }
{ MH TOS{PC-UvCL} ← Q + PC16 {+PC16}, }
{ N: TOSH ← UvPCpageL, }
{ F: TOSH{relWdPC} ← TOSH{UvPCpageL} + TOS{PC-UvCL} {+ 1}, }
{ MDR ← TOSH + TOSH + pc16, }
fnP: MAR{PC} ← PV ← [rhPV, PV - 5], c1;
MDR ← TOSH ← TOSH{pc}+TOSH+PC16, BRANCH[$, FnPCar, 1], c2;
FnPCont: PV{new} ← S + 8{empty fields}, XC2npcDisp, c3;
fnC: {push code base low}
MAR ← [rhS, S+0], IB ← 6{constant}, BRANCH[fnPcOdd, fnPcEv, 0E], c1;
fnPcOdd: MDR ← TOSH ← UvCL, GOTO[fnC0], Cin←pc16, c2;
fnPcEv: MDR ← TOSH ← UvCL, GOTO[fnC0], c2;
fnC0: TOSH{UvPCpageL} ← TOSH and ~0FF, c3;
fnC1: {push code base high}
MAR ← Q ← [rhS, S+1], IBPtr ← 1, L0Disp{pv# zero}, c1;
MDR ← TT ← rhTT, WriteOK, BRANCH[plp, plpD, 0E], c2;
plpD: UvChighL ← TT, S ← Q{S} + ib{6} + 1, GOTO[loopDone], c3;
plp: UvChighL ← TT, S ← Q{S} + ib{6} + 1, {room for next, PC, nameTable, Blink and, Clink} c3;
{(V) push #pvar unbound pointers}
loopP: MAR ← S ← [rhS, S+0], c1;
MDR ← TT{ones}← ~TT xor TT, c2;
S ← S + 2, c3;
MAR ← S ← [rhS, S+0], c1;
MDR ← TT{ones},Rx{pv#}←Rx-1, NegBr, c2;
S ← S + 2, BRANCH[loopP, loopDone], c3;
{(F) start fetch from the byte PC, PC16 cleared previously}
loopDone: MAR ← PC ← [rhPC, PC{+1} + TOS{start-1}], c1;
S ← S + 1, BRANCH[$, CCross,1], c2;
UvPCpageL ← TOSH, IB ← MD, c3;
MAR ← [rhPC, PC + 1], IBPtr←0, L2 ← L2.0, c1;
AlwaysIBDisp, TOSH ← 0, L0← L0.NERefill.Set, DISP2[NoRCross], c2;
CCross: UvPCpageL ← TOSH, c3;
TOSH ← 0, c1;
Noop, c2;
Q ← 0FF + 1, L0 ← L0.JRemap, GOTO[UpdatePC], c3;
{2 more clicks}
{exceptions:}
SCar1: Noop, c3;
Noop, c1;
TOSH ← TOSH + 0FF + 1, {derived from Q} c2;
S ← S + 1, {High half of S to match Q} c3;
MAR ← Q ← [rhS, S + 0], c1;
MDR ← STK, GOTO[Cont1], c2;
SCar5: S ← Q + 0FF + 1, c3;
MAR ← Q ← [rhS, S + 0],{High half of S to match Q} c1;
MDR ← TOSH, {S ← S - 1,}{High half of S to match Q} GOTO[Cont5], c2;
NegPcError: Q ← 13'd, CANCELBR[sink3, 3], c2;{MP9013}
FNXCross: uPCCrossL ← (~TT xor TT), c3;
TOSH ← Q - TOSH, c1;
uRx{savQ} ← Q, c2;
Q ← 0FF + 1, {GOTO[UpdatePC],} {L1 = L1.FNX,} c3;
{FNXCross1:}{UpdatePC:}
TT ← UvPCpageL, GOTO[UpdatePC2], c1;
{FCross:} {UpdatePC returns here}
Rx ← rhRx ← MD, ReadXRefBr, c3, at[L0.RefillFNX,10,ECross];
MAR ← [rhRx, PC + 2], ReadBRANCH[FXMapUD, $], c1, at[L0.RefillFNX,10,RMapFixCaller];
Q ← uRx{SavQ}, {rhTT ← DEFspace,} CANCELBR[$,2], c2;
IB ← MD, L3{ib's}←3, GOTO[fnIV], c3;
{ Q ← uRx{SavQ}, c1;
c2;
GOTO[fnIV],c3;
}
FXMapUD: Noop, CANCELBR[RLMapFix, 3], {returns at FXRedo} c2;
FXFix: TOSH ← STK, GOTO[NoMoreFix], c1, at[L1.FNX,10,Fix];
SCar6: STK ← PV, PV ← PV - 6, c3;
MAR ← [rhPV, PV + 0], c1;
MDR ← TOSH, PV ← STK, GOTO[SC6Cont], c2;
SCar9: STK ← PV, PV ← PV - 6, c3;
MAR ← [rhPV, PV + 0], c1;
MDR ← TOSH, PV ← STK, GOTO[SC9Cont], c2;
FnNCar: S ← S -0FF - 1, c3;
MAR ← [rhS, S + 0], GOTO[FnNCont], c1;
FnPCar: PV ← PV -0FF - 1, c3;
MAR ← [rhPV, PV + 0], c1;
MDR ← TOSH, GOTO[FnPCont], c2;
{S odd empty}
interpret: TOS{atm} ← uTT, CANCELBR[$, 2], c2;
TT ← 0FF + 1{400=AT.INTERPRETER%}, c3;
{interpret: TT ← 0FF + 1{400=AT.INTERPRETER%}, CANCELBR[$, 2], c2;
TOS{UvCL} ← MD, c3;}
interpret1: MAR ← [rhS, S - 1], c1;
MDR ← 0{rhTT}, CANCELBR[$, 2], WriteOK, c2;
interpret3: uTT ← TT, TT ← LShift1 TT, SE ← 1, NegBr, c3;
MAR ← [rhS, S + 0], BRANCH[$, intDefhi], c1;
MDR ← TOS{atm}, rhTT ← DEFspace, c2;
intDEFdone:
S ← S + 2, GOTO[fnMD], c3;
intDefhi:
MDR ← TOS{atm}, rhTT ← DEFspaceHi, GOTO[intDEFdone], c2;
LamStar: TT{na} ← TOSH{args}, CANCELBR[$, 2], c2;
Noop, GOTO[fnH2], {try again} c3;
FCMap: CANCELBR[RLMapFix, 3], c2;
FCHMap: Rx ← PC, CALL[RLMapFix], c2;
Noop, ReadCANCELBR[$], c1, at[L0.FCHRedo, 10,RMapFixCaller];
Rx{uStkLimO} ← uStkLimO, c2;
Xbus ← 3, XDisp, GOTO[FCHred], c3;
FnStkOvr: TOSH{iVar} ← uTOSH, CANCELBR[$, 3], c1;
TT{UvCL} ← uTOS, c2;
UvCL ← TT, c3;
Rx ← {0 -} SubovFXP, L3Disp{deltaPC}, GOTO[fchFix2], c1;
{*************************}
FCHFix: {preserves Rx:FXP#}
{Noop,} L3Disp{deltaPC}, c1, at[L1.FCH,10,Fix];
fchFix2: Noop, BRANCH[decPC1, decPC2, 0E], c2;
decPC1: PC ← uPC, GOTO[FCFix], Cin←pc16, c3;
decPC2: PC ← uPC, GOTO[FCFix], c3;
FCFix: L3Disp, c1, at[L1.FC,10,Fix];
TOS ← uTT, DISP4[PCdelt, 0C], c2;
PC ← PC + PC16, GOTO[FCFix1], c3, at[0C, 10, PCdelt];
PC ← PC + 1, GOTO[FCFix1], c3, at[0D, 10, PCdelt];
PC ← 1 + PC + PC16, GOTO[FCFix1], c3, at[0E, 10, PCdelt];
PC ← PC + 2, GOTO[FCFix1], c3, at[0F, 10, PCdelt];
FCFix1: MAR ← [rhS, S - 1], c1;
MDR ← smallpl, CANCELBR[$, 2], WriteOK, c2;
TOSH{args} ← RShift1 (S-TOSH{iVar}-1), SE←0, c3;
MAR ← [rhS, S + 0], c1;
MDR ← TOSH{args}, TOSH ← 0, L2 ← 1{InCall}, c2;
TOS ← TOS RShift1, GOTO[PuntFor], c3;
{ E N D }