By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
424,961 Members | 1,333 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 424,961 IT Pros & Developers. It's quick & easy.

128-bit hex number ---> string buffer

P: n/a
ern
Does a function exist to convert a 128-bit hex number to a string?

Sep 20 '06 #1
Share this Question
Share on Google+
14 Replies


P: n/a
ern said:
Does a function exist to convert a 128-bit hex number to a string?
There is no such thing as a "hex number". Hexadecimal is a numeric
representation system, not a kind of number.

If you have a hex representation, you already *have* a string, and
converting a string to a string is simple enough.

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at above domain (but drop the www, obviously)
Sep 20 '06 #2

P: n/a
"ern" <er*******@gmail.comwrites:
Does a function exist to convert a 128-bit hex number to a string?
What format is the number in to start out with? I ask because
it's strange to specify that a number is in hex if it's simply in
an integer variable. Normally, one thinks of a numeric variable
as simply having a value, and the base is not important. Also: C
doesn't guarantee the existence of an 128-bit integer type.
--
"Am I missing something?"
--Dan Pop
Sep 20 '06 #3

P: n/a
ern

Richard Heathfield wrote:
ern said:
Does a function exist to convert a 128-bit hex number to a string?

There is no such thing as a "hex number". Hexadecimal is a numeric
representation system, not a kind of number.

If you have a hex representation, you already *have* a string, and
converting a string to a string is simple enough.

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at above domain (but drop the www, obviously)
Let me rephrase. I have a 128 bit value, which I would like to be
converted to a hexadecimally represented string.

For example,

If my 128 bit value (represented hexadecimally) was:

4D9479E256DD4E8A923E32065141A911

I would want this function to populate a char buffer such that:

charBuffer = "4D9479E256DD4E8A923E32065141A911"
If you have a hex representation, you already *have* a string, and
converting a string to a string is simple enough.
Last time I checked... http://www.asciitable.com/

the string representation "4" has the hex value 0x34, contradicting
your above statement. You *always* have a string, though (as in this
case) it might not be the one you need.

Sep 20 '06 #4

P: n/a
In article <11*********************@i3g2000cwc.googlegroups.c om>,
ern <er*******@gmail.comwrote:
>Does a function exist to convert a 128-bit hex number to a string?
There is no library function to do that directly, but you can
write it easily enough if you are willing to assume a specific
character set (such as ASCII), and if you know the encoding
represented by the number.

For example, one that would work for one encoding combination is,
#include <stdio.h>

int main(void) {
const char hexnum[33] = "54686520616e73776572206973203432";
unsigned short tmpbuf[16];
int i;

sscanf( hexnum,
"%2hx%2hx%2hx%2hx%2hx%2hx%2hx%2hx%2hx%2hx%2hx%2hx% 2hx%2hx%2hx%2hx",
&tmpbuf[0], &tmpbuf[1], &tmpbuf[2], &tmpbuf[3],
&tmpbuf[4], &tmpbuf[5], &tmpbuf[6], &tmpbuf[7],
&tmpbuf[8], &tmpbuf[9], &tmpbuf[10], &tmpbuf[11],
&tmpbuf[12], &tmpbuf[13], &tmpbuf[14], &tmpbuf[15] );

for (i=0; i<16; i++) printf("%c", (unsigned char) tmpbuf[i] );
printf("\n");

return 0;
}

--
If you lie to the compiler, it will get its revenge. -- Henry Spencer
Sep 20 '06 #5

P: n/a
ern said:
>
Richard Heathfield wrote:
>ern said:
Does a function exist to convert a 128-bit hex number to a string?

There is no such thing as a "hex number". Hexadecimal is a numeric
representation system, not a kind of number.

If you have a hex representation, you already *have* a string, and
converting a string to a string is simple enough.
Let me rephrase. I have a 128 bit value, which I would like to be
converted to a hexadecimally represented string.
Okay. Since C doesn't guarantee the existence of 128-bit integer types, let
us assume that you have your value in an array of unsigned char, which we
will treat as a bit array.

Here's some preprocessing stuff:

#include <stddef.h>
#include <limits.h>

#define BYTE(x) ((x) / CHAR_BIT)
#define BIT(x) ((x) % CHAR_BIT)
#define SET_BIT(a, b) \
(a)[BYTE(b)] |= (1 << (BIT(b)))
#define CLEAR_BIT(a, b) \
(a)[BYTE(b)] &= ~(1 << (BIT(b)))
#define TEST_BIT(a, b) \
(!!(((a)[BYTE(b)]) & (1 << (BIT(b)))))

Okay, here's our routine, which requires a pointer to the first of len bytes
of input and a pointer to the first of len * 2 + 1 bytes of output. I
should warn you that I have *not* tested it very much! Especially the code
that deals with weird byte sizes. So it's likely to have a hole or two. But
it should give you the general idea, and is not limited to 128-bit inputs
(but if that is what you want and CHAR_BIT is 8, then this routine expects
len to be 16):

void to_hex(char *out, unsigned char *in, size_t len)
{
char hexabet[] = "0123456789ABCDEF";
size_t bits = len * CHAR_BIT;
size_t bit = 0;
int ch = 0;

if(bits & 7)
{
bit = bits & 7; bits &= ~7;

while(bit != 0)
{
ch <<= 1;
ch |= TEST_BIT(in, bit);
--bit;
}
*out++ = hexabet[ch];
}

for(; bit < bits; bit += 8)
{
*out++ = hexabet[(TEST_BIT(in, bit + 7) << 3) |
(TEST_BIT(in, bit + 6) << 2) |
(TEST_BIT(in, bit + 5) << 1) |
TEST_BIT(in, bit + 4)];
*out++ = hexabet[(TEST_BIT(in, bit + 3) << 3) |
(TEST_BIT(in, bit + 2) << 2) |
(TEST_BIT(in, bit + 1) << 1) |
TEST_BIT(in, bit)];
}
*out = '\0';
}

And here's a driver:

#include <stdio.h>

int main(void)
{
unsigned char in[] =
{
0x4D, 0x94, 0x79, 0xE2,
0x56, 0xDD, 0x4E, 0x8A,
0x92, 0x3E, 0x32, 0x06,
0x51, 0x41, 0xA9, 0x11
};
char out[33] = {0};
to_hex(out, in, 16);
printf("%s\n", out);
return 0;
}

>If you have a hex representation, you already *have* a string, and
converting a string to a string is simple enough.

Last time I checked... http://www.asciitable.com/
ASCII has nothing to do with C.
the string representation "4" has the hex value 0x34,
You seem to be confusing character sets, representations, and values. The
string "4" comprises two bytes, { '4', '\0' }. The code point of '4' is
implementation-defined. On some systems it is indeed 0x34, but on others
it's 0xF4 or some other value.
contradicting your above statement.
If it contradicts what I said, then it's wrong, because what I said is
right.

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at above domain (but drop the www, obviously)
Sep 20 '06 #6

P: n/a
Walter Roberson said:
In article <11*********************@i3g2000cwc.googlegroups.c om>,
ern <er*******@gmail.comwrote:
>>Does a function exist to convert a 128-bit hex number to a string?

There is no library function to do that directly, but you can
write it easily enough if you are willing to assume a specific
character set (such as ASCII),
You don't actually need to assume this. See my parallel reply.

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at above domain (but drop the www, obviously)
Sep 20 '06 #7

P: n/a
ern

Walter Roberson wrote:
In article <11*********************@i3g2000cwc.googlegroups.c om>,
ern <er*******@gmail.comwrote:
Does a function exist to convert a 128-bit hex number to a string?

There is no library function to do that directly, but you can
write it easily enough if you are willing to assume a specific
character set (such as ASCII), and if you know the encoding
represented by the number.

For example, one that would work for one encoding combination is,
#include <stdio.h>

int main(void) {
const char hexnum[33] = "54686520616e73776572206973203432";
unsigned short tmpbuf[16];
int i;

sscanf( hexnum,
"%2hx%2hx%2hx%2hx%2hx%2hx%2hx%2hx%2hx%2hx%2hx%2hx% 2hx%2hx%2hx%2hx",
&tmpbuf[0], &tmpbuf[1], &tmpbuf[2], &tmpbuf[3],
&tmpbuf[4], &tmpbuf[5], &tmpbuf[6], &tmpbuf[7],
&tmpbuf[8], &tmpbuf[9], &tmpbuf[10], &tmpbuf[11],
&tmpbuf[12], &tmpbuf[13], &tmpbuf[14], &tmpbuf[15] );

for (i=0; i<16; i++) printf("%c", (unsigned char) tmpbuf[i] );
printf("\n");

return 0;
}

--
If you lie to the compiler, it will get its revenge. -- Henry Spencer
Thanks for the code, but that's the inverse of what I need.

Let me make the problem simpler. Say I have a 32-bit integer. I what
the hexadecimally represented string version.

So the integer is the INPUT, and the hexadecimally represented string
is the OUTPUT.

Sep 20 '06 #8

P: n/a
ern posted:
If my 128 bit value (represented hexadecimally) was:

4D9479E256DD4E8A923E32065141A911

I would want this function to populate a char buffer such that:

charBuffer = "4D9479E256DD4E8A923E32065141A911"
If you have an aversion to the Standard Library, then maybe something along
the lines of the following. (This sample is capped at 32-Bit, but this is
easily adjusted.)

#include <assert.h>

#define MAX_VAL 0xFFFFFFFFu
#define MAX_DIVISOR 0x10000000u
#define MAX_HEX_DIGITS 8

typedef long unsigned IntType;

void IntToHexStr(IntType val,char *const buf)
{
int const assert_dummy = ( assert(val <= MAX_VAL),
assert(!!buf),
0);

static char const digits[16] = "0123456789ABCDEF";
/* No terminating null character */

IntType divisor = MAX_DIVISOR;

char *p = buf;

do
{
/* Maybe "ldiv" should be used... ? */

unsigned const digit_val = val / divisor;
val %= divisor;
divisor /= 0x10;

if(digit_val) *p++ = digits[digit_val];
} while(divisor);

if(buf==p) *p++ = '0';

*p = 0;
}

#include <stdlib.h>
#include <stdio.h>

int main(void)
{
char buf[MAX_HEX_DIGITS+1];

IntToHexStr(0x778FEE34,buf);

puts(buf);

return 0;
}

--

Frederick Gotham
Sep 20 '06 #9

P: n/a
ern

Richard Heathfield wrote:
ern said:

Richard Heathfield wrote:
ern said:

Does a function exist to convert a 128-bit hex number to a string?

There is no such thing as a "hex number". Hexadecimal is a numeric
representation system, not a kind of number.

If you have a hex representation, you already *have* a string, and
converting a string to a string is simple enough.
Let me rephrase. I have a 128 bit value, which I would like to be
converted to a hexadecimally represented string.

Okay. Since C doesn't guarantee the existence of 128-bit integer types, let
us assume that you have your value in an array of unsigned char, which we
will treat as a bit array.

Here's some preprocessing stuff:

#include <stddef.h>
#include <limits.h>

#define BYTE(x) ((x) / CHAR_BIT)
#define BIT(x) ((x) % CHAR_BIT)
#define SET_BIT(a, b) \
(a)[BYTE(b)] |= (1 << (BIT(b)))
#define CLEAR_BIT(a, b) \
(a)[BYTE(b)] &= ~(1 << (BIT(b)))
#define TEST_BIT(a, b) \
(!!(((a)[BYTE(b)]) & (1 << (BIT(b)))))

Okay, here's our routine, which requires a pointer to the first of len bytes
of input and a pointer to the first of len * 2 + 1 bytes of output. I
should warn you that I have *not* tested it very much! Especially the code
that deals with weird byte sizes. So it's likely to have a hole or two. But
it should give you the general idea, and is not limited to 128-bit inputs
(but if that is what you want and CHAR_BIT is 8, then this routine expects
len to be 16):

void to_hex(char *out, unsigned char *in, size_t len)
{
char hexabet[] = "0123456789ABCDEF";
size_t bits = len * CHAR_BIT;
size_t bit = 0;
int ch = 0;

if(bits & 7)
{
bit = bits & 7; bits &= ~7;

while(bit != 0)
{
ch <<= 1;
ch |= TEST_BIT(in, bit);
--bit;
}
*out++ = hexabet[ch];
}

for(; bit < bits; bit += 8)
{
*out++ = hexabet[(TEST_BIT(in, bit + 7) << 3) |
(TEST_BIT(in, bit + 6) << 2) |
(TEST_BIT(in, bit + 5) << 1) |
TEST_BIT(in, bit + 4)];
*out++ = hexabet[(TEST_BIT(in, bit + 3) << 3) |
(TEST_BIT(in, bit + 2) << 2) |
(TEST_BIT(in, bit + 1) << 1) |
TEST_BIT(in, bit)];
}
*out = '\0';
}

And here's a driver:

#include <stdio.h>

int main(void)
{
unsigned char in[] =
{
0x4D, 0x94, 0x79, 0xE2,
0x56, 0xDD, 0x4E, 0x8A,
0x92, 0x3E, 0x32, 0x06,
0x51, 0x41, 0xA9, 0x11
};
char out[33] = {0};
to_hex(out, in, 16);
printf("%s\n", out);
return 0;
}

If you have a hex representation, you already *have* a string, and
converting a string to a string is simple enough.
Last time I checked... http://www.asciitable.com/

ASCII has nothing to do with C.
the string representation "4" has the hex value 0x34,

You seem to be confusing character sets, representations, and values. The
string "4" comprises two bytes, { '4', '\0' }. The code point of '4' is
implementation-defined. On some systems it is indeed 0x34, but on others
it's 0xF4 or some other value.
contradicting your above statement.

If it contradicts what I said, then it's wrong, because what I said is
right.

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at above domain (but drop the www, obviously)
Thanks for the help all. I will try and apply the help to solve the
problem.

Sep 20 '06 #10

P: n/a
ern wrote:
Does a function exist to convert a 128-bit hex number to a string?

What's a 'hex number?' You mean like "Thirteen", or "666" ?

Or do you mean a "number" and its hexidecimal representation?

If so, then by "number", do you mean some sort of 128 bit Integer
format? There are int128_t and uint128_t on some platforms, which are
nonstandard. But there are also bignum libraries with 128 bit floating
point types.

If you are simply trying to take a 16 byte chunk of data, and convert
the value of each nybble to a hex digit in a string, isn't that just a
matter of using "%x" in some *printf() variety?
Sep 20 '06 #11

P: n/a
"ern" <er*******@gmail.comwrites:
Let me make the problem simpler. Say I have a 32-bit integer. I what
the hexadecimally represented string version.

So the integer is the INPUT, and the hexadecimally represented string
is the OUTPUT.
#v+
sprintf(buffer, "%08x", integer);
#v-

Anyways, you probably ask for:

#v+
void binary2hex(const char *data, size_t len, char *buffer) {
static const char digits[16] = '0123456789ABCDEF";
size_t i = 0;
for (; i<len; ++i, ++data) {
*buffer++ = digits[(data>>4) & 0xf];
*buffer++ = digits[ data & 0xf];
}
*buffer = 0;
}
#v-

Not tested but should work. Buffer has to have at least 2*len+1 chars.

--
Best regards, _ _
.o. | Liege of Serenly Enlightened Majesty of o' \,=./ `o
..o | Computer Science, Michal "mina86" Nazarewicz (o o)
ooo +--<mina86*tlen.pl>--<jid:mina86*jabber.org>--ooO--(_)--Ooo--
Sep 20 '06 #12

P: n/a
"ern" <er*******@gmail.comwrites:
>Let me make the problem simpler. Say I have a 32-bit integer. I what
the hexadecimally represented string version.

So the integer is the INPUT, and the hexadecimally represented string
is the OUTPUT.
Michal Nazarewicz <mi****@tlen.plwrites:
Anyways, you probably ask for:
void binary2hex(const char *data, size_t len, char *buffer) {
Duh... Even though it doesn't make big difference it shall be:

#v+
void binary2hex(const unsigned char *data, size_t len, char *buffer) {
#v-

The code will of course fail if CHAR_BIT != 8.

--
Best regards, _ _
.o. | Liege of Serenly Enlightened Majesty of o' \,=./ `o
..o | Computer Science, Michal "mina86" Nazarewicz (o o)
ooo +--<mina86*tlen.pl>--<jid:mina86*jabber.org>--ooO--(_)--Ooo--
Sep 20 '06 #13

P: n/a
ern wrote:
Thanks for the code, but that's the inverse of what I need.

Let me make the problem simpler. Say I have a 32-bit integer. I what
the hexadecimally represented string version.

So the integer is the INPUT, and the hexadecimally represented string
is the OUTPUT.
To do numeric types greater than 32-bits will require a nonstandard type.

#include <stdio.h>
int main(int argc, char** argv){
long unsigned int num;
num = 0xCAFEBABEUL;
printf("0x%8lX\n", num);
return 0;
}
Sep 20 '06 #14

P: n/a

"Ben Pfaff" <bl*@cs.stanford.eduwrote in message
news:87************@benpfaff.org...
"ern" <er*******@gmail.comwrites:
>Does a function exist to convert a 128-bit hex number to a string?

What format is the number in to start out with? I ask because
it's strange to specify that a number is in hex if it's simply in
an integer variable. Normally, one thinks of a numeric variable
as simply having a value, and the base is not important. Also: C
doesn't guarantee the existence of an 128-bit integer type.
--
"Am I missing something?"
--Dan Pop
We miss you, Dan. Elijah
Sep 22 '06 #15

This discussion thread is closed

Replies have been disabled for this discussion.