ansi c char to hex and hex to char

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <string.h>
 
int main()
{
	char str[12];
	char str1[256];
	char temp[5];
	int i;
 
	char x = 'a';
	for (i = 0; i < 12; i++)
		str[i] = x++;
 
	memset(str1, 0, 256);
	for (i = 0; i < 12; i++)
	{
		memset(temp, 0, 5);
		_snprintf(temp, 4, "0x%02x", str[i]);
		strncat(str1, temp, 4);
		strncat(str1, " ", 1);
	}
	printf(str1);
 
	return 0;
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:

#include <stdio.h>
#include <string.h> 
int main(int argc, char** argv) {
    char hexChar[17] = "1234567890ABCDEF";
    unsigned long long hexVal = 0;
    int i; 
    //
    // Convert to unsigned long long
    //
    for(i = 0; i < strlen(hexChar); i++) {
        char hexDigit = hexChar[i];
        unsigned long long val;
        if(hexDigit < 58) {
            // 0 - 9
            val = hexDigit - 48;
        } else {
            val = hexDigit - 55;
        }
        // printf("Val %d\n", val);
        hexVal <<= 4;
        hexVal |= val;
    }
    printf("Converted to long long %llX\n", hexVal); 
    //
    // Convert unsigned long long to char array
    //
    char reverseChar[17];
    reverseChar[16] = '\0';
    for(i = 16; i > 0; i--) {
        int nibble = hexVal & 0xF;
        char c;
        if(nibble < 10) {
            c = nibble + 48;
        } else {
            c = nibble + 55;
        }
        reverseChar[i-1] = c;
        hexVal >>= 4;
    }
    printf("Converted back to chars %s\n", reverseChar); 
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <string.h>
 
int main()
{
	char str[14];
	char str1[256];
	char temp[5];
	int i;
	char* p, *p1;
 
	int x = 'a';
	for (i = 0; i < 12; i++)
		str[i] = x++;
 
	memset(str1, 0, 256);
	for (i = 0; i < 12; i++)
	{
		memset(temp, 0, 5);
		_snprintf(temp, 4, "0x%02x", str[i]);
		strncat(str1, temp, 4);
		strncat(str1, " ", 1);
	}
	printf(str1);
 
	p = (char*)str1;
	memset(str, 0, 14);
	p1 = (char*)str;
	for (i = 0; i < 12; i++)
	{
		p[i + 4] = 0;
		sscanf(p + 2, "%02x", &x);
		memcpy(p1, (void*)&x, 2);
		printf("\n0x%02x", str[i]);
		p += 5;
		p1 += 1;
	}
 
	return 0;
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:

void tohex(const char * s, char * h, int sizh)
{
    static char hex[] = "0123456789abcdef";
    int i   = 0; 
    int len = strlen(s);
    if (len * 2 > sizh)
        len = sizh/2;
    for (i = 0; i < len; ++i)
    {
         *(h+2*i    ) = hex[(s[i]&0xf0)>>4];
         *(h+2*i+1) = hex[s[i]&0x0f];
    }
    if (i*2 < sizh)
        *(h+2*i)='\0';
}
 
void fromhex(const char * h, char * s, int sizs)
{
    static char hex[] = "0123456789abcdef";
    int i   = 0; 
    int len = strlen(h)/2;
    if (len > sizs)
        len = sizs;
    for (i = 0; i < len; ++i)
    {
       char* p = strchr(hex, *(h+2*i));
       if (p != NULL)
       {
           s[i] = (char)(unsigned char)((p-hex)<<4);
           p = strchr(hex, *(h+2*i+1));
           if (p != NULL)
           {
              s[i] |= (char)(p-hex);
           }
           else 
              s[i] = '?';
       }
       else 
          s[i] = '?';
    }
    if (i < sizs * 2)
        *(s+i)='\0';
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:

const char *str = "50";
int value = 0;
sscanf(str, "%2x", &value);
char c = (char) value;

                                              

1:
2:
3:
4:

void fromhex(const char * h, char * s, int sizs)
{
    static char hex[] = "0123456789abcdef";
    int i   = 0; 
    int len = strlen(h)/2;
    if (len > sizs)
        len = sizs;
    for (i = 0; i < len; ++i)
    {
       char* p = strchr(hex, tolower(*(h+2*i)));
       if (p != NULL)
       {
           s[i] = (char)(unsigned char)((p-hex)<<4);
           p = strchr(hex, *(h+2*i+1));
           if (p != NULL)
           {
              s[i] |= (char)(p-hex);
           }
           else 
              s[i] = '?';
       }
       else 
          s[i] = '?';
    }
    if (i < sizs * 2)
        *(s+i)='\0';
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:

#define CharHexToInt(value)                                                   \
                           ((((value) > '9')?(0x09):(0x00)) + ((value) & 0x0F)) 
void IntToHex(long number, char* hexstr)
{
   size_t hexindex;
   size_t position = 0;
   long mask = number;
   const char hex[] = "0123456789ABCDEF"; 
   do
   {
      mask = mask >> 1;
      position++; 
   } while (mask != 0); 
   position = (position / 4) + (((position % 4) & 2) >> 1);
   hexstr[position] = '\0';
   position--; 
   do
   {
      hexindex = number % 16;
      number = number / 16;
      hexstr[position] = hex[hexindex];
      position --; 
   } while (number != 0);
} 
long HexToInt(char* hexstr)
{
   long result = 0;
   size_t position = 0; 
   while (hexstr[position] != '\0')
   {
      result = (result << 4) + CharHexToInt(hexstr[position]);
      position++;
   } 
   return (result);
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:

void IntToHex(long number, char* hexstr)
{
   size_t hexindex;
   size_t position = 0;
   long mask = number;
   const char hex[] = "0123456789ABCDEF"; 
   do
   {
      mask = mask >> 1;
      position++; 
   } while (mask != 0); 
   position = (position / 4) + (((position % 4) & 2) >> 1); 
   if (position < 2)
   position = 2; 
   hexstr[position] = '\0';
   position--; 
   do
   {
      hexindex = number % 16;
      number = number / 16;
      hexstr[position] = hex[hexindex];
      position --; 
   } while (number != 0);
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

#define HEX_LENGTH                             (2u) 
void HexToInt(char* src, char* dst)
{
   char temp[HEX_LENGTH];
   int value;
   int dst_index = 0;
   int src_index = 0; 
   while (src[src_index] != '\0')
   {
      strncpy(temp, &src[src_index], HEX_LENGTH);
      sscanf(temp, "%x", &value);
      dst[dst_index] = value;
      src_index = src_index + HEX_LENGTH;
      dst_index++;
   } 
   dst[dst_index] = '\0';
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

#define HEX_LENGTH                             (2u) 
#define NULL_TERMINATION_CHAR                ('\0') 
void StringToHex(char* src, char* dst)
{
   int value;
   int dst_index = 0;
   int src_index = 0; 
   while (src[src_index] != NULL_TERMINATION_CHAR)
   {
      value = (int) src[src_index];
      sprintf(&dst[dst_index], "%X", value);
      dst_index = dst_index + HEX_LENGTH;
      src_index++;
   } 
   dst[dst_index] = NULL_TERMINATION_CHAR;
} 
void HexToString(char* src, char* dst)
{
   char temp[HEX_LENGTH];
   int value;
   int dst_index = 0;
   int src_index = 0; 
   while (src[src_index] != NULL_TERMINATION_CHAR)
   {
      strncpy(temp, &src[src_index], HEX_LENGTH);
      sscanf(temp, "%x", &value);
      dst[dst_index] = value;
      src_index = src_index + HEX_LENGTH;
      dst_index++;
   } 
   dst[dst_index] = NULL_TERMINATION_CHAR;
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:

void fromhex(const char * h, char * s, int sizs)
{
    char * sentinel = NULL;
    int i   = 0; 
    int len = strlen(h)/2;
    char hex[3] = { '\0' };
 
    if (len > sizs)
        len = sizs;
    for (i = 0; i < len; ++i)
    {
       hex[0] = h[2*i];
       hex[1] = h[2*i+1];
       s[i] = (char)strtol(hex, &sentinel, 16); // hex is base 16
       if (sentinel == NULL || *sentinel != '\0')
         s[i] = '?';
    }
    if (i < sizs * 2)
        s[i] = '\0';
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

#define HEX_LENGTH                             (2u)
#define NULL_TERMINATION_CHAR                ('\0') 
void StringToHex(char* src, char* dst)
{
   int value;
   int dst_index = 0;
   int src_index = 0; 
   while (src[src_index] != NULL_TERMINATION_CHAR)
   {
      value = (int) src[src_index];
      sprintf(&dst[dst_index], "%02X", value);
      dst_index = dst_index + HEX_LENGTH;
      src_index++;
   } 
   dst[dst_index] = NULL_TERMINATION_CHAR;
} 
void HexToString(char* src, char* dst)
{
   int value;
   int dst_index = 0;
   int src_index = 0; 
   while (src_index < strlen(src))
   {
      sscanf(&src[src_index], "%02x", &value);
      dst[dst_index] = (char) value;
      src_index = src_index + HEX_LENGTH;
      dst_index++;
   } 
   dst[dst_index] = NULL_TERMINATION_CHAR;
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36: