<<>>
<<BlockRotateImpl.meta>>
<<Copyright Ó 1991, 1992 by Xerox Corporation.  All rights reserved.>>
<<Russ Atkinson (RRA) October 23, 1991 3:12 pm PDT>>
<<Michael Plass, March 6, 1992 1:23 pm PST>>

DIRECTORY
Basics, BlockRotate;

BlockRotateImpl: CEDAR PROGRAM
IMPORTS Basics
EXPORTS BlockRotate
= BEGIN

WordPtr: TYPE = POINTER TO WORD;
RawBytesPtr: TYPE = POINTER TO RawBytes;
RawBytes: TYPE = Basics.RawBytes;

RotateLeft: PUBLIC UNSAFE PROC
[src: WordPtr, srcPitch: INTEGER, dst: WordPtr, dstPitch: INTEGER] RETURNS [nz: WORD]
= UNCHECKED {
dstInc: INTEGER = dstPitch*8;
dst _ dst + (BITS[WORD]-1)*dstPitch; 
src _ src + (BITS[WORD]-1)*srcPitch; 
dstPitch _ - dstPitch;
srcPitch _ - srcPitch;
nz ¬ Rotate8x32[LOOPHOLE[src], 0, srcPitch, dst, dstPitch];

dst _ dst - dstInc;
nz ¬ Basics.BITOR[nz, Rotate8x32[LOOPHOLE[src], 1, srcPitch, dst, dstPitch]];

dst _ dst - dstInc;
nz ¬ Basics.BITOR[nz, Rotate8x32[LOOPHOLE[src], 2, srcPitch, dst, dstPitch]];

dst _ dst - dstInc;
nz ¬ Basics.BITOR[nz, Rotate8x32[LOOPHOLE[src], 3, srcPitch, dst, dstPitch]];

};

RotateRight: PUBLIC UNSAFE PROC
[src: WordPtr, srcPitch: INTEGER, dst: WordPtr, dstPitch: INTEGER] RETURNS [nz: WORD]
= UNCHECKED {
dstInc: INTEGER = dstPitch*8;
nz ¬ Rotate8x32[LOOPHOLE[src], 0, srcPitch, dst, dstPitch];

dst _ dst + dstInc;
nz ¬ Basics.BITOR[nz, Rotate8x32[LOOPHOLE[src], 1, srcPitch, dst, dstPitch]];

dst _ dst + dstInc;
nz ¬ Basics.BITOR[nz, Rotate8x32[LOOPHOLE[src], 2, srcPitch, dst, dstPitch]];

dst _ dst + dstInc;
nz ¬ Basics.BITOR[nz, Rotate8x32[LOOPHOLE[src], 3, srcPitch, dst, dstPitch]];

};

Rotate8x32: PUBLIC UNSAFE PROC
[src: RawBytesPtr, srcOff: INTEGER, srcPitch: INTEGER, dst: WordPtr, dstPitch: INTEGER] RETURNS [nz: WORD]
= UNCHECKED {

w, w0, w1, w2, w3, w4, w5, w6, w7, mask: WORD;
off: INTEGER _ srcOff;

<<Fetch section: fetch 32 bytes and assemble into 8 registers>>
<<>>

w0 _ src[off];  off _ off + srcPitch; 
w1 _ src[off];  off _ off + srcPitch; 
w2 _ src[off];  off _ off + srcPitch; 
w3 _ src[off];  off _ off + srcPitch; 
w4 _ src[off];  off _ off + srcPitch; 
w5 _ src[off];  off _ off + srcPitch; 
w6 _ src[off];  off _ off + srcPitch; 
w7 _ src[off];  off _ off + srcPitch; 
w _ src[off]; w0 _ w0 + Basics.BITLSHIFT[w, 8];  off _ off + srcPitch; 
w _ src[off]; w1 _ w1 + Basics.BITLSHIFT[w, 8];  off _ off + srcPitch; 
w _ src[off]; w2 _ w2 + Basics.BITLSHIFT[w, 8];  off _ off + srcPitch; 
w _ src[off]; w3 _ w3 + Basics.BITLSHIFT[w, 8];  off _ off + srcPitch; 
w _ src[off]; w4 _ w4 + Basics.BITLSHIFT[w, 8];  off _ off + srcPitch; 
w _ src[off]; w5 _ w5 + Basics.BITLSHIFT[w, 8];  off _ off + srcPitch; 
w _ src[off]; w6 _ w6 + Basics.BITLSHIFT[w, 8];  off _ off + srcPitch; 
w _ src[off]; w7 _ w7 + Basics.BITLSHIFT[w, 8];  off _ off + srcPitch; 
w _ src[off]; w0 _ w0 + Basics.BITLSHIFT[w, 16];  off _ off + srcPitch; 
w _ src[off]; w1 _ w1 + Basics.BITLSHIFT[w, 16];  off _ off + srcPitch; 
w _ src[off]; w2 _ w2 + Basics.BITLSHIFT[w, 16];  off _ off + srcPitch; 
w _ src[off]; w3 _ w3 + Basics.BITLSHIFT[w, 16];  off _ off + srcPitch; 
w _ src[off]; w4 _ w4 + Basics.BITLSHIFT[w, 16];  off _ off + srcPitch; 
w _ src[off]; w5 _ w5 + Basics.BITLSHIFT[w, 16];  off _ off + srcPitch; 
w _ src[off]; w6 _ w6 + Basics.BITLSHIFT[w, 16];  off _ off + srcPitch; 
w _ src[off]; w7 _ w7 + Basics.BITLSHIFT[w, 16];  off _ off + srcPitch; 
w _ src[off]; w0 _ w0 + Basics.BITLSHIFT[w, 24];  off _ off + srcPitch; 
w _ src[off]; w1 _ w1 + Basics.BITLSHIFT[w, 24];  off _ off + srcPitch; 
w _ src[off]; w2 _ w2 + Basics.BITLSHIFT[w, 24];  off _ off + srcPitch; 
w _ src[off]; w3 _ w3 + Basics.BITLSHIFT[w, 24];  off _ off + srcPitch; 
w _ src[off]; w4 _ w4 + Basics.BITLSHIFT[w, 24];  off _ off + srcPitch; 
w _ src[off]; w5 _ w5 + Basics.BITLSHIFT[w, 24];  off _ off + srcPitch; 
w _ src[off]; w6 _ w6 + Basics.BITLSHIFT[w, 24];  off _ off + srcPitch; 
w _ src[off]; w7 _ w7 + Basics.BITLSHIFT[w, 24]; 
nz ¬
Basics.BITOR[Basics.BITOR[Basics.BITOR[Basics.BITOR[Basics.BITOR[Basics.BITOR[Basics.BITOR[w0, w1], w2], w3], w4], w5], w6], w7];
IF nz # 0 THEN {

<<Rotate section: recursively rotate using 2*2, 4*4, 8*8 cells>>
<<>>
mask _ 55555555h;

w _ Basics.BITAND[w0, mask];
w0 _ Basics.BITAND[mask, Basics.BITRSHIFT[w0, 1]];
w0 _ w0 + Basics.BITAND[Basics.BITNOT[mask], w1];
w1 _ w + Basics.BITLSHIFT[Basics.BITAND[mask, w1], 1];

w _ Basics.BITAND[w2, mask];
w2 _ Basics.BITAND[mask, Basics.BITRSHIFT[w2, 1]];
w2 _ w2 + Basics.BITAND[Basics.BITNOT[mask], w3];
w3 _ w + Basics.BITLSHIFT[Basics.BITAND[mask, w3], 1];

w _ Basics.BITAND[w4, mask];
w4 _ Basics.BITAND[mask, Basics.BITRSHIFT[w4, 1]];
w4 _ w4 + Basics.BITAND[Basics.BITNOT[mask], w5];
w5 _ w + Basics.BITLSHIFT[Basics.BITAND[mask, w5], 1];

w _ Basics.BITAND[w6, mask];
w6 _ Basics.BITAND[mask, Basics.BITRSHIFT[w6, 1]];
w6 _ w6 + Basics.BITAND[Basics.BITNOT[mask], w7];
w7 _ w + Basics.BITLSHIFT[Basics.BITAND[mask, w7], 1];

mask _ 33333333h;

w _ Basics.BITAND[w0, mask];
w0 _ Basics.BITAND[mask, Basics.BITRSHIFT[w0, 2]];
w0 _ w0 + Basics.BITAND[Basics.BITNOT[mask], w2];
w2 _ w + Basics.BITLSHIFT[Basics.BITAND[mask, w2], 2];

w _ Basics.BITAND[w1, mask];
w1 _ Basics.BITAND[mask, Basics.BITRSHIFT[w1, 2]];
w1 _ w1 + Basics.BITAND[Basics.BITNOT[mask], w3];
w3 _ w + Basics.BITLSHIFT[Basics.BITAND[mask, w3], 2];

w _ Basics.BITAND[w4, mask];
w4 _ Basics.BITAND[mask, Basics.BITRSHIFT[w4, 2]];
w4 _ w4 + Basics.BITAND[Basics.BITNOT[mask], w6];
w6 _ w + Basics.BITLSHIFT[Basics.BITAND[mask, w6], 2];

w _ Basics.BITAND[w5, mask];
w5 _ Basics.BITAND[mask, Basics.BITRSHIFT[w5, 2]];
w5 _ w5 + Basics.BITAND[Basics.BITNOT[mask], w7];
w7 _ w + Basics.BITLSHIFT[Basics.BITAND[mask, w7], 2];

mask _ 0f0f0f0fh;

w _ Basics.BITAND[w0, mask];
w0 _ Basics.BITAND[mask, Basics.BITRSHIFT[w0, 4]];
w0 _ w0 + Basics.BITAND[Basics.BITNOT[mask], w4];
w4 _ w + Basics.BITLSHIFT[Basics.BITAND[mask, w4], 4];

w _ Basics.BITAND[w1, mask];
w1 _ Basics.BITAND[mask, Basics.BITRSHIFT[w1, 4]];
w1 _ w1 + Basics.BITAND[Basics.BITNOT[mask], w5];
w5 _ w + Basics.BITLSHIFT[Basics.BITAND[mask, w5], 4];

w _ Basics.BITAND[w2, mask];
w2 _ Basics.BITAND[mask, Basics.BITRSHIFT[w2, 4]];
w2 _ w2 + Basics.BITAND[Basics.BITNOT[mask], w6];
w6 _ w + Basics.BITLSHIFT[Basics.BITAND[mask, w6], 4];

w _ Basics.BITAND[w3, mask];
w3 _ Basics.BITAND[mask, Basics.BITRSHIFT[w3, 4]];
w3 _ w3 + Basics.BITAND[Basics.BITNOT[mask], w7];
w7 _ w + Basics.BITLSHIFT[Basics.BITAND[mask, w7], 4];


};
<<Store section: store the 8 registers>>
<<>>
off _ dstPitch*2;
dst^ _ w0; (dst+dstPitch)^ _ w1; dst _ dst + off;
dst^ _ w2; (dst+dstPitch)^ _ w3; dst _ dst + off;
dst^ _ w4; (dst+dstPitch)^ _ w5; dst _ dst + off;
dst^ _ w6; (dst+dstPitch)^ _ w7;

};

END.