Simple Bitmask problem

[Patrick]

Hi there,

I have a simple problem to solve but somehow I am too stupid to figure
out where is the error.
Basically, I wanna shift each element of the array by an amount of n,
whereas the n highest
bits shifted out should be the n-least significant bits of the next
higher word. I tried doing this
by shifting the words the amount of n to the left which works fine. In
the next step I shift the lower
word 32-n positions to the right and OR the result with the higher
word which should add the then
bits I shifted out in the former step. Here is the code:

uint32 p_lo[] = { 0x00, 0x00, 0x00, 0x00 };

for (j = 0; j < 64; j ++ )
{
p_lo[0] <<= (j % 32);
p_lo[1] <<= (j % 32);
p_lo[1] |= (p_lo[0] >(32 - (j % 32)));
}

Unfortuantely the outcome is nonsense... Anyone an idea what I am
missing?

Many thanks,
Patrick

[pete]

Patrick wrote:

>
Hi there,

I have a simple problem to solve but somehow I am too stupid to figure
out where is the error.
Basically, I wanna shift each element of the array by an amount of n,
whereas the n highest
bits shifted out should be the n-least significant bits of the next
higher word. I tried doing this
by shifting the words the amount of n to the left which works fine. In
the next step I shift the lower
word 32-n positions to the right and OR the result with the higher
word which should add the then
bits I shifted out in the former step. Here is the code:

uint32 p_lo[] = { 0x00, 0x00, 0x00, 0x00 };

for (j = 0; j < 64; j ++ )
{
p_lo[0] <<= (j % 32);
p_lo[1] <<= (j % 32);
p_lo[1] |= (p_lo[0] >(32 - (j % 32)));
}

Unfortuantely the outcome is nonsense... Anyone an idea what I am
missing?

/* BEGIN new.c output */

D_Word[0] is 0x12345678
D_Word[1] is 0x9abcdef0
LEFT_SHIFT 12
D_Word[0] is 0x45678000
D_Word[1] is 0xcdef0123

/* END new.c output */
/* BEGIN new.c */

#include <stdio.h>

#define LEFT_SHIFT 12

int main(void)
{
long unsigned D_Word[] = {0x12345678, 0x9abcdef0};

puts("/* BEGIN new.c output */\n");
printf("D_Word[0] is 0x%x\n", D_Word[0]);
printf("D_Word[1] is 0x%x\n", D_Word[1]);
puts("LEFT_SHIFT 12");
D_Word[1] <<= LEFT_SHIFT;
D_Word[1] |= D_Word[0] >32 - LEFT_SHIFT;
D_Word[0] <<= LEFT_SHIFT;
printf("D_Word[0] is 0x%x\n", D_Word[0]);
printf("D_Word[1] is 0x%x\n", D_Word[1]);
puts("\n/* END new.c output */");
return 0;
}

/* END new.c */

--
pete

[pete]

pete wrote:

>

long unsigned D_Word[] = {0x12345678, 0x9abcdef0};

is 0x%x\n", D_Word[

is 0x%x\n", D_Word[

is 0x%x\n", D_Word[

is 0x%x\n", D_Word[

Those should all be:

is 0x%lx\n", D_Word[

instead.

--
pete

[Thad Smith]

Patrick wrote:

Basically, I wanna shift each element of the array by an amount of n,
whereas the n highest
bits shifted out should be the n-least significant bits of the next
higher word. I tried doing this
by shifting the words the amount of n to the left which works fine. In
the next step I shift the lower
word 32-n positions to the right and OR the result with the higher
word which should add the then
bits I shifted out in the former step. Here is the code:

uint32 p_lo[] = { 0x00, 0x00, 0x00, 0x00 };

for (j = 0; j < 64; j ++ )
{
p_lo[0] <<= (j % 32);
p_lo[1] <<= (j % 32);
p_lo[1] |= (p_lo[0] >(32 - (j % 32)));
}

Unfortuantely the outcome is nonsense... Anyone an idea what I am
missing?

In my opinion, the most important missing item is a rigorous
specification. Off the top of my head, I expect to know what input to
be shifted, the number of bits to shift, the shift count, what bits are
shifted in, the type of array elements, how many bits are in each array
element, and which array element is considered the most significant.

Given a rigorous specification, you could write the function code and I
could write a test determine if the code works as specified without
looking at the code. Try writing a synopsis for your shift function
that includes a full specification. Writing, testing, and using the
code then becomes a lot easier. ;-)
--
Thad