DIRECTORY
Alloc USING [Notifier],
Basics USING [bitsPerWord, LongNumber],
Code USING [CodeNotImplemented, curctxlvl, stking],
CodeDefs USING [Base, BoVarIndex, Byte, codeType, Lexeme, NullLex, StackIndex, StackLocRec, TempAddr, VarComponent, VarIndex, VarNull],
PrincOps USING [FieldDescriptor, framelink, localbase],
FOpCodes USING [qADD, qAMUL, qAND, qBLT, qBLTC, qBLTCL, qBLTL, qDADD, qLI, qLL, qLLK, qLP, qMUL, qPUSH, qR, qRFC, qSHIFT],
LiteralOps USING [FindDescriptor],
Literals USING [Base, LTIndex, ltType],
P5 USING [MoveToCodeWord, WriteCodeWord],
P5L USING [AllLoaded, CopyToTemp, CopyVarItem, EasilyLoadable, FieldOfVar, GenVarItem, LoadComponent, LoadVar, LongVarAddress, ModComponent, OVarItem, ReleaseVarItem, ReusableCopies, StackSpareAddr, StoreVar, TOSComponent, TOSLex, VarAddressEasy, VarAlignment],
P5U USING [Out0, Out1, Out2, RecordConstant],
Stack USING [Above, Also, Forget, Load, Loc, Pop, TempStore, Top],
Symbols USING [Base, ContextLevel, ctxType, lG, lZ, seType];

VarBasics: PROGRAM
IMPORTS CPtr: Code, LiteralOps, P5, P5U, P5L, Stack
EXPORTS P5L, CodeDefs =
BEGIN OPEN FOpCodes, CodeDefs, Symbols;

wordlength: CARDINAL = Basics.bitsPerWord;

cb: CodeDefs.Base;
seb, ctxb: Symbols.Base;
ltb: Literals.Base;

VarBasicsNotify: PUBLIC Alloc.Notifier =
BEGIN  -- called by allocator whenever table area is repacked
seb _ base[Symbols.seType];
ctxb _ base[Symbols.ctxType];
cb _ base[codeType];
ltb _ base[Literals.ltType];
END;

AddrComponent: PUBLIC PROC [var: VarComponent] RETURNS [avar: VarComponent] =
BEGIN
WITH vv: var SELECT FROM
code => RETURN [[wSize: 1, space: caddr[wd: vv.wd]]];
frame => RETURN [[wSize: 1, space: faddr[level: vv.level, wd: vv.wd]]];
frameup =>
BEGIN
base: VarComponent =
[wSize: vv.pwSize, space:
frame[wd: vv.wd, level: vv.level, immutable: vv.immutable]];
IF vv.delta = 0 THEN RETURN [base];
P5L.LoadComponent[base];
GenAdd[vv.delta, base.wSize > 1];
RETURN [P5L.TOSComponent[base.wSize]]
END;
linkup =>
BEGIN
IF vv.delta = 0 THEN RETURN [[wSize: 1, space: link[wd: vv.wd]]];
P5U.Out1[qLLK, vv.wd];
GenAdd[vv.delta];
RETURN [P5L.TOSComponent[1]]
END;
stack =>
IF vv.wd = 0 THEN
BEGIN
loc: StackLocRec = Stack.Loc[vv.sti, var.wSize];
WITH loc SELECT FROM
inTemp =>
BEGIN
Stack.Forget[vv.sti, var.wSize];
RETURN [[wSize: 1, space: faddr[level: tLevel, wd: tOffset]]]
END;
ENDCASE;
END;
caddr => ERROR; -- nobody should be taking the address of a code address
ENDCASE; -- faddr, link, const, pdesc
RETURN [AddrComponent[P5L.CopyToTemp[P5L.OVarItem[var]].var]]
END;

AddrForVar: PUBLIC PROC [r: VarIndex, codeOk: BOOL _ FALSE]
RETURNS [avar: VarComponent] =
BEGIN
WITH cc: cb[r] SELECT FROM
o => 
BEGIN
IF ~codeOk AND cc.var.tag = code THEN ERROR;
avar _ AddrComponent[cc.var];
END;
bo =>
BEGIN
WITH oo: cc.offset SELECT FROM
frame => IF oo.level = lZ AND oo.wd = 0 THEN avar _ cc.base
ELSE WITH vv: cc.base SELECT FROM
faddr => {vv.wd _ vv.wd + oo.wd; avar _ vv};
ENDCASE => GO TO loadIt;
code => IF codeOk AND oo.wd = 0 THEN avar _ cc.base
ELSE GO TO loadIt;
ENDCASE => ERROR;
END;
ENDCASE => GO TO loadIt;
P5L.ReleaseVarItem[r];
EXITS
loadIt =>
BEGIN
long: BOOL = LoadAddress[r, codeOk];
avar _ P5L.TOSComponent[IF long THEN 2 ELSE 1];
END;
END;

BaseComponent: PUBLIC PROC [lvl: ContextLevel] RETURNS [VarComponent] =
BEGIN
IF lvl >= CPtr.curctxlvl THEN ERROR;
IF lvl + 1 = CPtr.curctxlvl THEN
RETURN [[wSize: 1, space: frame[
immutable: TRUE, 
wd: PrincOps.framelink,
level: CPtr.curctxlvl]]];
P5U.Out1[qLL, PrincOps.framelink];
THROUGH (lvl..CPtr.curctxlvl) DO
P5U.Out1[qR, PrincOps.framelink - PrincOps.localbase];
ENDLOOP;
RETURN [P5L.TOSComponent[1]]
END;

GenAdd: PUBLIC PROC [delta: UNSPECIFIED, long: BOOL _ FALSE] =
BEGIN
n: [1..2] = IF long THEN 2 ELSE 1;
Stack.Load[Stack.Top[n],n];
P5U.Out1[qLI, LOOPHOLE[delta, CARDINAL]];
IF long THEN P5U.Out1[qLI, 0];
P5U.Out0[IF long THEN qDADD ELSE qADD];
END;

GenAnd: PUBLIC PROC [delta: UNSPECIFIED] =
BEGIN
P5U.Out1[qLI, LOOPHOLE[delta, CARDINAL]];
P5U.Out0[qAND];
END;

GenRFC: PUBLIC PROC [wd: CARDINAL, bd: [0..16), len: [1..16]] =
BEGIN
IF wd > Byte.LAST THEN {GenAdd[wd-Byte.LAST]; wd _ Byte.LAST};
P5U.Out2[qRFC, wd,
LOOPHOLE[PrincOps.FieldDescriptor[offset: 0, posn: bd, size: len]]];
END;

GenShift: PUBLIC PROC [delta: UNSPECIFIED] =
BEGIN
P5U.Out1[qLI, delta];
P5U.Out0[qSHIFT];
END;

LoadAddress: PUBLIC PROC [r: VarIndex, codeOk: BOOL _ FALSE]
RETURNS [long: BOOL] =
BEGIN
bor: BoVarIndex;
base, offset: VarComponent;
owd: CARDINAL;
WITH cc: cb[r] SELECT FROM
o =>
BEGIN
avar: VarComponent _ AddrComponent[cc.var];
IF avar.tag = caddr AND ~codeOk THEN ERROR;
P5L.LoadComponent[avar];
P5L.ReleaseVarItem[r];
RETURN [FALSE]
END;
ENDCASE;
bor _ MakeBo[r]; 
IF bor = VarNull THEN SIGNAL CPtr.CodeNotImplemented;
base _ cb[bor].base; offset _ cb[bor].offset;
P5L.ReleaseVarItem[bor];
long _ Words[base.wSize, base.bSize] > 1;
WITH oo: offset SELECT FROM
frame =>
BEGIN
IF oo.level # lZ THEN ERROR CPtr.CodeNotImplemented;
owd _ oo.wd;
END;
code =>
BEGIN
IF ~codeOk OR long THEN ERROR;
owd _ oo.wd;
END;
ENDCASE => ERROR;
WITH vv: base SELECT FROM
faddr => IF vv.wd + owd IN Byte THEN
BEGIN
vv.wd _ vv.wd + owd;
owd _ 0;
END;
ENDCASE;
P5L.LoadComponent[base];
IF owd # 0 THEN GenAdd[owd, long];
END;

LoadBoth: PUBLIC PROC [atC1, atC2: POINTER TO VarComponent, abelian: BOOL] =
BEGIN
c1: VarComponent _ atC1^;
c2: VarComponent _ atC2^;
c1Loaded, c2Loaded: BOOL _ FALSE;
c1Depth, c2Depth: CARDINAL;
c1Size: CARDINAL = Words[c1.wSize, c1.bSize];
c2Size: CARDINAL = Words[c2.wSize, c2.bSize];
WITH cc: c1 SELECT FROM
stack => IF cc.bd = 0 AND c1.bSize = 0 THEN
BEGIN
loc: StackLocRec = Stack.Loc[cc.sti, c1Size];
WITH loc SELECT FROM
onStack => {c1Depth _ depth; c1Loaded _ TRUE};
ENDCASE;
END;
ENDCASE;
WITH cc: c2 SELECT FROM
stack => IF cc.bd = 0 AND c2.bSize = 0 THEN
BEGIN
loc: StackLocRec = Stack.Loc[cc.sti, c2Size];
WITH loc SELECT FROM
onStack => {c2Depth _ depth; c2Loaded _ TRUE};
ENDCASE;
END;
ENDCASE;
BEGIN -- to set up loadBoth label
IF ~(c1Loaded OR c2Loaded) THEN GO TO loadBoth;
IF c1Loaded AND c2Loaded THEN
IF (c1Depth = c2Size AND c2Depth = 0) OR
(abelian AND c2Depth = c1Size AND c1Depth = 0) THEN RETURN
ELSE GO TO loadBoth; -- considered unlikely
IF c1Loaded THEN
BEGIN
IF c1Depth # 0 THEN P5L.LoadComponent[c1];
P5L.LoadComponent[c2];
END
ELSE -- c2Loaded
BEGIN
IF c2Depth # 0 THEN {P5L.LoadComponent[c2]; c2 _ P5L.TOSComponent[c2Size]};
IF ~abelian AND (c1Size>1 OR c2Size>1) THEN c2 _ Stack.TempStore[c2Size];
P5L.LoadComponent[c1];
IF ~abelian THEN P5L.LoadComponent[c2];
END;
EXITS
loadBoth => {P5L.LoadComponent[c1]; P5L.LoadComponent[c2]};
END;
END;

LoadSum: PUBLIC PROC [atB, atD: POINTER TO VarComponent] RETURNS [bpSize: [1..2]] =
BEGIN
base, disp: VarComponent;
dpSize: [1..2];

BDCommute: PROC =
BEGIN
t: VarComponent = base;
i: CARDINAL _ bpSize;
base _ disp; disp _ t;
bpSize _ dpSize; dpSize _ i;
END;

base _ atB^; disp _ atD^;
bpSize _ Words[base.wSize, base.bSize];
dpSize _ Words[disp.wSize, disp.bSize];
BEGIN -- to set up "different" exit label
SELECT bpSize FROM
> dpSize => GO TO different;
< dpSize => {BDCommute[]; GO TO different};
ENDCASE => LoadBoth[@base, @disp, TRUE];
EXITS
different =>
BEGIN
P5L.LoadComponent[disp];
P5U.Out1[qLI, 0]; --lengthen disp
disp _ P5L.TOSComponent[2];
LoadBoth[@base, @disp, TRUE];
END;
END;
P5U.Out0[IF bpSize = 1 THEN qADD ELSE qDADD];
RETURN
END;

MakeBo: PUBLIC PROC [r: VarIndex] RETURNS [bor: BoVarIndex] =
BEGIN
base, disp, offset: VarComponent;
bpSize: [1..2];
WITH cb[r] SELECT FROM
bo => RETURN [LOOPHOLE[r]];
ENDCASE;
bor _ LOOPHOLE[P5L.GenVarItem[bo]];
cb[bor] _ [body: bo[base: TRASH, offset: TRASH]]; -- set tag
WITH cc: cb[r] SELECT FROM
o => 
BEGIN
var: VarComponent _ cc.var;
P5L.ReleaseVarItem[r];
WITH vv: var SELECT FROM
frameup =>
BEGIN
cb[bor].base _
[wSize: vv.pwSize, space:
frame[wd: vv.wd, level: vv.level, immutable: vv.immutable]];
cb[bor].offset _ [wSize: var.wSize, space: frame[wd: vv.delta]];
RETURN
END;
linkup =>
BEGIN
cb[bor].base _ [wSize: 1, space: link[wd: vv.wd]];
cb[bor].offset _ [wSize: var.wSize, space: frame[wd: vv.delta]];
RETURN
END;
code => cb[bor].offset _ [wSize: TRASH, bSize: TRASH, space: code[bd: vv.bd]];
frame => cb[bor].offset _ [wSize: TRASH, bSize: TRASH, space: frame[bd: vv.bd]];
stack => cb[bor].offset _ [wSize: TRASH, bSize: TRASH, space: frame[bd: vv.bd]];
const =>
BEGIN
wS: CARDINAL = Words[var.wSize, var.bSize];
IF wS = 1 THEN 
cb[bor].offset _ -- can't index packed in code anyway
[wSize: TRASH, bSize: TRASH, space: frame[bd: vv.bd]]
ELSE
BEGIN -- wS = 2
const: ARRAY [0..1] OF CARDINAL _ [vv.d1, vv.d2];
lti: Literals.LTIndex = LiteralOps.FindDescriptor[DESCRIPTOR[const]].lti;
cb[bor].offset _ [wSize: TRASH, bSize: TRASH, space: code[bd: vv.bd]];
WITH ll: ltb[lti] SELECT FROM
long =>
BEGIN
IF ll.codeIndex = 0 THEN
BEGIN
ll.codeIndex _ P5.MoveToCodeWord[];
P5.WriteCodeWord[const[0]]; P5.WriteCodeWord[const[1]];
P5U.RecordConstant[ll.codeIndex, 2];
END;
var _ [wSize: 2, space: code[wd: ll.codeIndex]];
END;
ENDCASE => ERROR;
END;
END;
ENDCASE => ERROR;
cb[bor].base _ AddrComponent[var];
cb[bor].offset.wSize _ var.wSize;
cb[bor].offset.bSize _ var.bSize;
RETURN
END;
bdo => {disp _ cc.disp; base _ cc.base; offset _ cc.offset};
ind =>
BEGIN
eWords: CARDINAL;
base _ cc.base;
disp _ cc.index;
offset _ cc.offset;
WITH pp: cc SELECT FROM
packed => {P5L.ReleaseVarItem[bor]; RETURN [LOOPHOLE[VarNull]]};
notPacked => eWords _ pp.eWords;
ENDCASE;
IF eWords # 1 THEN
BEGIN
WITH vv: disp SELECT FROM
const =>
BEGIN
ld: Basics.LongNumber;
ld.lc _ CARDINAL[vv.d1].LONG * eWords.LONG;
vv.d1 _ ld.lowbits;
IF ld.highbits # 0 THEN {vv.wSize _ 2; vv.d2 _ ld.highbits};
GO TO const;
END;
ENDCASE;
P5L.LoadComponent[disp];
P5U.Out1[qLI, eWords];
IF cc.simple THEN
BEGIN
P5U.Out0[qMUL];
disp _ P5L.TOSComponent[1];
END
ELSE
BEGIN
P5U.Out0[qAMUL];
P5U.Out0[qPUSH];
disp _ P5L.TOSComponent[2];
END;
EXITS
const => NULL;
END;
END;
ENDCASE;
P5L.ReleaseVarItem[r];
WITH vv: disp SELECT FROM
const => IF vv.wSize = 1 AND vv.bSize = 0 THEN
BEGIN
ld: Basics.LongNumber;
owd: CARDINAL;
WITH oo: offset SELECT FROM
frame => owd _ oo.wd;
code => owd _ oo.wd;
ENDCASE => ERROR;
ld.lc _ owd.LONG + CARDINAL[vv.d1].LONG;
IF ld.highbits = 0 THEN
BEGIN
P5L.ModComponent[var: @offset, wd: vv.d1];
cb[bor].base _ base;
cb[bor].offset _ offset;
RETURN
END;
END;
ENDCASE;
bpSize _ LoadSum[@base, @disp];
cb[bor].base _ P5L.TOSComponent[bpSize];
cb[bor].offset _ offset;
END;

MakeComponent: PUBLIC PROC [r: VarIndex, allowFields: BOOL _ FALSE]
RETURNS [var: VarComponent] =
BEGIN
wS: CARDINAL;
WITH cc: cb[r] SELECT FROM
o => {var _ cc.var; GO TO freer};
bo =>
BEGIN
WITH oo: cc.offset SELECT FROM
code =>
WITH bb: cc.base SELECT FROM
caddr => 
BEGIN
var _ [wSize: cc.offset.wSize, bSize: cc.offset.bSize,
space: code[wd: bb.wd + oo.wd, bd: oo.bd]];
GO TO freer;
END;
ENDCASE;
frame => 
WITH bb: cc.base SELECT FROM
faddr => SELECT bb.level FROM
lG, CPtr.curctxlvl => 
BEGIN
var _ [
wSize: cc.offset.wSize, bSize: cc.offset.bSize,
space: frame[level: bb.level, wd: bb.wd + oo.wd, bd: oo.bd]];
GO TO freer;
END;
ENDCASE;
frame => IF ~allowFields AND cc.base.bSize = 0
AND cc.base.wSize IN [1..2] AND cc.offset.bSize = 0
AND cc.offset.wSize = 1 AND oo.level = lZ THEN
BEGIN
var _ [
wSize: cc.offset.wSize, space: frameup[
level: bb.level, wd: bb.wd, pwSize: cc.base.wSize,
delta: oo.wd, immutable: bb.immutable]];
GO TO freer;
END;
link => IF ~allowFields AND cc.offset.bSize = 0
AND cc.offset.wSize IN [1..2] AND oo.level = lZ THEN
BEGIN
var _ [
wSize: cc.offset.wSize, space: linkup[wd: bb.wd, delta: oo.wd]];
GO TO freer;
END;
ENDCASE;
ENDCASE => ERROR;
wS _ Words[cc.offset.wSize, cc.offset.bSize];
END;
bdo => wS _ Words[cc.offset.wSize, cc.offset.bSize];
ind => wS _ Words[cc.offset.wSize, cc.offset.bSize];
ENDCASE;
IF wS > 2 THEN var _ P5L.CopyToTemp[r].var
ELSE {P5L.LoadVar[r]; var _ P5L.TOSComponent[wS]};
EXITS
freer => P5L.ReleaseVarItem[r];
END;

VarVarAssign: PUBLIC PROC [to, from: VarIndex, isexp: BOOL]
RETURNS [l: Lexeme] =
BEGIN
bSize, tbd: [0..wordlength);
wSize, wS: CARDINAL;
trashOnStack: CARDINAL _ 0;
l _ NullLex;
[bd: tbd, bSize: bSize, wSize: wSize] _ P5L.VarAlignment[to, store];
wS _ Words[wSize, bSize];
WITH cc: cb[from] SELECT FROM
o => WITH vv: cc.var SELECT FROM
stack => IF vv.wd # 0 THEN
IF isexp THEN
BEGIN
P5L.LoadVar[from]; -- causing from to be freed
from _ P5L.OVarItem[P5L.TOSComponent[wS]];
END
ELSE
BEGIN
tvar: VarComponent;
trashOnStack _ vv.wd;
vv.wd _ 0;
tvar _ cc.var; -- to avoid passing address of chunk
P5L.ModComponent[var: @tvar, wd: trashOnStack];
cc.var _ tvar;
END;
ENDCASE;
ENDCASE;
IF wS <= 2 THEN
BEGIN -- it's 2  words at most
alsoLink: BOOL _ FALSE;
tOffset: TempAddr;
tLevel: Symbols.ContextLevel _ Symbols.lZ;
IF ~P5L.AllLoaded[from] THEN  -- anything above it is part of "to"
BEGIN
P5L.LoadVar[from];
from _ P5L.OVarItem[P5L.TOSComponent[wS]];
END;
IF isexp THEN
BEGIN -- locate a backup site for stack model after PUSH
WITH cb[from] SELECT FROM
o => WITH vv: var SELECT FROM
stack => 
BEGIN
vsti: StackIndex = vv.sti;
WITH sv: cb[vsti] SELECT FROM
onStack =>
BEGIN
IF sv.alsoLink OR sv.tLevel # lZ THEN
BEGIN
nsti: StackIndex;
alsoLink _ sv.alsoLink;
tOffset _ sv.tOffset;
tLevel _ sv.tLevel;
IF wS = 1 THEN GO TO foundOne;
IF tLevel # lZ THEN
BEGIN
nsti _ Stack.Above[vsti];
WITH sv2: cb[nsti] SELECT FROM
onStack =>
IF sv2.tLevel = tLevel AND sv2.tOffset = tOffset+1 THEN
GO TO foundOne;
ENDCASE;
END;
alsoLink _ FALSE; tLevel _ lZ;
END;
END;
ENDCASE;
END;
ENDCASE;
ENDCASE;
WITH cb[to] SELECT FROM
o => WITH vv: var SELECT FROM
link => {alsoLink _ TRUE; tLevel _ vv.wd};
frame => IF vv.bSize = 0 AND vv.bd = 0 THEN
BEGIN
level: Symbols.ContextLevel = vv.level;
SELECT level FROM
lG, CPtr.curctxlvl => {tLevel _ level; tOffset _ vv.wd};
ENDCASE;
END;
ENDCASE;
ENDCASE;
EXITS
foundOne => NULL;
END;
P5L.ReleaseVarItem[from];
P5L.StoreVar[to];
IF isexp THEN
BEGIN
THROUGH [0..wS) DO P5U.Out0[qPUSH]; ENDLOOP;
IF (alsoLink OR tLevel # lZ) AND CPtr.stking THEN 
Stack.Also[n: wS, inLink: alsoLink, tOffset: tOffset, tLevel: tLevel];
l _ P5L.TOSLex[wS];
END;
END
ELSE IF P5L.AllLoaded[from] THEN
BEGIN -- large thing, all on stack
IF isexp THEN 
BEGIN
tr: VarIndex;
[first: to, next: tr] _ P5L.ReusableCopies[to, store, FALSE];
l _ [bdo[tr]];
END;
P5L.StoreVar[to];
END
ELSE IF bSize = 0 THEN
BEGIN
fromCode: BOOL;
longDest: BOOL _ P5L.LongVarAddress[to];
longSource: BOOL _ P5L.LongVarAddress[from];
sourceAddr, destAddr: VarComponent;
destInTemp: BOOL _ FALSE;
expBase: {unknown, source, dest} _ unknown;
BltOp: ARRAY BOOL OF ARRAY BOOL OF Byte =
[[qBLT, qBLTL], [qBLTC, qBLTCL]]; -- peephole will choke on BLTCL
WITH ff: cb[from] SELECT FROM
o => fromCode _ ff.var.tag = code;
bo => fromCode _ ff.offset.tag = code;
bdo => fromCode _ ff.offset.tag = code;
ind => fromCode _ ff.offset.tag = code;
ENDCASE => ERROR;
IF fromCode AND longDest THEN
BEGIN
tvar: VarComponent = P5L.CopyToTemp[from].var;
[] _ VarVarAssign[to: to, from: P5L.OVarItem[tvar], isexp: FALSE];
IF isexp THEN l _ [bdo[P5L.OVarItem[tvar]]];
RETURN -- trashOnStack = 0
END;
IF  isexp AND longDest = longSource AND P5L.VarAddressEasy[from]
AND ~P5L.VarAddressEasy[to] THEN expBase _ source;
IF longDest AND ~P5L.StackSpareAddr[to] THEN
BEGIN
[] _ LoadAddress[to];
destAddr _ Stack.TempStore[2];
destInTemp _ TRUE;
END;
sourceAddr _ AddrForVar[r: from, codeOk: TRUE];
IF longDest AND ~longSource THEN 
BEGIN
IF isexp THEN
BEGIN
sourceAddr _ P5L.EasilyLoadable[sourceAddr, store];
expBase _ source;
END;
P5L.LoadComponent[sourceAddr];
P5U.Out0[qLP];
END
ELSE P5L.LoadComponent[sourceAddr];
P5U.Out1[qLI, wSize];
IF ~destInTemp THEN destAddr _ AddrForVar[to];
IF longSource AND ~longDest THEN
BEGIN
IF isexp THEN
BEGIN
destAddr _ P5L.EasilyLoadable[destAddr, store];
expBase _ dest;
END;
P5L.LoadComponent[destAddr];
P5U.Out0[qLP];
longDest _ TRUE;
END
ELSE
BEGIN
IF isexp AND expBase = unknown THEN
BEGIN
destAddr _ P5L.EasilyLoadable[destAddr, store];
expBase _ dest;
END;
P5L.LoadComponent[destAddr];
END;
P5U.Out0[BltOp[fromCode][longDest]];
IF isexp THEN
BEGIN
tr: BoVarIndex = LOOPHOLE[P5L.GenVarItem[bo]];
SELECT expBase FROM
source => NULL;
dest => sourceAddr _ destAddr;
ENDCASE => ERROR;
cb[tr] _ [body: bo[base: sourceAddr, offset: TRASH]];
IF expBase = source AND fromCode THEN
cb[tr].offset _ [wSize: wSize, space: code[wd: 0]]
ELSE
cb[tr].offset _ [wSize: wSize, space: frame[wd: 0]];
l _ [bdo[tr]];
END;
END
ELSE
BEGIN
fMain, fNub: VarIndex;
tMain, tNub: VarIndex;
[first: fMain, next: fNub] _ P5L.ReusableCopies[from, store, TRUE];
[first: tMain, next: tNub] _ P5L.ReusableCopies[to, store, FALSE];
IF tbd = 0 THEN
BEGIN
tr: VarIndex _ tMain;
tMain _ tNub; tNub _ tr;
tr _ fMain; fMain _ fNub; fNub _ fMain;
END;
IF isexp THEN
l _ [bdo[P5L.CopyVarItem[tMain]]]; -- has been rendered reusable
IF tbd = 0 THEN
BEGIN
P5L.FieldOfVar[r: fMain, wSize: wSize];
P5L.FieldOfVar[r: fNub, wd: wSize, bSize: bSize];
P5L.FieldOfVar[r: tMain, wSize: wSize];
P5L.FieldOfVar[r: tNub, wd: wSize, bSize: bSize];
[] _ VarVarAssign[to: tNub, from: fNub, isexp: FALSE];
[] _ VarVarAssign[to: tMain, from: fMain, isexp: FALSE];
END
ELSE
BEGIN
IF tbd + bSize # wordlength THEN ERROR;
P5L.FieldOfVar[r: fMain, wSize: wSize, bd: bSize];
P5L.FieldOfVar[r: fNub, bSize: bSize];
P5L.FieldOfVar[r: tMain, wSize: wSize, bd: bSize];
P5L.FieldOfVar[r: tNub, bSize: bSize];
[] _ VarVarAssign[to: tMain, from: fMain, isexp: FALSE];
[] _ VarVarAssign[to: tNub, from: fNub, isexp: FALSE];
END;
END;
THROUGH [0..trashOnStack) DO Stack.Pop[]; ENDLOOP;
END;

Words: PUBLIC PROC [w, b: CARDINAL] RETURNS [CARDINAL] =
BEGIN
RETURN [w + ((b+15)/16)];
END;

END.

RVarBasics.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Sweet,  3-Sep-81 12:24:46
Satterthwaite, April 17, 1986 11:33:07 am PST
Maxwell, August 11, 1983 9:23 am
Russ Atkinson (RRA) March 6, 1985 11:33:10 pm PST
put it in a temp, generate addr of temp
"from" is a stack o varitem, see if it is alsotemp
otherwise, see if "to" is a friendly frame loc (doesn't
have to be immutable in this case
but it shouldn't be generated, anyway
vars are ragged on at most one end; i.e., if wSize # 0 and bSize # 0
then bd = 0 or bd+bSize = wordlength, also bd # 0 implies bSize # 0
Κe˜
codeš
œ™Kšœ
Οm
œ1™<Kš
œ™Kš
œ-™-K™ K™1—K˜š
Οk	˜	Kšœžœ˜Kšœžœ˜'Kšœžœ)˜3Kšœ	žœy˜‡
Kšœ	žœ)˜7Kšœ	žœl˜zKšœžœ˜"Kšœ	žœ˜'Kšœžœ!˜)Kšœžœό
˜…Kšœžœ$˜-Kšœžœ7˜BKšœžœ/˜<K˜—šœž˜Kšžœ,˜3Kšžœ˜Kšžœ
žœ˜'K˜Kšœžœ˜*K˜K˜K˜K˜K˜šœžœ˜(KšžœΟc6˜=K˜K˜K˜K˜Kšžœ
˜K˜—šΟn
œžœ
žœžœ˜MKš
ž˜šžœ	žœ
ž˜Kšœžœ'˜5Kšœ	žœ8˜G˜
Kš
ž˜˜˜K˜<——Kšžœžœ
žœ˜#K˜K˜!Kšžœ˜%Kšžœ
˜—˜	Kš
ž˜Kšžœžœ
žœ&˜AK˜K˜Kšžœ˜Kšžœ
˜—˜šžœž˜Kš
ž˜K˜0šžœžœ
ž˜˜	Kš
ž˜K˜ Kšžœ7˜=Kšžœ
˜—Kšžœ
˜—Kšžœ
˜——Kšœ	žœŸ8˜HKšžœŸ˜%—Kš
œ'™'Kšžœ7˜=Kšžœ
˜K˜—š
 
œžœ
žœžœžœ
˜;Kšžœ˜Kš
ž˜šžœžœ
ž˜˜Kš
ž˜Kšžœ	žœžœ
žœ
˜,K˜Kšžœ
˜—˜Kš
ž˜šžœžœ
ž˜šœ	žœžœžœ˜;šžœ
žœ
žœ
ž˜!K˜,Kšžœžœ
žœ˜——šœžœžœžœ˜3Kšžœ
žœ
žœ˜—Kšžœžœ
˜—Kšžœ
˜—Kšžœžœ
žœ˜—K˜š
ž˜˜	Kš
ž˜Kšœžœ˜$Kšœžœžœžœ˜/Kšžœ
˜——Kšžœ
˜K˜—š 
œžœ
žœžœ˜GKš
ž˜Kšžœžœ
žœ
˜$šžœž˜ šžœ˜ Kšœžœ˜K˜K˜——K˜"šžœž˜ K˜6Kšžœ
˜—Kšžœ˜Kšžœ
˜K˜—š œžœ
žœ	žœžœžœ˜>Kš
ž˜Kšœžœžœžœ˜"K˜Kšœžœžœ˜)Kšžœžœ˜Kšœ	žœžœžœ˜'Kšžœ
˜K˜—š œžœ
žœ	žœ˜*Kš
ž˜Kšœžœžœ˜)K˜Kšžœ
˜K˜—š œžœ
žœžœ˜?Kš
ž˜Kš
žœžœ
žœžœ
žœ˜>˜Kšžœ<˜D—Kšžœ
˜K˜—š œžœ
žœ	žœ˜,Kš
ž˜K˜K˜Kšžœ
˜K˜—š
 œžœ
žœžœžœ
˜<Kšžœžœ˜Kš
ž˜K˜K˜Kšœžœ
˜šžœžœ
ž˜˜Kš
ž˜K˜+Kšžœžœ	žœ
žœ
˜+K˜K˜Kšžœžœ
˜Kšžœ
˜—Kšžœ
˜—K˜Kšžœžœ
žœ˜5K˜-K˜K˜)šžœžœ
ž˜˜Kš
ž˜Kšžœžœ
žœ˜4K˜Kšžœ
˜—˜Kš
ž˜Kšžœ	žœžœ
žœ
˜K˜Kšžœ
˜—Kšžœžœ
˜—šžœ
žœ
ž˜šœ	žœ
žœž˜$Kš
ž˜K˜K˜Kšžœ
˜—Kšžœ
˜—K˜Kšžœ	žœ˜"Kšžœ
˜K˜—š œžœ
žœžœ
žœžœ˜LKš
ž˜K˜K˜Kšœžœžœ
˜!Kšœžœ
˜Kšœžœ˜-Kšœžœ˜-šžœžœ
ž˜šœ	žœžœž˜+Kš
ž˜K˜-šžœžœ
ž˜Kšœ(žœ˜.Kšžœ
˜—Kšžœ
˜—Kšžœ
˜—šžœžœ
ž˜šœ	žœžœž˜+Kš
ž˜K˜-šžœžœ
ž˜Kšœ(žœ˜.Kšžœ
˜—Kšžœ
˜—Kšžœ
˜—Kšžœ
Ÿ˜!Kš
žœžœžœ
žœ
žœ
˜/šžœ
žœ
ž˜šžœžœž˜(Kšœ	žœžœžœ
ž˜:—Kšžœ
žœ
žœŸ˜+—šžœ
ž˜Kš
ž˜Kšžœ
žœ˜*K˜Kš
ž˜—šžœ
Ÿ˜Kš
ž˜Kšžœ
žœ8˜KKšžœ
žœžœžœ˜IK˜Kšžœ
žœ˜'Kšžœ
˜—š
ž˜K˜;—Kšžœ
˜Kšžœ
˜K˜—š œžœ
žœžœ
žœžœ˜SKš
ž˜K˜K˜K˜š 	œžœ˜Kš
ž˜K˜Kšœžœ
˜K˜K˜Kšžœ
˜K˜—K˜K˜'K˜'Kšžœ
Ÿ#˜)šžœž˜Kšœžœ
žœ˜Kšœžœ
žœ˜+Kšžœžœ˜(—š
ž˜˜Kš
ž˜K˜KšœŸ˜!K˜Kšœžœ˜Kšžœ
˜——Kšžœ
˜Kšœ	žœžœžœ˜-Kš
ž˜Kšžœ
˜K˜—š œžœ
žœžœ˜=Kš
ž˜K˜!K˜šžœžœ
ž˜Kšœžœžœ˜Kšžœ
˜—Kšœžœ˜#Kšœžœ
žœŸ
˜<šžœžœ
ž˜˜Kš
ž˜K˜K˜šžœ	žœ
ž˜˜
Kš
ž˜˜˜K˜<——K˜@Kš
ž˜Kšžœ
˜—˜	Kš
ž˜K˜2K˜@Kš
ž˜Kšžœ
˜—Kšœ!žœ	žœ˜NKšœ"žœ	žœ˜PKšœ"žœ	žœ˜P˜Kš
ž˜Kšœžœ˜+šžœžœ
˜šœŸ$˜5Kšœžœ	žœ˜5——š
ž˜Kšžœ
Ÿ	˜Kšœžœžœ
žœ˜1Kšœ2ž
œ
˜IKšœžœ	žœ˜Fšžœžœ
ž˜˜Kš
ž˜šžœž˜Kš
ž˜K˜#K˜7K˜$Kšžœ
˜—K˜0Kšžœ
˜—Kšžœžœ
˜—Kšžœ
˜—Kšžœ
˜—Kšžœžœ
˜—K˜"K˜!K˜!Kš
ž˜Kšžœ
˜—K˜<˜Kš
ž˜Kšœžœ
˜K˜K˜K˜šžœžœ
ž˜Kšœ$žœžœ˜@K˜ Kšžœ
˜—šžœž˜Kš
ž˜šžœ
žœ
ž˜˜Kš
ž˜K˜Kšœžœžœ
žœ
˜+K˜Kšžœžœ%˜<Kšžœ
žœ˜Kšžœ
˜—Kšžœ
˜—K˜K˜šžœž˜Kš
ž˜K˜K˜Kš
ž˜—š
ž˜Kš
ž˜K˜K˜K˜Kšžœ
˜—š
ž˜Kšœ	žœ
˜—Kšžœ
˜—Kšžœ
˜—Kšžœ
˜—K˜šžœ
žœ
ž˜šœ	žœžœž˜.Kš
ž˜K˜Kšœžœ
˜šžœžœ
ž˜K˜K˜Kšžœžœ
˜—Kšœžœžœžœ
˜(šžœž˜Kš
ž˜K˜*K˜K˜Kš
ž˜Kšžœ
˜—Kšžœ
˜—Kšžœ
˜—K˜K˜(K˜Kšžœ
˜K˜—š
 
œžœ
žœžœžœ
˜CKšžœ˜Kš
ž˜Kšœžœ
˜
šžœžœ
ž˜Kšœžœ
žœ˜!˜Kš
ž˜šžœžœ
ž˜˜šžœ
žœ
ž˜˜	Kš
ž˜˜6K˜+—Kšžœ
žœ˜Kšžœ
˜—Kšžœ
˜——˜	šžœ
žœ
ž˜šœ	žœ
ž˜˜Kš
ž˜˜K˜/K˜=—Kšžœ
žœ˜Kšžœ
˜—Kšžœ
˜—šœ	žœžœ˜.Kšžœžœžœ˜3šžœžœž˜.Kš
ž˜˜˜'K˜2K˜(——Kšžœ
žœ˜Kšžœ
˜——šœžœžœ˜/šžœžœžœž˜4Kš
ž˜˜K˜@—Kšžœ
žœ˜Kšžœ
˜——Kšžœ
˜——Kšžœžœ
˜—K˜-Kšžœ
˜—K˜4K˜4Kšžœ
˜—Kšžœžœ˜*Kšžœ.˜2š
ž˜K˜—Kšžœ
˜K˜—š œžœ
žœžœ
˜;Kšžœ˜Kš
ž˜K˜Kšœžœ
˜Kšœžœ˜K˜K˜DK˜šžœžœ
ž˜šœžœžœ
ž˜ šœ	žœž˜šžœž˜
Kš
ž˜KšœŸ˜.K˜*Kš
ž˜—š
ž˜Kš
ž˜K˜K˜K˜
KšœŸ$˜3K˜/K˜Kšžœ
˜——Kšžœ
˜—Kšžœ
˜—šžœ	ž˜Kšžœ
Ÿ˜Kšœ
žœžœ
˜K˜K˜*šžœžœŸ$˜BKš
ž˜K˜K˜*Kšžœ
˜—šžœž˜
Kšžœ
Ÿ2˜8Kš
œ2™2Kš
œ7™7Kš
œ!™!šžœ
žœ
ž˜šœžœ	žœ
ž˜˜	Kš
ž˜K˜šžœžœ
ž˜˜
Kš
ž˜šžœ
žœž˜%Kš
ž˜K˜K˜K˜K˜Kšžœžœ
žœ
žœ
˜šžœ
ž˜Kš
ž˜K˜šžœžœ
ž˜˜
šžœžœž˜7Kšžœ
žœ
˜——Kšžœ
˜—Kšžœ
˜—Kšœžœ˜Kšžœ
˜—Kšžœ
˜—Kšžœ
˜—Kšžœ
˜—Kšžœ
˜—Kšžœ
˜—šžœžœ
ž˜šœžœ	žœ
ž˜Kšœžœ˜*šœ	žœžœž˜+Kš
ž˜K˜'šžœž˜K˜8Kšžœ
˜—Kšžœ
˜—Kšžœ
˜—Kšžœ
˜—š
ž˜Kšœžœ
˜—Kšžœ
˜—K˜K˜šžœž˜
Kš
ž˜Kšžœ	žœžœ
˜,šžœžœžœ
žœ
˜2K˜F—K˜Kšžœ
˜—Kš
ž˜—šžœ
žœž˜ Kšžœ
Ÿ˜"šžœžœ
˜Kš
ž˜K˜
Kšœ6žœ˜=K˜Kšžœ
˜—K˜Kš
ž˜—šžœ
žœž˜Kš
ž˜Kšœ
žœ
˜Kšœ
žœ˜(Kšœžœ˜,K˜#Kšœžœžœ
˜K˜+š
œžœ
žœ
žœ
žœ
žœ
žœ˜)šœ"Ÿ˜AKš
œ%™%——šžœžœ
ž˜K˜"K˜&K˜'K˜'Kšžœžœ
˜—šžœ
žœ
ž˜Kš
ž˜K˜.Kšœ;žœ˜BKšžœžœ˜,Kšžœ
Ÿ˜Kšžœ
˜—šžœžœžœ˜@Kšžœžœ˜2—šžœ
žœž˜,Kš
ž˜K˜K˜Kšœ
žœ
˜Kšžœ
˜—Kšœ)žœ˜/šžœ
žœ
žœ
˜!Kš
ž˜šžœž˜
Kš
ž˜K˜3K˜Kšžœ
˜—K˜K˜Kš
ž˜—Kšžœ˜#K˜Kšžœ
žœ˜.šžœžœž˜ Kš
ž˜šžœž˜
Kš
ž˜K˜/K˜Kšžœ
˜—K˜K˜Kšœžœ
˜Kš
ž˜—š
ž˜Kš
ž˜šžœžœž˜#Kš
ž˜K˜/K˜Kšžœ
˜—K˜Kšžœ
˜—K˜$šžœž˜
Kš
ž˜Kšœžœ˜.šžœ	ž˜Kšœ
žœ
˜K˜Kšžœžœ
˜—Kšœ-žœ˜5šžœžœ
ž˜%K˜2—š
ž˜K˜4—K˜Kšžœ
˜—Kš
ž˜—š
ž˜Kš
ž˜Kš
œD™DKš
œC™CK˜K˜Kšœ=žœ˜CKšœ;žœ˜Bšžœ	ž˜Kš
ž˜K˜K˜K˜'Kšžœ
˜—šžœž˜
Kšœ#Ÿ˜@—šžœ	ž˜Kš
ž˜K˜'K˜1K˜'K˜1Kšœ/žœ˜6Kšœ1žœ˜8Kš
ž˜—š
ž˜Kš
ž˜Kšžœžœ
žœ
˜'K˜2K˜&K˜2K˜&Kšœ1žœ˜8Kšœ/žœ˜6Kšžœ
˜—Kšžœ
˜—Kšžœžœžœ
˜2Kšžœ
˜K˜—š œžœ
žœžœžœžœ˜8Kš
ž˜Kšžœ˜Kšžœ
˜K˜—Kšžœ
˜K˜——…—DΜ_ƒ