1

I am going through a C Code and wanted to know if I have understood the code correctly or not.

There is a structure, BF_salt defined in the header file as shown below:

typedef
{
BF_WORD salt[4];
..
..
} BF_SALT;

In the main C Code, there is a call to a function:

function func1()
{
 static BF_SALT salt;
 func2(salt.salt,x,y);
....
}

func2(BF_WORD * dst,x,y)
{
 unsigned char * dptr= (unsigned char*)dst;
 int c1,c2;

 // c1 and c2 are initialized here.

 // in a loop, an operation similar to the below is performed.

 *dptr++ = (c1 << 2) | ((c2 & 0x30) >> 4);
}

My understanding of the code above is:

in func1, salt is defined with data type of structure BF_SALT.

we are calling func2, passing the salt field of the structure.

the salt field is an array of 4 elements, each of data type BF_WORD (32 bit word or 4 bytes)

in func2

dst is the name of the array which points to an element of type BF_WORD.

it is performing a typecast on the pointer, dst.

currently, dst is pointing to data type BF_WORD. it is type casted so that it points to a char (1 byte data).

now it is performing bitshift operations on the integers, c1 and c2 and writing the output to the memory address pointed by dptr. So, it is overwriting the data which was initially pointed to by dst (the bytes in the salt array).

c1 and c2 are of datatype int, which requires 4 bytes of space.

In what way will dptr overwrite the contents of the array? Since everytime, we do *dptr++, we are advancing the pointer, dptr by 1 byte because it points to a character.

however, we are assigning it a value of size greater than 1 byte. How will the data be written to memory?

Thanks.

Improve this question

3 Answers 3

Reset to default
2

Only the lowest byte of the result will be written to memory. Since the pointer is to a char, the int will be truncated and the higher bytes will be lost as it is converted to the type of the lvalue; the same rule as if you had simply assigned the result to a char variable. See standard sections 6.3.2.1 and 6.5.16.1 for the details.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

1

Here

*dptr++ = (c1 << 2) | ((c2 & 0x30) >> 4);

an implicit cast to unsigned char is performed, as dptr is of type unsigned char *, so *dptr is treated as an unsigned char.

Improve this answer

1 Comment

Thanks. Yes, the increment operation is performed on the pointer because there is a loop though I have not mentioned that. I have edited the post to show that there is a loop.
0

Your understanding of the above code , is similiar to mine , and also let me chip in some of my own thoughts

unsigned char * dptr= (unsigned char*)dst;

Here dst which is of type BF_WORD (4 bytes) , is down casted to a char type (1 byte) Also it is worth noting that , though the type of pointer is char , and can navigate one byte at a time , it does holds the address of a 4 byte contiguous memory location , so technically it must be ably to navigate those 4 bytes , a byte at a time.

In what way will dptr overwrite the contents of the array?

dptr now contains the starting address of the 4 number , 4 byte array salt. So it currently accesses salt[0]. Here salt[0] is 4 bytes in size , and dptr is 1 byte pointer , so it takes four (dptr++) increments to cover one element of the array salt[0].

Now the other question

we are assigning it a value of size greater than 1 byte. How will the data be written to memory?

*dptr++ = (c1 << 2) | ((c2 & 0x30) >> 4);

Here both c1 and c2 are of type int , so after the bitwise operation the result is of type int. Hence the 4 byte result is written to salt[0] pointed by dptr; In the next increment of dptr , the pointer will point to the 2 byte of the previous 4 byte result , so the last three bytes of the previous result will be overrun by the next bitwise result.

Improve this answer

9 Comments

"Hence the 4 byte result is written to salt[0] pointed by dptr ..." but only the lowest byte is assigned to what dptr is pointing to, as it's an unsigned char *! And: Which "... next bitwise result.", please? I see no loop.
@alk Yes i thought of that , the lowest byte is assigned if its implicitly typecasted and hence the higher 3 bytes are truncated, but i guess the implicit typecasting occours only , if the left hand assignment is a datatype variable and not a pointer . Do correct me if i am wrong
On the left there is a dereferenced pointer. Please see Leushenko's answer, as he was so kind to lookup the standard.
Btw: Pointers to also have a type, a pointer to the one they are pointing to.
Thanks Barath for looking into the explanation that I have given. I have understood it :)
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.