
<<VarMove.mesa>>
<<last edited by Sweet, 9-Oct-81 11:39:32>>
<<last edited by Satterthwaite, April 16, 1986 2:39:15 pm PST>>

DIRECTORY
Alloc: TYPE USING [Notifier],
Basics: TYPE USING [BITAND, BITSHIFT, LongNumber],
Code: TYPE USING [curctxlvl],
CodeDefs: TYPE USING [
Base, BdoVarIndex, BYTE, codeType, MaxParmsInStack, MoveDirection,
StackIndex, StackLocRec, VarComponent, VarIndex, wordlength],
FOpCodes: TYPE USING [
qADC, qADD, qAMUL, qDB, qGA, qLA, qLCO, qLG, qLGD, qLI,
qLL, qLLD, qLLK, qLP, qMUL, qR, qRCFS, qRD, qRDL, qREC, qRF, qRL,
qRLF, qRLFS, qRSTR, qRSTRL, qSG, qSGD, qSL, qSLD, qW, qWD, qWDL,
qWF, qWL, qWLF, qWLFS, qWSTR, qWSTRL],
Literals: TYPE USING [Base, LTIndex, LTNull, ltType],
P5L: TYPE USING [
AddrComponent, BaseComponent, EasilyLoadable, GenAdd, GenAnd, GenRFC, GenShift,
GenVarItem, LoadBoth, LoadSum, ModComponent, ReleaseVarItem, TOSComponent, Words],
P5U: TYPE USING [Out0, Out1, Out2],
PrincOps: TYPE USING [FieldDescriptor, localbase],
Stack: TYPE USING [
Above, Also, Dump, Exchange, Forget, Load, Loc, Pop, RoomFor, stking,
TempStore, Top, VDepthOf],
Symbols: TYPE USING [Base, ContextLevel, lG, lZ, seType];

VarMove: PROGRAM
IMPORTS Basics, CPtr: Code, P5U, P5L, Stack
EXPORTS P5L, CodeDefs =
BEGIN OPEN FOpCodes, CodeDefs, Symbols;

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

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

LoadComponent: PUBLIC PROC [var: VarComponent] =
BEGIN
Mask: ARRAY [0..15] OF CARDINAL = [
0b, 1b, 3b, 7b, 17b, 37b, 77b, 177b, 377b, 777b,
1777b, 3777b, 7777b, 17777b, 37777b, 77777b];
wS: CARDINAL = P5L.Words[var.wSize, var.bSize];
WITH vv: var SELECT FROM
faddr =>
BEGIN
w: CARDINAL _ vv.wd;
lvl: ContextLevel = vv.level;
SELECT lvl FROM
lZ => ERROR;
lG => P5U.Out1[qGA, w];
CPtr.curctxlvl => P5U.Out1[qLA, w];
ENDCASE =>
BEGIN
LoadComponent[P5L.BaseComponent[lvl]];
w _ w - PrincOps.localbase;
IF w # 0 THEN P5L.GenAdd[w];
END;
END;
frame =>
BEGIN
w: CARDINAL _ vv.wd; 
b: CARDINAL = vv.bd;
lvl: ContextLevel = vv.level;
delta: CARDINAL _ 0;
IF b # 0 THEN
BEGIN
IF Stack.RoomFor[2] AND b + var.bSize = wordlength THEN
BEGIN
LoadComponent[[wSize: 1, space: frame[wd: w, level: lvl]]];
P5L.GenAnd[Mask[var.bSize]];
var.bSize _ 0;
END
ELSE
BEGIN
r: VarIndex = P5L.GenVarItem[bo];
IF var.wSize # 0 THEN ERROR;
cb[r] _ [body: bo[
base: P5L.AddrComponent[var],
offset: [bSize: var.bSize, space: frame[bd: b]]]];
MoveBo[r, load];
RETURN
END;
delta _ 1;
END;
BEGIN -- to declare LFOp
LFOp: ARRAY BOOL OF ARRAY [1..2] OF BYTE = [[qLL, qLLD], [qLG, qLGD]];
IF var.wSize # 0 THEN SELECT lvl FROM
lZ => ERROR;
CPtr.curctxlvl, lG => 
BEGIN
IF var.wSize IN [1..2] THEN {
P5U.Out1[LFOp[lvl=lG][var.wSize], w+delta];
IF vv.immutable AND Stack.stking THEN
Stack.Also[n: var.wSize, place: [frame[tOffset: w+delta, tLevel: lvl]]]}
ELSE
FOR i: CARDINAL IN [0..var.wSize) DO
P5U.Out1[LFOp[lvl=lG][1], w+delta+i];
IF vv.immutable AND Stack.stking THEN
Stack.Also[[frame[tOffset: w+delta+i, tLevel: lvl]]];
ENDLOOP;
END;
ENDCASE =>
BEGIN
r: VarIndex = P5L.GenVarItem[bo];
cb[r] _ [body: bo[
base: P5L.BaseComponent[lvl],
offset: [wSize: var.wSize, space:
frame[wd: w+delta - PrincOps.localbase]]]];
MoveBo[r, load];
END;
END; -- scope of LFOp
IF var.bSize # 0 THEN
BEGIN -- delta = 0 in this case
IF Stack.RoomFor[2] THEN
BEGIN
LoadComponent[[wSize: 1, space: frame[wd: w+var.wSize, level: lvl]]];
P5L.GenShift[var.bSize - wordlength];
END
ELSE
BEGIN
r: VarIndex = P5L.GenVarItem[bo];
cb[r] _ [body: bo[
base: P5L.AddrComponent[var],
offset: [bSize: var.bSize, space: frame[wd: var.wSize]]]];
MoveBo[r, load];
END;
END;
END;
frameup =>
BEGIN
r: VarIndex = P5L.GenVarItem[bo];
cb[r] _ [body: bo[
base: [wSize: vv.pwSize, space: frame[wd: vv.wd, level: vv.level]],
offset: [wSize: var.wSize, space: frame[wd: vv.delta]]]];
MoveBo[r, load];
END;
linkup =>
BEGIN
P5U.Out1[qLLK, vv.wd];
P5U.Out1[IF var.wSize = 2 THEN qRD ELSE qR, vv.delta];
END;
caddr => P5U.Out1[qLCO, vv.wd];
code =>
BEGIN
w: CARDINAL _ vv.wd; 
b: CARDINAL = vv.bd;
lti: Literals.LTIndex = vv.lti;
delta: CARDINAL _ 0;
IF lti # Literals.LTNull THEN
BEGIN
LoadFirst: PROC [val: CARDINAL] =
BEGIN
IF b # 0 THEN
BEGIN
IF var.wSize # 0 AND var.bSize + b # wordlength THEN ERROR;
val _ Basics.BITAND[ 
Basics.BITSHIFT[val, b + var.bSize - wordlength], Mask[var.bSize]];
var.bSize _ 0;
END;
P5U.Out1[qLI, val];
END;
LoadLast: PROC [val: CARDINAL] =
BEGIN
IF var.bSize # 0 THEN
val _ Basics.BITSHIFT[val, var.bSize - wordlength];
P5U.Out1[qLI, val];
END;
WITH ll: ltb[lti] SELECT FROM
short => LoadFirst[ll.value];
long =>
BEGIN
LoadFirst[ll.value[0]];
FOR i: CARDINAL IN [1..wS-1) DO
P5U.Out1[qLI, ll.value[i]];
ENDLOOP;
IF wS > 1 THEN LoadLast[ll.value[wS-1]];
END;
ENDCASE => ERROR;
RETURN
END;
IF b # 0 THEN
BEGIN
IF var.wSize # 0 AND var.bSize + b # wordlength THEN ERROR;
P5U.Out1[qLCO, w];
P5L.GenRFC[0, b, var.bSize];
var.bSize _ 0; delta _ 1;
END;
FOR i: CARDINAL IN [0..var.wSize) DO
P5U.Out1[qLCO, w];
P5L.GenRFC[i+delta, 0, wordlength];
ENDLOOP;
IF var.bSize # 0 THEN
BEGIN
P5U.Out1[qLCO, w];
P5L.GenRFC[var.wSize, 0, var.bSize];
END;
END;
link => P5U.Out1[qLLK, vv.wd];
stack =>
BEGIN
w: CARDINAL = vv.wd;
b: [0..wordlength) = vv.bd;
IF w # 0 THEN
BEGIN
IF Stack.VDepthOf[vv.sti] # wS+w-1 THEN
BEGIN
nsti: StackIndex;
Stack.Dump[];
nsti _ Stack.Above[vv.sti, w];
Stack.Forget[vv.sti, w];
vv.sti _ nsti;
GO TO notOnTop;
END;
IF wS > 1 THEN
BEGIN
fvar: VarComponent _ Stack.TempStore[wS];
THROUGH [0..w) DO Stack.Pop[]; ENDLOOP;
WITH vv: fvar SELECT FROM
frame =>
BEGIN
vv.bd _ b;
IF var.bSize # 0 THEN
BEGIN
fvar.wSize _ fvar.wSize-1;  fvar.bSize _ var.bSize;
END;
END;
ENDCASE;
LoadComponent[fvar];
RETURN;
END
ELSE THROUGH [0..w) DO Stack.Exchange[]; Stack.Pop[] ENDLOOP;
vv.sti _ Stack.Top[1];
EXITS
notOnTop => NULL;
END;
IF b # 0 THEN
BEGIN
rest: StackIndex;
IF var.wSize # 0 THEN
BEGIN
rest _ Stack.Above[vv.sti, 1];
IF b+var.bSize # wordlength THEN ERROR;
END;
Stack.Load[vv.sti, 1];
SELECT b + var.bSize FROM
> wordlength => ERROR;
= wordlength => NULL;
ENDCASE => P5L.GenShift[b + var.bSize - wordlength];
P5L.GenAnd[Mask[var.bSize]];
var.bSize _ 0;
IF var.wSize # 0 THEN Stack.Load[rest, var.wSize];
END
ELSE Stack.Load[vv.sti, wS];
IF var.bSize # 0 THEN P5L.GenShift[var.bSize - wordlength];
END;
const => 
BEGIN
v1: CARDINAL _ vv.d1;
b: [0..wordlength) = vv.bd;
nw: CARDINAL = P5L.Words[var.wSize, var.bSize];
IF b # 0 THEN
BEGIN -- Field taking machinery takes care of less than word case
IF b + var.bSize # wordlength THEN ERROR;
v1 _ Basics.BITAND[v1, Mask[var.bSize]];
var.bSize _ 0;
END;
P5U.Out1[qLI, v1];
IF nw = 2 THEN 
BEGIN
v2: CARDINAL = 
IF var.bSize # 0 THEN Basics.BITSHIFT[vv.d2, var.bSize - wordlength]
ELSE vv.d2;
P5U.Out1[qLI, v2];
END;
END;
pdesc => P5U.Out1[qDB, vv.ep];
ENDCASE => ERROR;
END;

LoadVar: PUBLIC PROC [r: VarIndex] =
BEGIN
WITH cb[r] SELECT FROM
o => {LoadComponent[var]; P5L.ReleaseVarItem[r]};
bo => MoveBo[r, load];
bdo => MoveBdo[r, load];
ind => MoveInd[r, load];
ENDCASE => ERROR;
END;



MoveBo: PROC [r: VarIndex, dir: MoveDirection] =
BEGIN
base, offset: VarComponent;
foffset: POINTER TO VarComponent.frame;
psize: CARDINAL;
RWFOp: ARRAY MoveDirection OF ARRAY [1..2] OF BYTE =
[[qRF, qRLF], [qWF, qWLF]];

MoveInitialFragment: PROC =
BEGIN -- let Peephole find RLIF, etc.
SELECT foffset.bd+offset.bSize FROM
< wordlength => IF offset.wSize # 0 THEN ERROR;
> wordlength => ERROR;
ENDCASE;
LoadComponent[base];
P5U.Out2[
RWFOp[dir][psize],
foffset.wd,
LOOPHOLE[PrincOps.FieldDescriptor[
offset: 0, posn: foffset.bd, size: offset.bSize]]];
offset.bSize _ 0;
END;

MoveFinalFragment: PROC =
BEGIN
LoadComponent[base];
P5U.Out2[
RWFOp[dir][psize],
foffset.wd,
LOOPHOLE[PrincOps.FieldDescriptor[
offset: 0, posn: foffset.bd, size: offset.bSize]]];
END;

WITH cc: cb[r] SELECT FROM
bo => {base _ cc.base; offset _ cc.offset};
ENDCASE => ERROR;
P5L.ReleaseVarItem[r];
WITH oo: offset SELECT FROM
frame => foffset _ @oo;
code =>
BEGIN
IF dir = store THEN ERROR;
IF oo.bd # 0 THEN
BEGIN
IF offset.wSize # 0 THEN 
IF oo.bd + offset.bSize # wordlength THEN ERROR
ELSE IF offset.wSize # 0 THEN 
base _ P5L.EasilyLoadable[base, dir];
LoadComponent[base];
P5L.GenRFC[oo.wd, oo.bd, offset.bSize];
offset.bSize _ 0; oo.wd _ oo.wd + 1;
END;
IF offset.wSize > 1 OR offset.wSize # 0 AND offset.bSize # 0 THEN
base _ P5L.EasilyLoadable[base, dir];
FOR i: CARDINAL IN [0..offset.wSize) DO
LoadComponent[base];
P5L.GenRFC[oo.wd+i, 0, wordlength];
ENDLOOP;
IF offset.bSize # 0 THEN
BEGIN
LoadComponent[base];
P5L.GenRFC[oo.wd+offset.wSize, 0, offset.bSize];
END;
RETURN;
END;
ENDCASE => ERROR;
psize _ P5L.Words[base.wSize, base.bSize];
IF psize NOT IN [1..2] THEN ERROR;
WITH bb: base SELECT FROM
faddr =>
BEGIN
SELECT bb.level FROM
lG, CPtr.curctxlvl =>
IF offset.wSize IN [1..2] AND offset.bSize = 0 AND foffset.bd = 0 THEN
BEGIN
LSFOp: ARRAY MoveDirection OF ARRAY [1..2] OF ARRAY BOOL OF BYTE =
[[[qLL, qLG], [qLLD, qLGD]], [[qSL, qSG], [qSLD, qSGD]]];
P5U.Out1[LSFOp[dir][offset.wSize][bb.level = lG], bb.wd + foffset.wd];
RETURN
END;
ENDCASE => 
BEGIN
tr: VarIndex = P5L.GenVarItem[bo];
cb[tr] _ [body: bo[base: P5L.BaseComponent[bb.level],
offset: [wSize: offset.wSize, bSize: offset.bSize,
space: frame[
wd: bb.wd - PrincOps.localbase + foffset.wd, bd: foffset.bd]]]];
MoveBo[tr, dir];
RETURN
END;
END;
stack => IF base.bSize = 0 AND base.wSize IN [1..2] THEN
BEGIN
loc: StackLocRec = Stack.Loc[bb.sti, base.wSize];
WITH loc SELECT FROM
contig => IF place.where = frame THEN
BEGIN -- let recursive call check other criteria
tr: VarIndex = P5L.GenVarItem[bo];
cb[tr] _ [body: bo[base: P5L.EasilyLoadable[base, dir], offset: offset]];
MoveBo[tr, dir];
RETURN;
END;
ENDCASE;
END;
ENDCASE;
IF foffset.bd # 0 OR offset.bSize # 0 THEN
BEGIN
IF offset.wSize # 0 THEN base _ P5L.EasilyLoadable[base, dir];
IF foffset.bd # 0 THEN
BEGIN
IF dir = load THEN MoveInitialFragment[];
foffset.wd _ foffset.wd+1;
END
ELSE IF dir = store THEN MoveFinalFragment[];
END;
SELECT offset.wSize FROM
0 => NULL;
> MaxParmsInStack => ERROR;
1, 2 => 
BEGIN
RWOp: ARRAY MoveDirection OF ARRAY [1..2] OF ARRAY [1..2] OF BYTE =
[[[qR, qRL], [qRD, qRDL]], [[qW, qWL], [qWD, qWDL]]];
LoadComponent[base];
P5U.Out1[RWOp[dir][offset.wSize][psize], foffset.wd];
END;
ENDCASE =>
BEGIN
n, wo, s: CARDINAL;
tr: VarIndex;
base _ P5L.EasilyLoadable[base, dir];
n _ offset.wSize;
s _ MIN[n, 2];
wo _ IF dir = load THEN foffset.wd ELSE foffset.wd + n-s;
WHILE n # 0 DO
tr _ P5L.GenVarItem[bo];
cb[tr] _ [body: bo[base: base, offset: [wSize: s, space: frame[wd: wo]]]];
MoveBo[tr, dir];
n _ n - s;
IF dir = load THEN {wo _ wo + s; s _ MIN[n, 2]}
ELSE {s _ MIN[n, 2]; wo _ wo - s};
ENDLOOP;
END;
IF offset.bSize # 0 THEN
BEGIN
IF foffset.bd # 0 THEN foffset.wd _ foffset.wd - 1;
IF dir = load THEN MoveFinalFragment[]
ELSE IF foffset.bd # 0 THEN MoveInitialFragment[];
END;
END;

MoveBdo: PROC [r: VarIndex, dir: MoveDirection] =
BEGIN
base, disp, offset: VarComponent;
bpSize: [1..2];

WITH cc: cb[r] SELECT FROM
bdo => {base _ cc.base; disp _ cc.disp; offset _ cc.offset};
ENDCASE => ERROR;
P5L.ReleaseVarItem[r];

<<N.B. some of the following code is copied in MakeBo.  Any bugs should>>
<<be fixed in both places.>>

WITH vv: disp SELECT FROM
const =>
BEGIN
owd: CARDINAL;
ld: Basics.LongNumber;
bor: VarIndex;
IF disp.wSize > 1 OR disp.bSize # 0 THEN GO TO tooBig;
WITH offset SELECT FROM
frame => owd _ wd;
code => owd _ wd;
ENDCASE => ERROR;
ld.lc _ CARDINAL[vv.d1].LONG + owd.LONG;
IF ld.highbits # 0 THEN GO TO tooBig;
P5L.ModComponent[var: @offset, wd: vv.d1];
bor _ P5L.GenVarItem[bo];
cb[bor] _ [body: bo[base: base, offset: offset]];
MoveBo[bor, dir];
RETURN;
EXITS
tooBig => NULL;
END;
ENDCASE;

bpSize _ P5L.LoadSum[@disp, @base];
BEGIN
tr: VarIndex = P5L.GenVarItem[bo];
cb[tr] _ [body: bo[base: P5L.TOSComponent[bpSize], offset: offset]];
MoveBo[tr, dir];
END;
END;

MoveInd: PROC [r: VarIndex, dir: MoveDirection] =
BEGIN
base, index, offset: VarComponent;
packed, simple: BOOL;
eWords, grain: CARDINAL;

WITH cc: cb[r] SELECT FROM
ind =>
BEGIN
base _ cc.base;  index _ cc.index;  offset _ cc.offset;
simple _ cc.simple;
WITH pp: cc SELECT FROM
packed => {packed _ TRUE; grain _ pp.grain};
notPacked => {packed _ FALSE; eWords _ pp.eWords};
ENDCASE;
END;
ENDCASE => ERROR;
P5L.ReleaseVarItem[r];

IF ~packed THEN
BEGIN
tr: BdoVarIndex = LOOPHOLE[P5L.GenVarItem[bdo]];
cb[tr] _ [body: bdo[base: base, disp: TRASH, offset: offset]];
IF eWords = 1 THEN cb[tr].disp _ index
ELSE
BEGIN
WITH vv: index 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};
cb[tr].disp _ index;
GO TO const;
END;
ENDCASE;
LoadComponent[index];
P5U.Out1[qLI, eWords];
IF simple THEN
BEGIN
P5U.Out0[qMUL];
cb[tr].disp _ P5L.TOSComponent[1];
END
ELSE
BEGIN
P5U.Out0[qAMUL];
P5U.Out0[qREC];
cb[tr].disp _ P5L.TOSComponent[2];
END;
EXITS
const => NULL;
END;
MoveBdo[tr, dir];
END
ELSE
BEGIN
shift: [4..7] _ (SELECT grain FROM
1 => 4, 2 => 5, 4 => 6, 8 => 7, ENDCASE => ERROR);
obd: [0..wordlength);
owd: CARDINAL;
fd: PrincOps.FieldDescriptor;
bpSize: CARDINAL;
fromCode: BOOL;
RWFSOp: ARRAY MoveDirection OF BYTE = [qRLFS, qWLFS];
WITH oo: offset SELECT FROM
code => {obd _ oo.bd; owd _ oo.wd; fromCode _ TRUE};
frame =>
BEGIN
IF oo.level # lZ THEN ERROR;
obd _ oo.bd; owd _ oo.wd;
fromCode _ FALSE;
END;
ENDCASE => ERROR;
fd _ [offset: 0, posn: obd, size: offset.bSize];
bpSize _ P5L.Words[base.wSize, base.bSize];
IF bpSize NOT IN [1..2] OR offset.wSize # 0 OR offset.bSize = 0
THEN ERROR;
IF ~fromCode AND fd = [offset: 0, posn: 0, size: 8] THEN
BEGIN
RWSTROp: ARRAY MoveDirection OF ARRAY [1..2] OF BYTE = 
[[qRSTR, qRSTRL], [qWSTR, qWSTRL]];
alpha: CARDINAL _ owd;
P5L.LoadBoth[@base, @index, FALSE];
IF alpha > BYTE.LAST THEN
BEGIN
P5L.GenAdd[alpha-BYTE.LAST];
alpha _ BYTE.LAST;
END;
P5U.Out1[RWSTROp[dir][bpSize], alpha];
RETURN
END;
IF simple THEN
BEGIN
LoadComponent[base];
IF ~fromCode AND bpSize = 1 THEN P5U.Out0[FOpCodes.qLP];
LoadComponent[index];
IF owd # 0 THEN P5L.GenAdd[owd];
END
ELSE
BEGIN
Mask: ARRAY [4..7] OF CARDINAL = [17b, 7b, 3b, 1b];
IF owd # 0 THEN
BEGIN
LoadComponent[index];
P5L.GenAdd[owd];
index _ Stack.TempStore[1];
END
ELSE index _ P5L.EasilyLoadable[index, load];
LoadComponent[base];
IF ~fromCode AND bpSize = 1 THEN P5U.Out0[FOpCodes.qLP];
LoadComponent[index];
P5L.GenShift[shift-8];
IF fromCode THEN P5U.Out0[FOpCodes.qADD]
ELSE P5U.Out0[FOpCodes.qADC];
LoadComponent[index];
P5L.GenAnd[Mask[shift]];
END;
P5L.GenShift[shift];
IF fd # LOOPHOLE[0] THEN P5L.GenAdd[fd];
IF fromCode THEN P5U.Out0[qRCFS] ELSE P5U.Out0[RWFSOp[dir]];
END;

END;

StoreComponent: PUBLIC PROC [var: VarComponent] =
BEGIN
w, b: CARDINAL;
lvl: ContextLevel;
WITH vv: var SELECT FROM
frame => {w _ vv.wd; b _ vv.bd; lvl _ vv.level};
frameup =>
BEGIN
r: VarIndex = P5L.GenVarItem[bo];
cb[r] _ [body: bo[
base: [wSize: vv.pwSize, space: frame[wd: vv.wd, level: vv.level]],
offset: [wSize: vv.wSize, space: frame[wd: vv.delta]]]];
MoveBo[r, store];
END;
linkup =>
BEGIN
r: VarIndex = P5L.GenVarItem[bo];
cb[r] _ [body: bo[
base: [wSize: 1, space: link[wd: vv.wd]],
offset: [wSize: vv.wSize, space: frame[wd: vv.delta]]]];
MoveBo[r, store];
END;
ENDCASE => ERROR;
IF b # 0 OR var.bSize # 0 THEN
BEGIN
r: VarIndex = P5L.GenVarItem[bo];
cb[r] _ [body: bo[
base: P5L.AddrComponent[var],
offset: [wSize: var.wSize, bSize: var.bSize, space: frame[bd: b]]]];
MoveBo[r, store];
END
ELSE
BEGIN
SFOp: ARRAY BOOL OF ARRAY [1..2] OF BYTE = [[qSL, qSLD], [qSG, qSGD]];
SELECT lvl FROM
lZ => ERROR;
CPtr.curctxlvl, lG => IF var.wSize IN [1..2] THEN
P5U.Out1[SFOp[lvl=lG][var.wSize], w]
ELSE
FOR i: CARDINAL DECREASING IN [0..var.wSize) DO
P5U.Out1[SFOp[lvl=lG][1], w+i];
ENDLOOP;
ENDCASE =>
BEGIN
r: VarIndex = P5L.GenVarItem[bo];
cb[r] _ [body: bo[base: P5L.BaseComponent[lvl],
offset: [wSize: var.wSize,
space: frame[wd: w - PrincOps.localbase]]]];
MoveBo[r, store];
END;
END;
END;

StoreVar: PUBLIC PROC [r: VarIndex] =
BEGIN
WITH cb[r] SELECT FROM
o => {StoreComponent[var]; P5L.ReleaseVarItem[r]};
bo => MoveBo[r, store];
bdo => MoveBdo[r, store];
ind => MoveInd[r, store];
ENDCASE => ERROR;
END;

END.

