-- VarMove.mesa Edited by Sweet, January 21, 1980 2:24 PM DIRECTORY AltoDefs: FROM "altodefs" USING [BYTE, wordlength], Code: FROM "code" USING [CodeNotImplemented, curctxlvl, dStar, stking], CodeDefs: FROM "codedefs", ControlDefs: FROM "controldefs" USING [FieldDescriptor, localbase], FOpCodes: FROM "fopcodes" USING [qADD, qAMUL, qDESCB, qGADRB, qLADRB, qLCO, qLG, qLGD, qLI, qLL, qLLD, qLLK, qMUL, qPUSH, qR, qRD, qRDL, qRF, qRFL, qRFS, qRFSL, qRIG, qRIGL, qRIL, qRILL, qRL, qRSTR, qRSTRL, qRXGL, qRXL, qRXLL, qSG, qSGD, qSL, qSLD, qW, qWD, qWDL, qWF, qWFL, qWFS, qWFSL, qWIG, qWIGL, qWIL, qWILL, qWL, qWSTR, qWSTRL, qWXGL, qWXL, qWXLL], InlineDefs: FROM "inlinedefs" USING [BITAND, BITSHIFT, LongNumber], OpCodeParams: FROM "opcodeparams" USING [GlobalHB, HB, LocalHB], P5L: FROM "p5l", P5U: FROM "p5u" USING [Out0, Out1, Out2], Stack: FROM "stack" USING [Above, Also, Dump, Exchange, Forget, Load, Loc, Pop, TempStore, Top, VDepthOf], Symbols: FROM "symbols" USING [ContextLevel, ctxType, lG, lZ, seType], Table: FROM "table" USING [Base, Notifier], Tree: FROM "tree" USING [treeType]; VarMove: PROGRAM IMPORTS LCPtr: Code, InlineDefs, P5U, P5L, Stack EXPORTS P5L, CodeDefs = BEGIN OPEN FOpCodes, CodeDefs, Symbols; CPtr: POINTER TO FRAME [Code] = LCPtr; WontHappen: SIGNAL = CODE; wordlength: CARDINAL = AltoDefs.wordlength; BYTE: TYPE = AltoDefs.BYTE; cb, seb, ctxb: Table.Base; VarMoveNotify: PUBLIC Table.Notifier = BEGIN -- called by allocator whenever table area is repacked seb _ base[Symbols.seType]; ctxb _ base[Symbols.ctxType]; cb _ base[Tree.treeType]; RETURN END; LoadComponent: PUBLIC PROCEDURE [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[qGADRB, w]; CPtr.curctxlvl => P5U.Out1[qLADRB, w]; ENDCASE => BEGIN P5L.LoadComponent[P5L.BaseComponent[lvl]]; w _ w - ControlDefs.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 b + var.bSize = wordlength THEN BEGIN P5L.LoadComponent[[wSize: 1, space: frame[wd: w, level: lvl]]]; P5L.GenAnd[Mask[var.bSize]]; var.bSize _ 0; END ELSE BEGIN r: VarIndex; r _ 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 BOOLEAN 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] ELSE BEGIN i: CARDINAL; FOR i IN [0..var.wSize) DO P5U.Out1[LFOp[lvl=lG][1], w+delta+i]; ENDLOOP; END; IF vv.immutable AND CPtr.stking THEN Stack.Also[var.wSize, FALSE, w+delta, lvl]; 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 - ControlDefs.localbase]]]]; MoveBo[r, load]; END; END; -- scope of LFOp IF var.bSize # 0 THEN BEGIN -- delta = 0 in this case P5L.LoadComponent[[wSize: 1, space: frame[wd: w+var.wSize, level: lvl]]]; P5L.GenShift[var.bSize - wordlength]; 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; i: CARDINAL; delta: CARDINAL _ 0; 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 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; SIGNAL WontHappen; 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; P5L.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 _ InlineDefs.BITAND[v1, Mask[var.bSize]]; var.bSize _ 0; END; P5U.Out1[qLI, v1]; IF nw = 2 THEN IF var.bSize # 0 THEN P5U.Out1[qLI, InlineDefs.BITSHIFT[vv.d2, var.bSize - wordlength]] ELSE P5U.Out1[qLI, vv.d2]; END; pdesc => P5U.Out1[qDESCB, LOOPHOLE[vv.desc]]; ENDCASE => ERROR; END; LoadVar: PUBLIC PROCEDURE [r: VarIndex] = BEGIN WITH cb[r] SELECT FROM o => BEGIN P5L.LoadComponent[var]; P5L.ReleaseVarItem[r]; END; bo => MoveBo[r, load]; bdo => MoveBdo[r, load]; ind => MoveInd[r, load]; ENDCASE => ERROR; END; MoveBo: PROCEDURE [r: VarIndex, dir: MoveDirection] = BEGIN base, offset: VarComponent; foffset: POINTER TO frame VarComponent; psize: CARDINAL; delta: CARDINAL _ 0; RWFOp: ARRAY MoveDirection OF ARRAY [1..2] OF BYTE = [[qRF, qRFL], [qWF, qWFL]]; MoveInitialFragment: PROCEDURE = BEGIN SELECT foffset.bd+offset.bSize FROM < wordlength => IF offset.wSize # 0 THEN ERROR; > wordlength => ERROR; ENDCASE; P5L.LoadComponent[base]; P5U.Out2[ RWFOp[dir][psize], foffset.wd, LOOPHOLE[ControlDefs.FieldDescriptor[ offset: 0, posn: foffset.bd, size: offset.bSize]]]; offset.bSize _ 0; END; MoveFinalFragment: PROCEDURE = BEGIN P5L.LoadComponent[base]; P5U.Out2[ RWFOp[dir][psize], foffset.wd, LOOPHOLE[ControlDefs.FieldDescriptor[ offset: 0, posn: foffset.bd, size: offset.bSize]]]; END; WITH cc: cb[r] SELECT FROM bo => BEGIN base _ cc.base; offset _ cc.offset; END; ENDCASE => ERROR; P5L.ReleaseVarItem[r]; WITH oo: offset SELECT FROM frame => foffset _ @oo; code => BEGIN i: CARDINAL; 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 base _ P5L.EasilyLoadable[base, dir]; P5L.LoadComponent[base]; P5L.GenRFC[oo.wd, oo.bd, offset.bSize]; offset.bSize _ 0; END; IF offset.wSize > 1 OR offset.bSize # 0 THEN base _ P5L.EasilyLoadable[base, dir]; FOR i IN [0..offset.wSize) DO P5L.LoadComponent[base]; P5L.GenRFC[oo.wd+i, 0, wordlength]; ENDLOOP; IF offset.bSize # 0 THEN BEGIN P5L.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 ~IN [1..2] THEN ERROR; IF foffset.level # lZ THEN BEGIN -- a field descriptor RWFSOp: ARRAY MoveDirection OF ARRAY [1..2] OF BYTE = [[qRFS, qRFSL], [qWFS, qWFSL]]; SIGNAL CPtr.CodeNotImplemented; -- the following is only half baked, when field variables -- happen, need to work through in detail P5L.LoadComponent[base]; P5L.LoadComponent[offset]; P5U.Out0[ RWFSOp[dir][psize]]; RETURN END; WITH bb: base SELECT FROM frame => BEGIN RWilOp: ARRAY MoveDirection OF ARRAY [1..2] OF ARRAY BOOLEAN OF BYTE = [[[qRIL, qRIG], [qRILL, qRIGL]], [[qWIL, qWIG], [qWILL, qWIGL]]]; IF offset.wSize # 1 OR foffset.wd ~IN OpCodeParams.HB OR foffset.bd # 0 OR offset.bSize # 0 OR base.bSize # 0 THEN GO TO notMagic; SELECT bb.level FROM lG => IF bb.wd ~IN OpCodeParams.GlobalHB THEN GO TO notMagic; CPtr.curctxlvl => IF bb.wd ~IN OpCodeParams.LocalHB THEN GO TO notMagic; ENDCASE => GO TO notMagic; P5U.Out2[ RWilOp[dir][psize][bb.level = lG], bb.wd, foffset.wd]; RETURN; EXITS notMagic => NULL; END; 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 BOOLEAN 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 - ControlDefs.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 inTemp => 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 delta _ 1; IF dir = load THEN MoveInitialFragment[]; 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]]]; P5L.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 BEGIN wo _ wo + s; s _ MIN[n, 2]; END ELSE BEGIN s _ MIN[n, 2]; wo _ wo - s; END; ENDLOOP; END; IF offset.bSize # 0 THEN BEGIN IF dir = load THEN MoveFinalFragment[] ELSE IF foffset.bd # 0 THEN MoveInitialFragment[]; END; END; MoveBdo: PROCEDURE [r: VarIndex, dir: MoveDirection] = BEGIN base, disp, offset: VarComponent; dpSize, bpSize: [1..2]; magicOffset: BOOLEAN; foffset: POINTER TO frame VarComponent; BDCommute: PROCEDURE = BEGIN t: VarComponent = base; i: CARDINAL _ bpSize; base _ disp; disp _ t; bpSize _ dpSize; dpSize _ i; END; MagicBase: PROCEDURE [b: VarComponent] RETURNS [BOOLEAN] = BEGIN WITH bb: b SELECT FROM frame => BEGIN IF bb.bd # 0 OR b.bSize # 0 THEN RETURN [FALSE]; IF b.wSize = 1 AND bb.level = CPtr.curctxlvl THEN RETURN [bb.wd IN OpCodeParams.LocalHB]; IF CPtr.dStar AND b.wSize = 2 THEN SELECT bb.level FROM lG => RETURN [bb.wd IN OpCodeParams.GlobalHB]; CPtr.curctxlvl => RETURN [bb.wd IN OpCodeParams.LocalHB]; ENDCASE; END; ENDCASE; RETURN[FALSE]; END; WITH cc: cb[r] SELECT FROM bdo => BEGIN base _ cc.base; disp _ cc.disp; offset _ cc.offset; END; 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: InlineDefs.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 _ LONG[CARDINAL[vv.d1]] + LONG[owd]; 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; WITH oo: offset SELECT FROM frame => foffset _ @oo; code => BEGIN tr: VarIndex = P5L.GenVarItem[bo]; P5L.LoadComponent[disp]; --more likely to be already loaded P5L.LoadComponent[base]; P5U.Out0[qADD]; cb[tr] _ [body: bo[base: P5L.TOSComponent[1], offset: offset]]; MoveBo[tr, dir]; RETURN; END; ENDCASE => ERROR; magicOffset _ offset.bSize = 0 AND offset.wSize = 1 AND foffset.level = lZ AND foffset.wd IN OpCodeParams.HB; bpSize _ P5L.Words[base.wSize, base.bSize]; dpSize _ P5L.Words[disp.wSize, disp.bSize]; BEGIN -- to set up some exit labels SELECT bpSize FROM >dpSize => GO TO different; BEGIN BDCommute[]; GO TO different END; =1 => BEGIN IF ~magicOffset THEN GO TO notMagic; IF MagicBase[base] THEN GO TO magic; IF MagicBase[disp] THEN BEGIN BDCommute[]; GO TO magic END; GO TO notMagic; EXITS magic => BEGIN P5L.LoadComponent[disp]; WITH bb: base SELECT FROM frame => P5U.Out2[ IF dir = load THEN qRXL ELSE qWXL, bb.wd, foffset.wd]; ENDCASE; RETURN; END; END; =2 => GO TO notMagic; ENDCASE => ERROR; EXITS different => BEGIN IF magicOffset AND MagicBase[base] THEN BEGIN RWXFLOp: ARRAY MoveDirection OF ARRAY BOOLEAN OF BYTE = [[qRXLL, qRXGL], [qWXLL, qWXGL]]; P5L.LoadComponent[disp]; WITH bb: base SELECT FROM frame => P5U.Out2[ RWXFLOp[dir][bb.level = lG], bb.wd, foffset.wd]; ENDCASE => ERROR; RETURN; END; END; notMagic => NULL; END; 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: PROCEDURE [r: VarIndex, dir: MoveDirection] = BEGIN base, index, offset: VarComponent; packed, simple: BOOLEAN; 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 => BEGIN packed _ TRUE; grain _ pp.grain; END; notPacked => BEGIN packed _ FALSE; eWords _ pp.eWords; END; ENDCASE; END; ENDCASE => ERROR; P5L.ReleaseVarItem[r]; IF ~packed THEN BEGIN tr: BdoVarIndex = LOOPHOLE[P5L.GenVarItem[bdo]]; cb[tr] _ [body: bdo[base: base, disp: NULL, offset: offset]]; IF eWords = 1 THEN cb[tr].disp _ index ELSE BEGIN WITH vv: index SELECT FROM const => BEGIN ld: InlineDefs.LongNumber; ld.lc _ LONG[CARDINAL[vv.d1]] * LONG[eWords]; vv.d1 _ ld.lowbits; IF ld.highbits # 0 THEN BEGIN vv.wSize _ 2; vv.d2 _ ld.highbits; END; cb[tr].disp _ index; GO TO const; END; ENDCASE; P5L.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[qPUSH]; 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: ControlDefs.FieldDescriptor; bpSize: CARDINAL; RWFSOp: ARRAY MoveDirection OF ARRAY [1..2] OF BYTE = [[qRFS, qRFSL], [qWFS, qWFSL]]; WITH oo: offset SELECT FROM code => BEGIN obd _ oo.bd; owd _ oo.wd END; frame => BEGIN IF oo.level # lZ THEN ERROR; obd _ oo.bd; owd _ oo.wd; END; ENDCASE => ERROR; fd _ [offset: 0, posn: obd, size: offset.bSize]; bpSize _ P5L.Words[base.wSize, base.bSize]; IF bpSize ~IN [1..2] OR offset.wSize # 0 OR offset.bSize = 0 OR CARDINAL[offset.bSize + obd] > grain THEN ERROR; WITH oo: offset SELECT FROM code => BEGIN Mask: ARRAY [4..7] OF CARDINAL = [17B, 7B, 3B, 1B]; tr: VarIndex = P5L.GenVarItem[bdo]; fr: VarIndex = P5L.GenVarItem[ind]; iscomp, bscomp: VarComponent; IF dir = store THEN ERROR; IF owd # 0 THEN BEGIN P5L.LoadComponent[index]; P5L.GenAdd[owd]; index _ Stack.TempStore[1]; END ELSE index _ P5L.EasilyLoadable[index, load]; P5L.LoadComponent[index]; P5L.GenShift[shift-8]; cb[tr] _ [body: bdo[ base: base, disp: P5L.TOSComponent[1], offset: [wSize: 1, space: code[wd: 0]]]]; MoveBdo[tr, load]; -- get word containing field P5L.LoadComponent[P5L.AddrComponent[Stack.TempStore[1]]]; bscomp _ P5L.TOSComponent[1]; P5L.LoadComponent[index]; P5L.GenAnd[Mask[shift]]; iscomp _ P5L.TOSComponent[1]; cb[fr] _ [body: ind[ base: bscomp, index: iscomp, offset: [bSize: offset.bSize, space: frame[bd: obd]], simple: TRUE, packinfo: packed[grain: grain]]]; MoveInd[fr, load]; RETURN END; ENDCASE; IF 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 > LAST[BYTE] THEN BEGIN P5L.GenAdd[alpha-LAST[BYTE]]; alpha _ LAST[BYTE]; END; P5U.Out1[RWSTROp[dir][bpSize], alpha]; RETURN END; IF simple THEN BEGIN IF bpSize = 2 AND index.tag = stack THEN index _ P5L.EasilyLoadable[index, dir]; -- move to temp P5L.LoadBoth[@base, @index, FALSE]; 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 P5L.LoadComponent[index]; P5L.GenAdd[owd]; index _ Stack.TempStore[1]; END ELSE index _ P5L.EasilyLoadable[index, load]; P5L.LoadComponent[base]; P5L.LoadComponent[index]; P5L.GenShift[shift-8]; P5U.Out0[FOpCodes.qADD]; P5L.LoadComponent[index]; P5L.GenAnd[Mask[shift]]; END; P5L.GenShift[shift]; IF fd # LOOPHOLE[0] THEN P5L.GenAdd[fd]; P5U.Out0[RWFSOp[dir][bpSize]]; END; END; StoreComponent: PUBLIC PROCEDURE [var: VarComponent] = BEGIN w,b: CARDINAL; lvl: ContextLevel; WITH vv: var SELECT FROM frame => BEGIN w _ vv.wd; b _ vv.bd; lvl _ vv.level; END; frameup => BEGIN r: VarIndex; r _ 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; r _ 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; r _ P5L.GenVarItem[bo]; cb[r] _ [body: bo[ base: P5L.AddrComponent[var], offset: [bSize: var.bSize, space: frame[bd: b]]]]; MoveBo[r, store]; END ELSE BEGIN SFOp: ARRAY BOOLEAN 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 BEGIN P5U.Out1[SFOp[lvl=lG][var.wSize], w]; END ELSE BEGIN i: CARDINAL; FOR i DECREASING IN [0..var.wSize) DO P5U.Out1[SFOp[lvl=lG][1], w+i]; 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 - ControlDefs.localbase]]]]; MoveBo[r, store]; END; END; END; StoreVar: PUBLIC PROCEDURE [r: VarIndex] = BEGIN WITH cb[r] SELECT FROM o => BEGIN P5L.StoreComponent[var]; P5L.ReleaseVarItem[r]; END; bo => MoveBo[r, store]; bdo => MoveBdo[r, store]; ind => MoveInd[r, store]; ENDCASE => ERROR; END; END.