CODEWITHSUNDEEP
c
cokedude
cokedude

Reputation: 387

Hex remove leading digits

When you do something like 0x01AE1 - 0x01AEA = fffffff7. I only want the last 3 digits. So I used the modulus trick to remove the extra digits. The displacement gets filled with hex values. 

  int extra_crap = 0; 
  int extra_crap1 = 0; 
  int displacement = 0;
  int val1 = 0;
  int val2 = 0;

  displacement val1 - val2;
  extra_crap = displacement % 0x100;
  extra_crap1 = displacement % 256;
  printf(" extra_crap is %x \n", extra_crap);
  printf(" extra_crap1 is %x \n", extra_crap1);

Unfortunately this is having no effect at all. Is there another way to remove all but the last 3 digits?

Upvotes: 0

Views: 2871

Answers (1)

CiaPan
CiaPan

Reputation: 9570

'Unfortunately this is having no effect at all.'

That's probably because you do your calculations on signed int. Try casting the value to unsigned, or simply forget the remainder operator % and use bitwise masking:

displacement & 0xFF;
displacement & 255;

for two hex digits or 

displacement & 0xFFF;
displacement & 4095;

for three digits.

EDIT – some explanation

A detailed answer would be quite long... You need to learn about data types used in C (esp. int and unsigned int, which are two of most used Integral types), the range of values that can be represented in those types and their internal representation in Two's complement code. Also about Integer overflow and Hexadecimal system.

Then you will easily get what happened to your data: subtracting 0x01AE1 - 0x01AEA, that is 6881 - 6890, gave the result of -9, which in 32-bit signed integer encoded with 2's complement and printed in hexadecimal is FFFFFFF7. That MINUS NINE divided by 256 gave a quotient ZERO and Remainder MINUS NINE, so the remainder operator % gave you a precise and correct result. What you call 'no effect at all' is just a result of your lack of understanding what you were actually doing.

My answer above (variant 1) is not any kind of magic, but just a way to enforce calculation on positive numbers. Casting values to unsigned type makes the program to interpret 0xFFFFFFF7 as 4294967287, which divided by 265 (0x100 in hex) results in quotient 16777215 (0xFFFFFF) and remainder 247 (0xF7). Variant 2 does no division at all and just 'masks' those necessary bits: numbers 255 and 4095 contain 8 and 12 low-order bits equal 1 (in hexadecimal 0xFF and 0xFFF, respectively), so bitwise AND does exactly what you want: removes the higher part of the value, leaving just the required two or three low-order hex dgits.

Upvotes: 3

Related Questions