Bit manipulation - replace a "block" - bit-manipulation

Question

I'm trying to write a function that will replace a certain "block" of size 2^x with a new value.
For example, if I had a number 1110 1000 0010 and I wanted to replace block 2 (max block size of 2^4) with 0110, I would get 0110 1000 0010. Likewise, If I wanted the to replace block 2 with 110 (max block size of 2^3) I would get 111 110 000 010, or 1111 1000 0010.
replace_block (value, x, blockNumber, newValue) {
value |= ((value >> (blockNumber*x) & ~((1 << x) – 1)) | newValue) << (blockNumber*x)
}
Step by step process of what I'm trying to do with this code:
1. Shift the block we want all the way to the right
2. Mask that block with 0's
3. Mask that block again, but with the new value we want
4. Shift the block all the way back to the original position
5. Or the bits in the block with the original value
This is what I have so far but I don't think it's correct.
Note: The rightmost block is block 0.

Answer 1

First we need the mask: The mask is a set of ones "block size" wide shifted to the right block.
set of ones "block size" wide: (1<<size) - 1
set of ones "block size" wide shifted to the right place: ((1<<size)-1) << (number*size)
First we clear the bits in the spot that will be replaced then we stick in the bits we want.
old value with the masked bits cleared: oldv & ~mask
new value shifted to right place: newv << (number*size)
new value shifted to right place and masked to right width: (newv<<(number*size)) & mask
old bits cleared and new value inserted: (oldv&~mask) | ((newv<<(number*size))&mask)
So the bit of code you want is:
mask=(((1<<size)-1)<<(number*size));
result=((oldv&~mask)|((newv<<(number*size))&mask));
A test program:
#include <stdio.h>
void printbits(int n) {
unsigned int i = 1<<(sizeof(n) * 8 - 1);
while (i > 0) {
if (n & i)
printf("1");
else
printf("0");
i >>= 1;
}
}
int main(void) {
int size,number,mask,oldv,newv,result;
size=4;number=2;oldv=0;newv=15;
mask=(((1<<size)-1)<<(number*size));
result=((oldv&~mask)|((newv<<(number*size))&mask));
printf("\nsize = %d\nnumber = %d",size,number);
printf("\noldv = "); printbits(oldv);
printf("\nnewv = "); printbits(newv);
printf("\nmask = "); printbits(mask);
printf("\nomask = "); printbits(oldv&~mask);
printf("\nnmask = "); printbits((newv<<(number*size))&mask);
printf("\nresult = "); printbits(result);
printf("\n");
size=4;number=2;oldv=~0;newv=0;
mask=(((1<<size)-1)<<(number*size));
result=((oldv&~mask)|((newv<<(number*size))&mask));
printf("\nsize = %d\nnumber = %d",size,number);
printf("\noldv = "); printbits(oldv);
printf("\nnewv = "); printbits(newv);
printf("\nmask = "); printbits(mask);
printf("\nomask = "); printbits(oldv&~mask);
printf("\nnmask = "); printbits((newv<<(number*size))&mask);
printf("\nresult = "); printbits(result);
printf("\n");
size=3;number=2;oldv=0;newv=7;
mask=(((1<<size)-1)<<(number*size));
result=((oldv&~mask)|((newv<<(number*size))&mask));
printf("\nsize = %d\nnumber = %d",size,number);
printf("\noldv = "); printbits(oldv);
printf("\nnewv = "); printbits(newv);
printf("\nmask = "); printbits(mask);
printf("\nomask = "); printbits(oldv&~mask);
printf("\nnmask = "); printbits((newv<<(number*size))&mask);
printf("\nresult = "); printbits(result);
printf("\n");
size=3;number=2;oldv=~0;newv=0;
mask=(((1<<size)-1)<<(number*size));
result=((oldv&~mask)|((newv<<(number*size))&mask));
printf("\nsize = %d\nnumber = %d",size,number);
printf("\noldv = "); printbits(oldv);
printf("\nnewv = "); printbits(newv);
printf("\nmask = "); printbits(mask);
printf("\nomask = "); printbits(oldv&~mask);
printf("\nnmask = "); printbits((newv<<(number*size))&mask);
printf("\nresult = "); printbits(result);
printf("\n");
size=4;number=4;oldv=0xAAAAAAAA;newv=0x15;
mask=(((1<<size)-1)<<(number*size));
result=((oldv&~mask)|((newv<<(number*size))&mask));
printf("\nsize = %d\nnumber = %d",size,number);
printf("\noldv = "); printbits(oldv);
printf("\nnewv = "); printbits(newv);
printf("\nmask = "); printbits(mask);
printf("\nomask = "); printbits(oldv&~mask);
printf("\nnmask = "); printbits((newv<<(number*size))&mask);
printf("\nresult = "); printbits(result);
printf("\n");
size=5;number=3;oldv=0xAAAAAAAA;newv=0x15;
mask=(((1<<size)-1)<<(number*size));
result=((oldv&~mask)|((newv<<(number*size))&mask));
printf("\nsize = %d\nnumber = %d",size,number);
printf("\noldv = "); printbits(oldv);
printf("\nnewv = "); printbits(newv);
printf("\nmask = "); printbits(mask);
printf("\nomask = "); printbits(oldv&~mask);
printf("\nnmask = "); printbits((newv<<(number*size))&mask);
printf("\nresult = "); printbits(result);
printf("\n");
return 0;
}
And the result:
size = 4
number = 2
oldv = 00000000000000000000000000000000
newv = 00000000000000000000000000001111
mask = 00000000000000000000111100000000
omask = 00000000000000000000000000000000
nmask = 00000000000000000000111100000000
result = 00000000000000000000111100000000
size = 4
number = 2
oldv = 11111111111111111111111111111111
newv = 00000000000000000000000000000000
mask = 00000000000000000000111100000000
omask = 11111111111111111111000011111111
nmask = 00000000000000000000000000000000
result = 11111111111111111111000011111111
size = 3
number = 2
oldv = 00000000000000000000000000000000
newv = 00000000000000000000000000000111
mask = 00000000000000000000000111000000
omask = 00000000000000000000000000000000
nmask = 00000000000000000000000111000000
result = 00000000000000000000000111000000
size = 3
number = 2
oldv = 11111111111111111111111111111111
newv = 00000000000000000000000000000000
mask = 00000000000000000000000111000000
omask = 11111111111111111111111000111111
nmask = 00000000000000000000000000000000
result = 11111111111111111111111000111111
size = 4
number = 4
oldv = 10101010101010101010101010101010
newv = 00000000000000000000000000010101
mask = 00000000000011110000000000000000
omask = 10101010101000001010101010101010
nmask = 00000000000001010000000000000000
result = 10101010101001011010101010101010
size = 5
number = 3
oldv = 10101010101010101010101010101010
newv = 00000000000000000000000000010101
mask = 00000000000011111000000000000000
omask = 10101010101000000010101010101010
nmask = 00000000000010101000000000000000
result = 10101010101010101010101010101010