Thread: int CHARACTER/S to char/*

I get how to check if the integer is greater than UCHAR_MAX for easy conversion, I also know of wc/stomb/s functions but I cannot find the ic/stomb/s variants that should be available for functions that do such conversions (e.g. printf)

Edit: Btw this is what I currently have:

Code:

case 'c':
	if ( !dst ) return 1;
	if (imax <= UCHAR_MAX && size) *((udac_t*)dst) = (udac_t)imax;
	else if (imax <= WCHAR_MAX && imax >= WCHAR_MIN && size >= sizeof(wchar_t))
		wctomb( dst, (wchar_t)imax );
	else if (imax <= INT_MAX && imax >= INT_MIN && size >= sizeof(int))
		/* Is this the right way to do it? */
		*((int*)dst) = (int)imax;
	else return 1;
	break;

I have no idea what you are talking about.

the printf/fprintf/sprintf definition says that it takes an int for "%c", that implies that somewhere in the library there is a function or functions that do the same for an int to char* as wctomb() would do for a wchar_t to char* since these functions only print to char* buffers and it is fools folly to repeat the same code in similar functions when a common function can take that particular load itself, I'm not looking for itoa() since that covers the %i %d formats (also I already used a more reliable method than a sometimes available function for that purpose)

Edit: It would be like converting UTF32 characters to UTF8 characters, although in this case it's not restricted to that and I'd prefer a standard function to cover that load

Originally Posted by awsdert

that implies that somewhere in the library there is a function or functions that do the same for an int to char*

No it doesn't. In C, a character constant, like 'c', is an int. Also, when a single char is passed to a function with a variable number of parameters (like printf), it is passed as an int. There is no "conversion" to print an int as a char. All that's needed is to send the low byte to the output. So 'c' is represented as 0x00000063 and printf (or putchar) simply sends the low byte, 0x63, to the output.

Did you not catch my mention of %c and snprintf? Also since there are code formats that go as large as 0x10000 or higher (such as UTF32) and since the code take will be system dependent support for converting said codes to a system multibyte character must also be supported, neither of which are suited for hardcoding like I can do with an alternative itoa(),
and even if there is no need of something like icstombs() there would still be a need for something like ictomb() for simplifying the code of snprintf() & strset() which both support int to char* conversion, unless they return an error for being outside wchar_t range I cannot see how they would convert beyond that 0xFFFF (as set by M$ and from what I've read recent builds of linux variants) without introducing error prone code, the simplest way is to always have a ictomb() or lctomb() variant of wctomb() and map to it on systems with wchar_t mapped to int/long (dependent on whether the int is big enough since there are 16bit variants in systems using __LP32__ or similar macros), otherwise they would then just wrap around it when wchar_t maps to a short

Edit:
Here's an quote of the kind of multibyte character I need to make on systems where wchar_t maps to a short:
The GNU C Library - Extended Characters

The basic sequences consist of

single bytes with values in the range 0 through 0177.
two-byte sequences in which the first byte is in the range from 0200 through 0207, and the second byte is in the range from 0240 through 0377.
three-byte sequences in which the first byte is in the range from 0210 through 0217, and the other bytes are in the range from 0240 through 0377.
four-byte sequences in which the first byte is in the range from 0220 through 0227, and the other bytes are in the range from 0240 through 0377.

Can you read? Then please read my posts carefully next time.

Originally Posted by awsdert

Did you not catch my mention of %c and snprintf?

Yes, I know you said "%c" (I didn't think you were talking about the character 'c').
No, you never mentioned snprintf. You said "printf" in your first post and you said "printf/fprintf/sprintf" in your second. So I used printf in my post. I used 'c' as an example character. It could be any character.

Originally Posted by awsdert

there are code formats that go as large as 0x10000 or higher (such as UTF32)

printf and friends cannot deal with a character code of 0x10000 as a single character since that would need to be a wchar_t. Instead, they will deal with such a character as a series of bytes, hence the term "multi-byte". They don't need any special way to handle the multi-byte characters since all they need to do is send the individual bytes on to the output device which will deal with the multi-byte sequence (if it can).

Maybe this program will teach you something.

Code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
#include <wchar.h>
 
int main() {
    setlocale(LC_ALL, "en_US.utf8");
 
    const wchar_t *wcs = L"x£ΣאᏇ𝄞";  // 6 wide characters (plus a wide null char)
    char mb[MB_CUR_MAX + 1];
 
    for (const wchar_t *wc = wcs; *wc; ++wc) {
        int len = wctomb(mb, *wc);
        mb[len] = '\0';
 
        // Print the character (as a multi-byte character)
        // Print the wchar_t (as an integer, in hex)
        printf("%s  %08X  ", mb, *wc);
 
        // Print the separate bytes of the multi-byte character representation
        for (int i = 0; i < len; ++i)
            printf(" %02X", (unsigned char)mb[i]);
 
        putchar('\n');
    }
}