int main(int argc, char *argv[]) { int i; printf("1..2\n"); /* * C/POSIX locale. */ assert(btowc(EOF) == WEOF); assert(wctob(WEOF) == EOF); for (i = 0; i < UCHAR_MAX; i++) assert(btowc(i) == (wchar_t)i && i == (int)wctob(i)); /* * Japanese (EUC) locale. */ assert(strcmp(setlocale(LC_CTYPE, "ja_JP.eucJP"), "ja_JP.eucJP") == 0); assert(MB_CUR_MAX > 1); assert(btowc('A') == L'A' && wctob(L'A') == 'A'); assert(btowc(0xa3) == WEOF && wctob(0xa3c1) == EOF); printf("ok 1 - btowc()\n"); printf("ok 2 - wctob()\n"); return (0); }
static __inline int convert_wccl(FILE *fp, wchar_t *wcp, int width, const char *ccltab, locale_t locale) { mbstate_t mbs; wint_t wi; int n, nread; mbs = initial_mbs; n = 0; if (wcp == SUPPRESS_PTR) { while ((wi = __fgetwc_mbs(fp, &mbs, &nread, locale)) != WEOF && width-- != 0 && ccltab[wctob(wi)]) n += nread; if (wi != WEOF) __ungetwc(wi, fp, __get_locale()); } else { while ((wi = __fgetwc_mbs(fp, &mbs, &nread, locale)) != WEOF && width-- != 0 && ccltab[wctob(wi)]) { *wcp++ = (wchar_t)wi; n += nread; } if (wi != WEOF) __ungetwc(wi, fp, __get_locale()); if (n == 0) return (0); *wcp = 0; } return (n); }
int _Locale_wctob(struct _Locale_ctype *__loc, wint_t c) { int _c; /* __c_locale __tmp = __uselocale( __loc ); */ _c = wctob( c ); /* __uselocale( __tmp ); */ return _c; }
NCURSES_EXPORT(bool) _nc_is_charable(wchar_t ch) { bool result; #if HAVE_WCTOB result = (wctob((wint_t) ch) == (int) ch); #else result = (_nc_to_char(ch) >= 0); #endif return result; }
GLOBAL int test_btowc() { int i; char *locale; printf("1..2\n"); /* * C/POSIX locale. */ locale = setlocale(LC_CTYPE, "C"); assert(locale != NULL); assert(strcmp(locale, "C") == 0); assert(btowc(EOF) == WEOF); assert(wctob(WEOF) == EOF); for (i = 0; i < UCHAR_MAX; i++) assert(btowc(i) == (wchar_t)i && i == (int)wctob(i)); #if CRYSTAX_FULL_LOCALES /* * Japanese (EUC) locale. */ locale = setlocale(LC_CTYPE, "ja_JP.eucJP"); assert(locale != NULL); assert(strcmp(locale, "ja_JP.eucJP") == 0); assert(MB_CUR_MAX > 1); assert(btowc('A') == L'A' && wctob(L'A') == 'A'); assert(btowc(0xa3) == WEOF && wctob(0xa3c1) == EOF); #endif /* CRYSTAX_FULL_LOCALES */ printf("ok 1 - btowc()\n"); printf("ok 2 - wctob()\n"); return (0); }
void main() { int i, j; _setmbcp( 932 ); for( i = 0; i < SIZE; i++ ) { j = wctob( wc[i] ); if( j == EOF ) { printf( "%#6.4x EOF\n", wc[i] ); } else { printf( "%#6.4x->%#6.4x\n", wc[i], j ); } } }
NCURSES_EXPORT(int) _nc_to_char(wint_t ch) { int result; #if HAVE_WCTOB result = wctob(ch); #elif HAVE_WCTOMB char temp[MB_LEN_MAX]; result = wctomb(temp, ch); if (strlen(temp) == 1) result = UChar(temp[0]); else result = -1; #endif return result; }
/* Converts a LIBEWF character string to an EWF character string * Returns 1 if successful, 0 if string was not set, or -1 on error */ int8_t libewf_string_copy_to_ewf_char( LIBEWF_CHAR *string, size_t size_string, EWF_CHAR *ewf_char_string, size_t size_ewf_char_string ) { size_t iterator = 0; if( string == NULL ) { LIBEWF_WARNING_PRINT( "libewf_string_copy_to_ewf_char: invalid string.\n" ); return( -1 ); } if( ewf_char_string == NULL ) { LIBEWF_WARNING_PRINT( "libewf_string_copy_to_ewf_char: invalid EWF character string.\n" ); return( -1 ); } if( ( size_string > (size_t) SSIZE_MAX ) || ( size_ewf_char_string > (size_t) SSIZE_MAX ) ) { LIBEWF_WARNING_PRINT( "libewf_string_copy_to_ewf_char: invalid size value exceeds maximum.\n" ); return( -1 ); } if( size_ewf_char_string < size_string ) { LIBEWF_WARNING_PRINT( "libewf_string_copy_to_ewf_char: EWF character string too small.\n" ); return( -1 ); } for( iterator = 0; iterator < size_string; iterator++ ) { #ifdef HAVE_WIDE_CHARACTER_TYPE ewf_char_string[ iterator ] = (EWF_HEADER) wctob( string[ iterator ] ); /* If character is out of the basic ASCII range use '_' as a place holder */ if( ewf_char_string[ iterator ] == (EWF_HEADER) EOF ) { ewf_char_string[ iterator ] = (EWF_HEADER) '_'; } #else ewf_char_string[ iterator ] = (EWF_HEADER) string[ iterator ]; #endif } ewf_char_string[ size_string - 1 ] = (EWF_HEADER) '\0'; return( 1 ); }
int mpq_inp_wstr10(mpq_t rop, FILE* in) { char* buf = malloc(sizeof(char)); size_t len = 1; wint_t c; for(;;) { c = fgetwc(in); if(!(iswdigit(c) || (len == 1 && c == L'-') || (c == L'/'))) break; len++; buf = realloc(buf, sizeof(char) * len); buf[len - 2] = wctob(c); } buf[len - 1] = '\0'; ungetwc(c, in); int n = mpq_set_str(rop, buf, 10); free(buf); return n; }
void strip_wchar(CHAR *locale, char *stripped_locale) { CHAR *in = locale; char *out = stripped_locale; int len; int i; #ifdef proc_debug printf("strip_wchar start\n"); #endif /*printf("locale: -%d-%d-\n", locale[0], locale[1]); */ len = STRLEN(locale); /* copy stripped string to out */ for (i=0; i<len; i++) { out[i] = wctob(in[i]); } out[i] = 0x00; /*printf("out %s\n", stripped_locale); */ #ifdef proc_debug printf("strip_wchar end\n"); #endif } /* end strip_wchar */
/* Copies the source string (of wchar_t) into the destination string (of char) for a certain size * Terminates the destination string with \0 at ( size - 1 ) * Returns 1 if successful, -1 on error */ int8_t libewf_common_copy_wchar_to_char( char *destination, const wchar_t *source, size_t size ) { size_t iterator = 0; if( source == NULL ) { LIBEWF_WARNING_PRINT( "libewf_common_copy_wchar_to_char: invalid source.\n" ); return( -1 ); } if( destination == NULL ) { LIBEWF_WARNING_PRINT( "libewf_common_copy_wchar_to_char: invalid destination.\n" ); return( -1 ); } if( size > (size_t) SSIZE_MAX ) { LIBEWF_WARNING_PRINT( "libewf_common_copy_wchar_to_char: invalid size value exceeds maximum.\n" ); return( -1 ); } for( iterator = 0; iterator < size; iterator++ ) { destination[ iterator ] = (char) wctob( (wint_t) source[ iterator ] ); /* If character is out of the basic ASCII range use '_' as a place holder */ if( destination[ iterator ] == EOF ) { destination[ iterator ] = '_'; } } destination[ size - 1 ] = (char) '\0'; return( 1 ); }
int LedDeviceLightpackHidapi::testAndOpen(hid_device_info *device, const std::string & requestedSerialNumber) { if ((device->vendor_id == USB_VENDOR_ID && device->product_id == USB_PRODUCT_ID) || (device->vendor_id == USB_OLD_VENDOR_ID && device->product_id == USB_OLD_PRODUCT_ID)) { Debug(_log, "Found a lightpack device. Retrieving more information..."); // get the serial number std::string serialNumber = ""; if (device->serial_number != nullptr) { // the serial number needs to be converted to a char array instead of wchar size_t size = wcslen(device->serial_number); serialNumber.resize(size, '.'); for (size_t i = 0; i < size; ++i) { int c = wctob(device->serial_number[i]); if (c != EOF) { serialNumber[i] = c; } } } else { Error(_log, "No serial number for Lightpack device"); } Debug(_log, "Lightpack device found: path=%s serial=%s", device->path.c_str(), serialNumber.c_str()); // check if this is the device we are looking for if (requestedSerialNumber.empty() || requestedSerialNumber == serialNumber) { // This is it! _deviceHandle = hid_open_path(device->path); if (_deviceHandle != nullptr) { _serialNumber = serialNumber; Info(_log, "Lightpack device successfully opened"); // get the firmware version uint8_t buffer[256]; buffer[0] = 0; // report id int error = hid_get_feature_report(_deviceHandle, buffer, sizeof(buffer)); if (error < 4) { Error(_log, "Unable to retrieve firmware version number from Lightpack device"); } else { _firmwareVersion.majorVersion = buffer[INDEX_FW_VER_MAJOR+1]; _firmwareVersion.minorVersion = buffer[INDEX_FW_VER_MINOR+1]; } // FOR TESTING PURPOSE: FORCE MAJOR VERSION TO 6 _firmwareVersion.majorVersion = 6; // disable smoothing of the chosen device disableSmoothing(); // determine the number of leds if (_firmwareVersion.majorVersion == 4) { _hwLedCount = 8; } else { _hwLedCount = 10; } // determine the bits per channel if (_firmwareVersion.majorVersion == 6) { // maybe also or version 7? The firmware suggest this is only for 6... (2013-11-13) _bitsPerChannel = 12; } else { _bitsPerChannel = 8; } // set the led buffer size (repport id + command + 6 bytes per led) _ledBuffer = std::vector<uint8_t>(2 + _hwLedCount * 6, 0); _ledBuffer[0] = 0x0; // report id _ledBuffer[1] = CMD_UPDATE_LEDS; // return success Debug(_log,"Lightpack device opened: path=%s serial=%s version=%s.%s.%s", device->path.c_str(), _serialNumber.c_str(), _firmwareVersion.majorVersion.c_str(), _firmwareVersion.minorVersion.c_str()); return 0; } else { Warning(_log, "Unable to open Lightpack device. Searching for other device"); } } } return -1; }
int main (int argc, char *argv[]) { mbstate_t state; wchar_t wc; size_t ret; /* configure should already have checked that the locale is supported. */ if (setlocale (LC_ALL, "") == NULL) return 1; /* Test NUL byte input. */ { const char *src; memset (&state, '\0', sizeof (mbstate_t)); src = ""; ret = mbsrtowcs (NULL, &src, 0, &state); ASSERT (ret == 0); ASSERT (mbsinit (&state)); src = ""; ret = mbsrtowcs (NULL, &src, 1, &state); ASSERT (ret == 0); ASSERT (mbsinit (&state)); wc = (wchar_t) 0xBADFACE; src = ""; ret = mbsrtowcs (&wc, &src, 0, &state); ASSERT (ret == 0); ASSERT (wc == (wchar_t) 0xBADFACE); ASSERT (mbsinit (&state)); wc = (wchar_t) 0xBADFACE; src = ""; ret = mbsrtowcs (&wc, &src, 1, &state); ASSERT (ret == 0); ASSERT (wc == 0); ASSERT (mbsinit (&state)); } if (argc > 1) { int unlimited; for (unlimited = 0; unlimited < 2; unlimited++) { #define BUFSIZE 10 wchar_t buf[BUFSIZE]; const char *src; mbstate_t temp_state; { size_t i; for (i = 0; i < BUFSIZE; i++) buf[i] = (wchar_t) 0xBADFACE; } switch (argv[1][0]) { case '1': /* Locale encoding is ISO-8859-1 or ISO-8859-15. */ { char input[] = "B\374\337er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == (unsigned char) '\374'); ASSERT (mbsinit (&state)); input[1] = '\0'; src = input + 2; temp_state = state; ret = mbsrtowcs (NULL, &src, unlimited ? BUFSIZE : 1, &temp_state); ASSERT (ret == 3); ASSERT (src == input + 2); ASSERT (mbsinit (&state)); src = input + 2; ret = mbsrtowcs (buf, &src, unlimited ? BUFSIZE : 1, &state); ASSERT (ret == (unlimited ? 3 : 1)); ASSERT (src == (unlimited ? NULL : input + 3)); ASSERT (wctob (buf[0]) == (unsigned char) '\337'); if (unlimited) { ASSERT (buf[1] == 'e'); ASSERT (buf[2] == 'r'); ASSERT (buf[3] == 0); ASSERT (buf[4] == (wchar_t) 0xBADFACE); } else ASSERT (buf[1] == (wchar_t) 0xBADFACE); ASSERT (mbsinit (&state)); } break; case '2': /* Locale encoding is UTF-8. */ { char input[] = "B\303\274\303\237er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); ASSERT (wc == (wchar_t) 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; src = input + 2; temp_state = state; ret = mbsrtowcs (NULL, &src, unlimited ? BUFSIZE : 2, &temp_state); ASSERT (ret == 4); ASSERT (src == input + 2); ASSERT (!mbsinit (&state)); src = input + 2; ret = mbsrtowcs (buf, &src, unlimited ? BUFSIZE : 2, &state); ASSERT (ret == (unlimited ? 4 : 2)); ASSERT (src == (unlimited ? NULL : input + 5)); ASSERT (wctob (buf[0]) == EOF); ASSERT (wctob (buf[1]) == EOF); if (unlimited) { ASSERT (buf[2] == 'e'); ASSERT (buf[3] == 'r'); ASSERT (buf[4] == 0); ASSERT (buf[5] == (wchar_t) 0xBADFACE); } else ASSERT (buf[2] == (wchar_t) 0xBADFACE); ASSERT (mbsinit (&state)); } break; case '3': /* Locale encoding is EUC-JP. */ { char input[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */ memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == '<'); ASSERT (mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 1, 2, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); ASSERT (mbsinit (&state)); input[1] = '\0'; input[2] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 3, 1, &state); ASSERT (ret == (size_t)(-2)); ASSERT (wc == (wchar_t) 0xBADFACE); ASSERT (!mbsinit (&state)); input[3] = '\0'; src = input + 4; temp_state = state; ret = mbsrtowcs (NULL, &src, unlimited ? BUFSIZE : 2, &temp_state); ASSERT (ret == 3); ASSERT (src == input + 4); ASSERT (!mbsinit (&state)); src = input + 4; ret = mbsrtowcs (buf, &src, unlimited ? BUFSIZE : 2, &state); ASSERT (ret == (unlimited ? 3 : 2)); ASSERT (src == (unlimited ? NULL : input + 7)); ASSERT (wctob (buf[0]) == EOF); ASSERT (wctob (buf[1]) == EOF); if (unlimited) { ASSERT (buf[2] == '>'); ASSERT (buf[3] == 0); ASSERT (buf[4] == (wchar_t) 0xBADFACE); } else ASSERT (buf[2] == (wchar_t) 0xBADFACE); ASSERT (mbsinit (&state)); } break; case '4': /* Locale encoding is GB18030. */ { char input[] = "B\250\271\201\060\211\070er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); ASSERT (wc == (wchar_t) 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; src = input + 2; temp_state = state; ret = mbsrtowcs (NULL, &src, unlimited ? BUFSIZE : 2, &temp_state); ASSERT (ret == 4); ASSERT (src == input + 2); ASSERT (!mbsinit (&state)); src = input + 2; ret = mbsrtowcs (buf, &src, unlimited ? BUFSIZE : 2, &state); ASSERT (ret == (unlimited ? 4 : 2)); ASSERT (src == (unlimited ? NULL : input + 7)); ASSERT (wctob (buf[0]) == EOF); ASSERT (wctob (buf[1]) == EOF); if (unlimited) { ASSERT (buf[2] == 'e'); ASSERT (buf[3] == 'r'); ASSERT (buf[4] == 0); ASSERT (buf[5] == (wchar_t) 0xBADFACE); } else ASSERT (buf[2] == (wchar_t) 0xBADFACE); ASSERT (mbsinit (&state)); } break; default: return 1; } } return 0; } return 1; }
void decodeArgumentStrings( std::vector<std::string>& entity_arguments ) { std::vector<std::string>::iterator it = entity_arguments.begin(); for( ; it != entity_arguments.end(); ++it ) { std::string& argument_str = (*it); const size_t arg_length = argument_str.length(); std::string arg_str_new = ""; if( arg_length > 0 ) { arg_str_new.reserve(arg_length); char* stream_pos = (char*)argument_str.c_str(); // ascii characters from STEP file //char* stream_pos_new = (char*)arg_str_new.c_str(); // ascii characters from STEP file { while( *stream_pos != '\0' ) { if( *stream_pos == '\\' ) { if( *(stream_pos+1) == 'S' ) { if( *(stream_pos+2) == '\\' ) { if( *(stream_pos+3) != '\0' ) { if( *(stream_pos+4) == '\\' ) { if( *(stream_pos+5) == 'S' ) { if( *(stream_pos+6) == '\\' ) { if( *(stream_pos+7) != '\0' ) { char first = *(stream_pos+3); char second = *(stream_pos+7); //*stream_pos_new = char(125 + first + second); //++stream_pos_new; arg_str_new += char(125 + first + second); stream_pos += 8; continue; } } } } else { // next characters code value v shall be interpreted as v + 128 char char_pos = *(stream_pos+3); char char_pos_128 = char_pos + 128; //*stream_pos_new = char_pos_128; //++stream_pos_new; arg_str_new += char_pos_128; stream_pos += 4; continue; } } } } else if( *(stream_pos+1) == 'X' ) { if( *(stream_pos+2) == '\\' ) { wchar_t wc = Hex2Wchar(*(stream_pos+3), *(stream_pos+4)); #ifdef _WIN32 char char_ascii = wctob(wc); if( char_ascii < 0) { //we got a multibyte character here char buf[2]; int len = WideCharToMultiByte(CP_UTF8, 0, &wc, 1, buf, 2, nullptr, nullptr); arg_str_new+= buf[0]; arg_str_new+= buf[1]; } else { arg_str_new += char_ascii; } #else unsigned char char_ascii = wctob(wc); arg_str_new += char_ascii; #endif stream_pos += 4; continue; } else if( *(stream_pos+2) == '0' ) { if( *(stream_pos+3) == '\\' ) { stream_pos += 4; continue; } } else if( *(stream_pos+2) == '2' ) { if( *(stream_pos+3) == '\\' ) { // the following sequence of multiples of four hexadecimal characters shall be interpreted as encoding the // two-octet representation of characters from the BMP in ISO 10646 bool finished = false; stream_pos += 4; do { wchar_t wc = Hex4Wchar(*(stream_pos), *(stream_pos+1), *(stream_pos+2), *(stream_pos+3)); #ifdef _WIN32 char char_ascii = wctob(wc); if( char_ascii < 0 ) { //we got a multibyte character here char buf[2]; int len = WideCharToMultiByte(CP_UTF8, 0, &wc, 1, buf, 2, nullptr, nullptr); arg_str_new+= buf[0]; arg_str_new+= buf[1]; } else { arg_str_new+= char_ascii; } #else unsigned char char_ascii = wctob(wc); arg_str_new+= char_ascii; #endif stream_pos += 4; } while (( *stream_pos != '\0' ) && ( *stream_pos != '\\' )); continue; } } } else if( *(stream_pos+1) == 'N' ) { if( *(stream_pos+2) == '\\' ) { arg_str_new += "\n"; stream_pos += 3; continue; } } } arg_str_new+= *stream_pos; ++stream_pos; } } } argument_str.assign( arg_str_new ); } }
int main(int argc, char *argv[]) { mbstate_t state; wchar_t wc; size_t ret; int mode; /* configure should already have checked that the locale is supported. */ if (setlocale(LC_ALL, "") == NULL) { fprintf(stderr, "unable to set standard locale\n"); return 1; } /* Test NUL byte input. */ { const char *src; memset(&state, '\0', sizeof(mbstate_t)); src = ""; ret = mbsnrtowcs(NULL, &src, 1, 0, &state); assert(ret == 0); assert(mbsinit (&state)); src = ""; ret = mbsnrtowcs(NULL, &src, 1, 1, &state); assert(ret == 0); assert(mbsinit (&state)); wc = (wchar_t) 0xBADFACE; src = ""; ret = mbsnrtowcs(&wc, &src, 1, 0, &state); assert(ret == 0); assert(wc == (wchar_t) 0xBADFACE); assert(mbsinit (&state)); wc = (wchar_t) 0xBADFACE; src = ""; ret = mbsnrtowcs(&wc, &src, 1, 1, &state); assert(ret == 0); assert(wc == 0); assert(mbsinit (&state)); } for (mode = '1'; mode <= '4'; ++mode) { int unlimited; for (unlimited = 0; unlimited < 2; unlimited++) { wchar_t buf[BUFSIZE]; const char *src; mbstate_t temp_state; { size_t i; for (i = 0; i < BUFSIZE; i++) buf[i] = (wchar_t) 0xBADFACE; } switch (mode) { case '1': /* Locale encoding is ISO-8859-1 or ISO-8859-15. */ printf("ISO8859-1 ...\n"); { char input[] = "B\374\337er"; /* "Büßer" */ memset(&state, '\0', sizeof(mbstate_t)); if (setlocale (LC_ALL, "en_US.ISO8859-1") == NULL) { fprintf(stderr, "unable to set ISO8859-1 locale, skipping\n"); break; } wc = (wchar_t) 0xBADFACE; ret = mbrtowc(&wc, input, 1, &state); assert(ret == 1); assert(wc == 'B'); assert(mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc(&wc, input + 1, 1, &state); assert(ret == 1); assert(wctob (wc) == (unsigned char) '\374'); assert(mbsinit (&state)); input[1] = '\0'; src = input + 2; temp_state = state; ret = mbsnrtowcs(NULL, &src, 4, unlimited ? BUFSIZE : 1, &temp_state); assert(ret == 3); assert(src == input + 2); assert(mbsinit (&state)); src = input + 2; ret = mbsnrtowcs(buf, &src, 4, unlimited ? BUFSIZE : 1, &state); assert(ret == (unlimited ? 3 : 1)); assert(src == (unlimited ? NULL : input + 3)); assert(wctob (buf[0]) == (unsigned char) '\337'); if (unlimited) { assert(buf[1] == 'e'); assert(buf[2] == 'r'); assert(buf[3] == 0); assert(buf[4] == (wchar_t) 0xBADFACE); } else assert(buf[1] == (wchar_t) 0xBADFACE); assert(mbsinit (&state)); } break; case '2': /* Locale encoding is UTF-8. */ printf("UTF-8 ...\n"); { char input[] = "B\303\274\303\237er"; /* "Büßer" */ memset(&state, '\0', sizeof(mbstate_t)); if (setlocale (LC_ALL, "en_US.UTF-8") == NULL) { fprintf(stderr, "unable to set UTF-8 locale, skipping\n"); break; } wc = (wchar_t) 0xBADFACE; ret = mbrtowc(&wc, input, 1, &state); assert(ret == 1); assert(wc == 'B'); assert(mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc(&wc, input + 1, 1, &state); assert(ret == (size_t)(-2)); assert(wc == (wchar_t) 0xBADFACE); assert(!mbsinit (&state)); input[1] = '\0'; // Copying mbstate_t doesn't really copy the ICU-converter's state, so this // doesn't work on Haiku. #ifndef __HAIKU__ src = input + 2; temp_state = state; ret = mbsnrtowcs(NULL, &src, 6, unlimited ? BUFSIZE : 2, &temp_state); assert(ret == 4); assert(src == input + 2); assert(!mbsinit (&state)); #endif src = input + 2; ret = mbsnrtowcs(buf, &src, 6, unlimited ? BUFSIZE : 2, &state); assert(ret == (unlimited ? 4 : 2)); assert(src == (unlimited ? NULL : input + 5)); assert(wctob (buf[0]) == EOF); assert(wctob (buf[1]) == EOF); if (unlimited) { assert(buf[2] == 'e'); assert(buf[3] == 'r'); assert(buf[4] == 0); assert(buf[5] == (wchar_t) 0xBADFACE); } else assert(buf[2] == (wchar_t) 0xBADFACE); assert(mbsinit (&state)); } break; case '3': /* Locale encoding is EUC-JP. */ printf("EUC-JP ...\n"); { char input[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */ memset(&state, '\0', sizeof(mbstate_t)); if (setlocale (LC_ALL, "en_US.EUC-JP") == NULL) { fprintf(stderr, "unable to set EUC-JP locale, skipping\n"); break; } wc = (wchar_t) 0xBADFACE; ret = mbrtowc(&wc, input, 1, &state); assert(ret == 1); assert(wc == '<'); assert(mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc(&wc, input + 1, 2, &state); assert(ret == 2); assert(wctob (wc) == EOF); assert(mbsinit (&state)); input[1] = '\0'; input[2] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc(&wc, input + 3, 1, &state); assert(ret == (size_t)(-2)); assert(wc == (wchar_t) 0xBADFACE); assert(!mbsinit (&state)); input[3] = '\0'; // Copying mbstate_t doesn't really copy the ICU-converter's state, so this // doesn't work on Haiku. #ifndef __HAIKU__ src = input + 4; temp_state = state; ret = mbsnrtowcs(NULL, &src, 5, unlimited ? BUFSIZE : 2, &temp_state); assert(ret == 3); assert(src == input + 4); assert(!mbsinit (&state)); #endif src = input + 4; ret = mbsnrtowcs(buf, &src, 5, unlimited ? BUFSIZE : 2, &state); assert(ret == (unlimited ? 3 : 2)); assert(src == (unlimited ? NULL : input + 7)); assert(wctob (buf[0]) == EOF); assert(wctob (buf[1]) == EOF); if (unlimited) { assert(buf[2] == '>'); assert(buf[3] == 0); assert(buf[4] == (wchar_t) 0xBADFACE); } else assert(buf[2] == (wchar_t) 0xBADFACE); assert(mbsinit (&state)); } break; case '4': /* Locale encoding is GB18030. */ printf("GB18030 ...\n"); { char input[] = "B\250\271\201\060\211\070er"; /* "Büßer" */ memset(&state, '\0', sizeof(mbstate_t)); if (setlocale (LC_ALL, "en_US.GB18030") == NULL) { fprintf(stderr, "unable to set GB18030 locale, skipping\n"); break; } wc = (wchar_t) 0xBADFACE; ret = mbrtowc(&wc, input, 1, &state); assert(ret == 1); assert(wc == 'B'); assert(mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc(&wc, input + 1, 1, &state); assert(ret == (size_t)(-2)); assert(wc == (wchar_t) 0xBADFACE); assert(!mbsinit (&state)); input[1] = '\0'; // Copying mbstate_t doesn't really copy the ICU-converter's state, so this // doesn't work on Haiku. #ifndef __HAIKU__ src = input + 2; temp_state = state; ret = mbsnrtowcs(NULL, &src, 8, unlimited ? BUFSIZE : 2, &temp_state); assert(ret == 4); assert(src == input + 2); assert(!mbsinit (&state)); #endif src = input + 2; ret = mbsnrtowcs(buf, &src, 8, unlimited ? BUFSIZE : 2, &state); assert(ret == (unlimited ? 4 : 2)); assert(src == (unlimited ? NULL : input + 7)); assert(wctob (buf[0]) == EOF); assert(wctob (buf[1]) == EOF); if (unlimited) { assert(buf[2] == 'e'); assert(buf[3] == 'r'); assert(buf[4] == 0); assert(buf[5] == (wchar_t) 0xBADFACE); } else assert(buf[2] == (wchar_t) 0xBADFACE); assert(mbsinit (&state)); } break; default: return 1; } } } return 0; }
/* We provide support for some special names. This helps debugging and may be useful for advanced usage of the provided information outside C. */ void locale_special (const char *name, int show_category_name, int show_keyword_name) { #if 0 /* "collate-elements": print collation elements of locale. */ if (strcmp (name, "collate-elements") == 0) { size_t nelem = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_ELEM_HASH_SIZE); if (show_category_name) puts ("LC_COLLATE"); if (show_keyword_name) fputs ("collate-elements=", stdout); if (nelem != 0) { int first = 1; size_t cnt; for (cnt = 0; cnt < nelem; ++cnt) if (__collate_element_hash[2 * cnt] != (~((u_int32_t) 0))) { size_t idx = __collate_element_hash[2 * cnt]; printf ("%s<%s>", first ? "" : ";", &__collate_element_strings[idx]); /* We don't print the string. This is only confusing because only the programs have to know the encoding. The code is left in place because it shows how to get the information. */ { const wchar_t *wp; idx = __collate_element_hash[2 * cnt + 1]; wp = &__collate_element_values[idx]; while (*wp != L'\0') { /********************************************\ |* XXX The element values are really wide *| |* chars. But we are currently not able to *| |* print these so fake here. *| \********************************************/ int ch = wctob (*wp++); if (ch != EOF) putchar (ch); else fputs ("<??\?>", stdout); } putchar ('"'); } first = 0; } } putchar ('\n'); return; } if (strcmp (name, "collate-classes") == 0) { size_t nelem = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_SYMB_HASH_SIZE); size_t cnt; int first = 1; if (show_category_name) puts ("LC_COLLATE"); if (show_keyword_name) fputs ("collate-classes=", stdout); for (cnt = 0; cnt < nelem; ++cnt) if (__collate_symbol_hash[2 * cnt] != 0xffffffff) { printf ("%s<%s>", first ? "" : ",", &__collate_symbol_strings[__collate_symbol_hash[2 * cnt]]); #if 0 { size_t idx = __collate_symbol_hash[2 * cnt + 1]; size_t cls; putchar ('='); for (cls = 0; cls < __collate_symbol_classes[idx]; ++cls) printf ("%s%d", cls == 0 ? "" : ":", __collate_symbol_classes[idx + 1 + cls]); } #endif first = 0; } putchar ('\n'); return; } #endif }
int main() { mbstate_t mb = {0}; size_t s = 0; tm tm = {0}; wint_t w = 0; ::FILE* fp = 0; __darwin_va_list va; char* ns = 0; wchar_t* ws = 0; static_assert((std::is_same<decltype(fwprintf(fp, L"")), int>::value), ""); static_assert((std::is_same<decltype(fwscanf(fp, L"")), int>::value), ""); static_assert((std::is_same<decltype(swprintf(ws, s, L"")), int>::value), ""); static_assert((std::is_same<decltype(swscanf(L"", L"")), int>::value), ""); static_assert((std::is_same<decltype(vfwprintf(fp, L"", va)), int>::value), ""); static_assert((std::is_same<decltype(vfwscanf(fp, L"", va)), int>::value), ""); static_assert((std::is_same<decltype(vswprintf(ws, s, L"", va)), int>::value), ""); static_assert((std::is_same<decltype(vswscanf(L"", L"", va)), int>::value), ""); static_assert((std::is_same<decltype(vwprintf(L"", va)), int>::value), ""); static_assert((std::is_same<decltype(vwscanf(L"", va)), int>::value), ""); static_assert((std::is_same<decltype(wprintf(L"")), int>::value), ""); static_assert((std::is_same<decltype(wscanf(L"")), int>::value), ""); static_assert((std::is_same<decltype(fgetwc(fp)), wint_t>::value), ""); static_assert((std::is_same<decltype(fgetws(ws, 0, fp)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(fputwc(L' ', fp)), wint_t>::value), ""); static_assert((std::is_same<decltype(fputws(L"", fp)), int>::value), ""); static_assert((std::is_same<decltype(fwide(fp, 0)), int>::value), ""); static_assert((std::is_same<decltype(getwc(fp)), wint_t>::value), ""); static_assert((std::is_same<decltype(getwchar()), wint_t>::value), ""); static_assert((std::is_same<decltype(putwc(L' ', fp)), wint_t>::value), ""); static_assert((std::is_same<decltype(putwchar(L' ')), wint_t>::value), ""); static_assert((std::is_same<decltype(ungetwc(L' ', fp)), wint_t>::value), ""); static_assert((std::is_same<decltype(wcstod(L"", (wchar_t**)0)), double>::value), ""); static_assert((std::is_same<decltype(wcstof(L"", (wchar_t**)0)), float>::value), ""); static_assert((std::is_same<decltype(wcstold(L"", (wchar_t**)0)), long double>::value), ""); static_assert((std::is_same<decltype(wcstol(L"", (wchar_t**)0, 0)), long>::value), ""); static_assert((std::is_same<decltype(wcstoll(L"", (wchar_t**)0, 0)), long long>::value), ""); static_assert((std::is_same<decltype(wcstoul(L"", (wchar_t**)0, 0)), unsigned long>::value), ""); static_assert((std::is_same<decltype(wcstoull(L"", (wchar_t**)0, 0)), unsigned long long>::value), ""); static_assert((std::is_same<decltype(wcscpy(ws, L"")), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcsncpy(ws, L"", s)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcscat(ws, L"")), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcsncat(ws, L"", s)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcscmp(L"", L"")), int>::value), ""); static_assert((std::is_same<decltype(wcscoll(L"", L"")), int>::value), ""); static_assert((std::is_same<decltype(wcsncmp(L"", L"", s)), int>::value), ""); static_assert((std::is_same<decltype(wcsxfrm(ws, L"", s)), size_t>::value), ""); static_assert((std::is_same<decltype(wcschr((wchar_t*)0, L' ')), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcscspn(L"", L"")), size_t>::value), ""); static_assert((std::is_same<decltype(wcslen(L"")), size_t>::value), ""); static_assert((std::is_same<decltype(wcspbrk((wchar_t*)0, L"")), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcsrchr((wchar_t*)0, L' ')), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcsspn(L"", L"")), size_t>::value), ""); static_assert((std::is_same<decltype(wcsstr((wchar_t*)0, L"")), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcstok(ws, L"", (wchar_t**)0)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wmemchr((wchar_t*)0, L' ', s)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wmemcmp(L"", L"", s)), int>::value), ""); static_assert((std::is_same<decltype(wmemcpy(ws, L"", s)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wmemmove(ws, L"", s)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wmemset(ws, L' ', s)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcsftime(ws, s, L"", &tm)), size_t>::value), ""); static_assert((std::is_same<decltype(btowc(0)), wint_t>::value), ""); static_assert((std::is_same<decltype(wctob(w)), int>::value), ""); static_assert((std::is_same<decltype(mbsinit(&mb)), int>::value), ""); static_assert((std::is_same<decltype(mbrlen("", s, &mb)), size_t>::value), ""); static_assert((std::is_same<decltype(mbrtowc(ws, "", s, &mb)), size_t>::value), ""); static_assert((std::is_same<decltype(wcrtomb(ns, L' ', &mb)), size_t>::value), ""); static_assert((std::is_same<decltype(mbsrtowcs(ws, (const char**)0, s, &mb)), size_t>::value), ""); static_assert((std::is_same<decltype(wcsrtombs(ns, (const wchar_t**)0, s, &mb)), size_t>::value), ""); }
int _Locale_wctob(struct _Locale_ctype *l, wint_t c) { return wctob(c); }
int main(int argc, char **argv) { const char *fields_file = ""; const char *config_file = ""; #if LIBEDIT_IS_UNICODE wchar_t wc; #endif char cmd_buf[500]; const char *cmd; int cmd_len; bool version = false; const char *cfile = NULL; size_t n; nmsg_res res; char *p; int i; axa_set_me(argv[0]); AXA_ASSERT(axa_parse_log_opt(NULL, "trace,off,stderr")); AXA_ASSERT(axa_parse_log_opt(NULL, "error,off,stderr")); axa_syslog_init(); axa_set_core(); axa_client_init(&client); if (strcmp(axa_prog_name, "radtool") == 0) mode = RAD; if (isatty(STDIN_FILENO)) el_e = el_init(axa_prog_name, stdin, stdout, stderr); if (el_e != NULL) { int flag; if (0 > el_get(el_e, EL_EDITMODE, &flag) || !flag) { el_end(el_e); el_e = NULL; } } if (el_e != NULL) { /* prefer emacs mode but let the user choose in .editrc */ el_set(el_e, EL_EDITOR, "emacs"); /* bind emacs search to ^R */ el_set(el_e, EL_BIND, "\022", "em-inc-search-prev", NULL); el_source(el_e, NULL); el_history = history_init(); history(el_history, &el_event, H_SETSIZE, 800); history_get_savefile(); history(el_history, &el_event, H_LOAD, history_savefile); el_set(el_e, EL_HIST, history, el_history); el_set(el_e, EL_PROMPT, el_prompt); el_set(el_e, EL_SIGNAL, 1); el_set(el_e, EL_GETCFN, getcfn); } while ((i = getopt(argc, argv, "hVdNF:E:S:c:n:")) != -1) { switch (i) { case 'n': config_file = optarg; break; case 'V': version = true; break; case 'h': usage(); break; case 'd': ++axa_debug; break; case 'N': no_prompt = true; break; case 'F': fields_file = optarg; break; case 'E': if (axa_tls_cipher_list(&emsg, optarg) == NULL) error_msg("%s", emsg.c); break; case 'S': if (!axa_tls_certs_dir(&emsg, optarg)) error_msg("%s", emsg.c); break; case 'c': if (cfile != NULL) error_msg("only one -c allowed;" " ignoring all but the last"); cfile = optarg; break; default: usage(); } } argc -= optind; argv += optind; if (version) { version_cmd(AXA_TAG_NONE, "", NULL); if (argc == 0) stop(EX_OK); } signal(SIGPIPE, SIG_IGN); if (el_e != NULL) { signal(SIGINT, sigint); signal(SIGTERM, sigterm); signal(SIGHUP, sigterm); } AXA_DEBUG_TO_NMSG(axa_debug); res = nmsg_init(); if (res != nmsg_res_success) { error_msg("nmsg_init(): %s", nmsg_res_lookup(res)); exit(EX_SOFTWARE); } nmsg_input = nmsg_input_open_null(); AXA_ASSERT(nmsg_input != NULL); nmsg_pres = nmsg_output_open_pres(STDOUT_FILENO); axa_load_fields(fields_file); if (!axa_load_client_config(&emsg, config_file)) { axa_error_msg("can't load config file: %s", emsg.c); exit(EXIT_FAILURE); } /* Answer commands from the control file. */ if (cfile != NULL) { axa_asprintf(&p, "source %s", cfile); if (el_e != NULL) history(el_history, &el_event, H_ENTER, p); if (!do_cmds(p)) error_msg(" initial \"-c %s\" failed", cfile); free(p); } /* Answer commands from the command line. */ while (argc != 0) { if (el_e != NULL) history(el_history, &el_event, H_ENTER, *argv); if (!do_cmds(*argv)) { error_msg(" initial command \"%s\" failed", *argv); break; } ++argv; --argc; } for (;;) { cmd_input.tv_sec = 0; fflush(stderr); fflush(stdout); if (in_file_cur > 0) { /* Get a command from a "sourced" file. */ if (interrupted) { close_in_files(); continue; } cmd = axa_fgetln(in_files[in_file_cur].f, in_files[in_file_cur].name, &in_files[in_file_cur].lineno, &in_files[in_file_cur].buf, &in_files[in_file_cur].buf_size); if (cmd == NULL) { close_in_file_cur(); continue; } if (axa_debug != 0) { printf("< %s\n", cmd); fflush(stdout); } } else if (el_e != NULL) { /* Get a command from the terminal via editline(3). */ cmd = el_gets(el_e, &cmd_len); prompt_len = 0; if (!interrupted) { if (cmd == NULL) { fputc('\n', stdout); if (cmd_len == -1) error_msg("el_gets(): %s", strerror(errno)); stop(EX_OK); } /* Save nontrivial command lines. */ if (*(cmd+strspn(cmd, AXA_WHITESPACE)) != '\0') history(el_history, &el_event, H_ENTER, cmd); } } else if (!interrupted) { /* Get a command from stdin. */ n = 0; for (;;) { #if LIBEDIT_IS_UNICODE getcfn(NULL, &wc); cmd_buf[n] = wctob(wc); #else getcfn(NULL, &cmd_buf[n]); #endif if (cmd_buf[n++] == '\n' || n >= sizeof(cmd_buf)-1) break; } cmd_buf[n] = '\0'; cmd = cmd_buf; } if (interrupted) { interrupted = false; if (el_e != NULL) { el_set(el_e, EL_UNBUFFERED, 0); el_reset(el_e); if (prompt_cleared.tv_sec != 0) { packet_counting = true; packet_count = 0; packet_count_total = 0; } } close_in_files(); fputs(" (int)\n", stdout); continue; } if (!do_cmds(cmd)) { fputs(" ?\n", stderr); fflush(stdout); close_in_files(); } } }
void VOICEREC_execute_command(ISpPhrase *pPhrase, HWND hWnd) { SPPHRASE *pElements; // Get the phrase elements, one of which is the rule id we specified in // the grammar. Switch on it to figure out which command was recognized. if (SUCCEEDED(pPhrase->GetPhrase(&pElements))) { #ifndef NDEBUG if(DEBUG_ON) { WCHAR *pwszText; char szText[255]; int i; pPhrase->GetText(static_cast<ULONG>(SP_GETWHOLEPHRASE), static_cast<ULONG>(SP_GETWHOLEPHRASE), TRUE, &pwszText, NULL); memset(szText, 0, 255); for (i=0;i<254;i++) { if (*(pwszText + i) == 0) { break; } szText[i] = (char)(*(pwszText + i)); szText[i+1] = 0; } mprintf(( "recognized speech : %s \n", szText )); mprintf(( "speech Rule.ulId : %d \n", pElements->Rule.ulId )); mprintf(( "confidence: %f \n", pElements->pProperties->SREngineConfidence)); ::CoTaskMemFree(pwszText); } #endif int part1, part2, part3; part1 = part2 = part3 = -1; switch ( pElements->Rule.ulId ) { case VID_WingName: { part1 = pElements->pProperties->vValue.ulVal; if (pElements->pProperties->pNextSibling) { part2 = pElements->pProperties->pNextSibling->vValue.ulVal; if (pElements->pProperties->pNextSibling->pNextSibling) { part3 = pElements->pProperties->pNextSibling->pNextSibling->vValue.ulVal; } } if (part2 == -1) break; // no ship number or wing const wchar_t* valstr = pElements->pProperties->pszValue; char* wing_name = new char[wcslen(valstr)+1]; size_t j = 0; for (size_t i = 0; i < wcslen(valstr); i++) { int c = wctob(valstr[i]); if (c != EOF) { wing_name[j++] = static_cast<char>(c); } } wing_name[j] = '\0'; if (part2 == 0) { Msg_instance = wing_lookup(wing_name); delete[] wing_name; if (Msg_instance < 0) break; if(!(Player->flags & PLAYER_FLAGS_MSG_MODE)) { hud_squadmsg_toggle(); } if (hud_squadmsg_wing_valid(&Wings[Msg_instance])) hud_squadmsg_do_mode(SM_MODE_WING_COMMAND); } else { char shipName[NAME_LENGTH]; wing_bash_ship_name(shipName, wing_name, part2); delete[] wing_name; Msg_instance = ship_name_lookup(shipName); // Can't issue commands to yourself or to nobody if (Msg_instance < 0 || Msg_instance == Player_obj->instance) { break; } if(!(Player->flags & PLAYER_FLAGS_MSG_MODE)) { hud_squadmsg_toggle(); } if (hud_squadmsg_ship_valid(&Ships[Msg_instance])) hud_squadmsg_do_mode(SM_MODE_SHIP_COMMAND); } if (part3 == -1) break; } case VID_Action: { int action; if (part3 == -1) { action = pElements->pProperties->vValue.ulVal; } else { action = part3; } doVid_Action(action); break; } // These commands run no matter what, and will even bring up the menu case VID_TopMenu: { int action = pElements->pProperties->vValue.ulVal; bool msgWindow = false; if (Player->flags & PLAYER_FLAGS_MSG_MODE) { msgWindow = true; } // If the command window is not up, or it is and its a cancel request toggle if((msgWindow && action == VID_Cancel) || (!msgWindow && action != VID_Cancel)) { hud_squadmsg_toggle(); } switch(action) { case VID_Ships: hud_squadmsg_do_mode( SM_MODE_SHIP_SELECT ); break; case VID_Wings: hud_squadmsg_do_mode( SM_MODE_WING_SELECT ); break; case VID_AllFighters: case VID_AllWings: hud_squadmsg_msg_all_fighters(); // can have the action to perform spoken directly afterwards if (pElements->pProperties->pFirstChild) { doVid_Action(pElements->pProperties->pFirstChild->vValue.ulVal); } break; case VID_Reinforcements: hud_squadmsg_do_mode( SM_MODE_REINFORCEMENTS ); break; case VID_SupportShip: hud_squadmsg_do_mode( SM_MODE_REPAIR_REARM ); break; case VID_AbortSupport: hud_squadmsg_do_mode( SM_MODE_REPAIR_REARM_ABORT ); break; case VID_More: break; } break; } // phrases for transferring shield energy to different locations case VID_shields: { int action = pElements->pProperties->vValue.ulVal; switch(action) { case 0: button_function( SHIELD_XFER_TOP ); break; case 1: button_function( SHIELD_XFER_LEFT ); break; case 2: button_function( SHIELD_XFER_RIGHT ); break; case 3: button_function( SHIELD_XFER_BOTTOM ); break; case 4: button_function( SHIELD_EQUALIZE ); break; } break; } // basic cheat, phrase as a value equivalent to the defines in ControlConfig/ControlsConfig.h // it just calls the button_function with this value case VID_speed: case VID_targeting: case VID_other: { int action = pElements->pProperties->vValue.ulVal; if (action > -1) { button_function( action ); } break; } // nearly the same as the previous except it has some extra entries for // maximising/minimising energy case VID_power: { int action = pElements->pProperties->vValue.ulVal; if (action >= INCREASE_WEAPON && action <= ETS_EQUALIZE) { button_function( action ); } else { // this is for the max engines etc. for (int i=1; i<7; i++) { button_function( action - 132 ); } } break; } } // Free the pElements memory which was allocated for us ::CoTaskMemFree(pElements); } }
char GetVolumeLabelByDiskNumber(DWORD dwDeviceNumber) { /* The returned value is like C:\ and a null terminator seperating each drive root hence 4 characters per letter */ wchar_t wszDrives[26 * 4]; DWORD dwSize = GetLogicalDriveStrings(sizeof(wszDrives), wszDrives); DWORD dwBytesReturned = 0; if (dwSize) { for (unsigned int uiCharIndex = 0; uiCharIndex <= dwSize; uiCharIndex += 4) { STORAGE_DEVICE_NUMBER storageDeviceNumber; ZeroMemory(&storageDeviceNumber, sizeof(STORAGE_DEVICE_NUMBER)); storageDeviceNumber.DeviceNumber = 0; /* To obtain a drive handle we need to use CreateFile with a path like \\.\C: */ wchar_t wszDrivePath[MAX_PATH]; wcscpy_s(wszDrivePath, L"\\\\.\\"); wcscat_s(wszDrivePath, wszDrives + uiCharIndex); wszDrivePath[wcslen(wszDrivePath) - 1] = L'\0'; HANDLE hDrive = CreateFile( wszDrivePath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0 ); if (hDrive != INVALID_HANDLE_VALUE) { /* Get the device number of the device and compare it to our device's device number */ BOOL bResult = DeviceIoControl( hDrive, IOCTL_STORAGE_GET_DEVICE_NUMBER, NULL, 0, &storageDeviceNumber, sizeof(storageDeviceNumber), &dwBytesReturned, NULL ); if (bResult && dwBytesReturned) { if (storageDeviceNumber.DeviceNumber == dwDeviceNumber) { char cDrive = wctob(wszDrives[uiCharIndex]); return cDrive; } } } CloseHandle(hDrive); } } return NULL; }
/** * Returns TRUE if this token is a special token and it is equal to c */ static int is_equal(Dictionary dict, wint_t c) { return (dict->is_special && wctob(c) == dict->token[0] && dict->token[1] == '\0'); }
int main() { // mbstate_t comes from the underlying C library; it is defined (in C99) as: // a complete object type other than an array type that can hold the conversion // state information necessary to convert between sequences of multibyte // characters and wide characters #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wmissing-braces" #endif mbstate_t mb = {0}; #if defined(__clang__) #pragma clang diagnostic pop #endif size_t s = 0; tm *tm = 0; wint_t w = 0; ::FILE* fp = 0; #ifdef __APPLE__ __darwin_va_list va; #else __builtin_va_list va; #endif char* ns = 0; wchar_t* ws = 0; static_assert((std::is_same<decltype(fwprintf(fp, L"")), int>::value), ""); static_assert((std::is_same<decltype(fwscanf(fp, L"")), int>::value), ""); static_assert((std::is_same<decltype(swprintf(ws, s, L"")), int>::value), ""); static_assert((std::is_same<decltype(swscanf(L"", L"")), int>::value), ""); static_assert((std::is_same<decltype(vfwprintf(fp, L"", va)), int>::value), ""); static_assert((std::is_same<decltype(vfwscanf(fp, L"", va)), int>::value), ""); static_assert((std::is_same<decltype(vswprintf(ws, s, L"", va)), int>::value), ""); static_assert((std::is_same<decltype(vswscanf(L"", L"", va)), int>::value), ""); static_assert((std::is_same<decltype(fgetwc(fp)), wint_t>::value), ""); static_assert((std::is_same<decltype(fgetws(ws, 0, fp)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(fputwc(L' ', fp)), wint_t>::value), ""); static_assert((std::is_same<decltype(fputws(L"", fp)), int>::value), ""); static_assert((std::is_same<decltype(fwide(fp, 0)), int>::value), ""); static_assert((std::is_same<decltype(getwc(fp)), wint_t>::value), ""); static_assert((std::is_same<decltype(putwc(L' ', fp)), wint_t>::value), ""); static_assert((std::is_same<decltype(ungetwc(L' ', fp)), wint_t>::value), ""); static_assert((std::is_same<decltype(wcstod(L"", (wchar_t**)0)), double>::value), ""); static_assert((std::is_same<decltype(wcstof(L"", (wchar_t**)0)), float>::value), ""); static_assert((std::is_same<decltype(wcstold(L"", (wchar_t**)0)), long double>::value), ""); static_assert((std::is_same<decltype(wcstol(L"", (wchar_t**)0, 0)), long>::value), ""); static_assert((std::is_same<decltype(wcstoll(L"", (wchar_t**)0, 0)), long long>::value), ""); static_assert((std::is_same<decltype(wcstoul(L"", (wchar_t**)0, 0)), unsigned long>::value), ""); static_assert((std::is_same<decltype(wcstoull(L"", (wchar_t**)0, 0)), unsigned long long>::value), ""); static_assert((std::is_same<decltype(wcscpy(ws, L"")), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcsncpy(ws, L"", s)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcscat(ws, L"")), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcsncat(ws, L"", s)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcscmp(L"", L"")), int>::value), ""); static_assert((std::is_same<decltype(wcscoll(L"", L"")), int>::value), ""); static_assert((std::is_same<decltype(wcsncmp(L"", L"", s)), int>::value), ""); static_assert((std::is_same<decltype(wcsxfrm(ws, L"", s)), size_t>::value), ""); static_assert((std::is_same<decltype(wcschr((wchar_t*)0, L' ')), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcscspn(L"", L"")), size_t>::value), ""); static_assert((std::is_same<decltype(wcslen(L"")), size_t>::value), ""); static_assert((std::is_same<decltype(wcspbrk((wchar_t*)0, L"")), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcsrchr((wchar_t*)0, L' ')), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcsspn(L"", L"")), size_t>::value), ""); static_assert((std::is_same<decltype(wcsstr((wchar_t*)0, L"")), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcstok(ws, L"", (wchar_t**)0)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wmemchr((wchar_t*)0, L' ', s)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wmemcmp(L"", L"", s)), int>::value), ""); static_assert((std::is_same<decltype(wmemcpy(ws, L"", s)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wmemmove(ws, L"", s)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wmemset(ws, L' ', s)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcsftime(ws, s, L"", tm)), size_t>::value), ""); static_assert((std::is_same<decltype(btowc(0)), wint_t>::value), ""); static_assert((std::is_same<decltype(wctob(w)), int>::value), ""); static_assert((std::is_same<decltype(mbsinit(&mb)), int>::value), ""); static_assert((std::is_same<decltype(mbrlen("", s, &mb)), size_t>::value), ""); static_assert((std::is_same<decltype(mbrtowc(ws, "", s, &mb)), size_t>::value), ""); static_assert((std::is_same<decltype(wcrtomb(ns, L' ', &mb)), size_t>::value), ""); static_assert((std::is_same<decltype(mbsrtowcs(ws, (const char**)0, s, &mb)), size_t>::value), ""); static_assert((std::is_same<decltype(wcsrtombs(ns, (const wchar_t**)0, s, &mb)), size_t>::value), ""); // These tests fail on systems whose C library doesn't provide a correct overload // set for wcschr, wcspbrk, wcsrchr, wcsstr, and wmemchr, unless the compiler is // a suitably recent version of Clang. #if !defined(__APPLE__) || defined(_LIBCPP_PREFERRED_OVERLOAD) static_assert((std::is_same<decltype(wcschr((const wchar_t*)0, L' ')), const wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcspbrk((const wchar_t*)0, L"")), const wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcsrchr((const wchar_t*)0, L' ')), const wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcsstr((const wchar_t*)0, L"")), const wchar_t*>::value), ""); static_assert((std::is_same<decltype(wmemchr((const wchar_t*)0, L' ', s)), const wchar_t*>::value), ""); #endif #ifndef _LIBCPP_HAS_NO_STDIN static_assert((std::is_same<decltype(getwchar()), wint_t>::value), ""); static_assert((std::is_same<decltype(vwscanf(L"", va)), int>::value), ""); static_assert((std::is_same<decltype(wscanf(L"")), int>::value), ""); #endif #ifndef _LIBCPP_HAS_NO_STDOUT static_assert((std::is_same<decltype(putwchar(L' ')), wint_t>::value), ""); static_assert((std::is_same<decltype(vwprintf(L"", va)), int>::value), ""); static_assert((std::is_same<decltype(wprintf(L"")), int>::value), ""); #endif }
int main (int argc, char *argv[]) { mbstate_t state; wchar_t wc; size_t ret; int i; /* configure should already have checked that the locale is supported. */ if (setlocale (LC_ALL, "") == NULL) { fprintf(stderr, "unable to set standard locale\n"); return 1; } /* Test zero-length input. */ printf("zero-length input ...\n"); { memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "x", 0, &state); /* gnulib's implementation returns (size_t)(-2). The AIX 5.1 implementation returns (size_t)(-1). glibc's implementation returns 0. */ assert (ret == (size_t)(-2) || ret == (size_t)(-1) || ret == 0); assert (mbsinit (&state)); } /* Test NUL byte input. */ printf("NUL byte input ...\n"); { memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "", 1, &state); assert (ret == 0); assert (wc == 0); assert (mbsinit (&state)); ret = mbrtowc (NULL, "", 1, &state); assert (ret == 0); assert (mbsinit (&state)); } /* Test single-byte input. */ printf("single-byte input ...\n"); { char buf[1]; int c; memset (&state, '\0', sizeof (mbstate_t)); for (c = 0; c < 0x100; c++) switch (c) { case '\t': case '\v': case '\f': case ' ': case '!': case '"': case '#': case '%': case '&': case '\'': case '(': case ')': case '*': case '+': case ',': case '-': case '.': case '/': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case ':': case ';': case '<': case '=': case '>': case '?': case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z': case '[': case '\\': case ']': case '^': case '_': case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n': case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u': case 'v': case 'w': case 'x': case 'y': case 'z': case '{': case '|': case '}': case '~': /* c is in the ISO C "basic character set". */ buf[0] = c; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, buf, 1, &state); assert (ret == 1); assert (wc == c); assert (mbsinit (&state)); ret = mbrtowc (NULL, buf, 1, &state); assert (ret == 1); assert (mbsinit (&state)); break; } } /* Test special calling convention, passing a NULL pointer. */ printf("special calling convention, passing NULL ...\n"); { memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, NULL, 5, &state); assert (ret == 0); assert (wc == (wchar_t) 0xBADFACE); assert (mbsinit (&state)); } for (i = '1'; i <= '4'; ++i) { switch (i) { case '1': /* Locale encoding is ISO-8859-1 or ISO-8859-15. */ printf("ISO8859-1 ...\n"); { char input[] = "B\374\337er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); if (setlocale (LC_ALL, "en_US.ISO8859-1") == NULL) { fprintf(stderr, "unable to set ISO8859-1 locale, skipping\n"); break; } wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); assert (ret == 1); assert (wc == 'B'); assert (mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); assert (ret == 1); assert (wctob (wc) == (unsigned char) '\374'); assert (mbsinit (&state)); input[1] = '\0'; /* Test support of NULL first argument. */ ret = mbrtowc (NULL, input + 2, 3, &state); assert (ret == 1); assert (mbsinit (&state)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 2, 3, &state); assert (ret == 1); assert (wctob (wc) == (unsigned char) '\337'); assert (mbsinit (&state)); input[2] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 3, 2, &state); assert (ret == 1); assert (wc == 'e'); assert (mbsinit (&state)); input[3] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 4, 1, &state); assert (ret == 1); assert (wc == 'r'); assert (mbsinit (&state)); } break; case '2': /* Locale encoding is UTF-8. */ printf("UTF-8 ...\n"); { char input[] = "B\303\274\303\237er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); if (setlocale (LC_ALL, "en_US.UTF-8") == NULL) { fprintf(stderr, "unable to set UTF-8 locale, skipping\n"); break; } wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); assert (ret == 1); assert (wc == 'B'); assert (mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); assert (ret == (size_t)(-2)); assert (wc == (wchar_t) 0xBADFACE); assert (!mbsinit (&state)); input[1] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 2, 5, &state); assert (ret == 1); assert (wctob (wc) == EOF); assert (mbsinit (&state)); input[2] = '\0'; /* Test support of NULL first argument. */ ret = mbrtowc (NULL, input + 3, 4, &state); assert (ret == 2); assert (mbsinit (&state)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 3, 4, &state); assert (ret == 2); assert (wctob (wc) == EOF); assert (mbsinit (&state)); input[3] = '\0'; input[4] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 5, 2, &state); assert (ret == 1); assert (wc == 'e'); assert (mbsinit (&state)); input[5] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 6, 1, &state); assert (ret == 1); assert (wc == 'r'); assert (mbsinit (&state)); } break; case '3': /* Locale encoding is EUC-JP. */ printf("EUC-JP ...\n"); { char input[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */ memset (&state, '\0', sizeof (mbstate_t)); if (setlocale (LC_ALL, "en_US.EUC-JP") == NULL) { fprintf(stderr, "unable to set EUC-JP locale, skipping\n"); break; } wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); assert (ret == 1); assert (wc == '<'); assert (mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 1, 2, &state); assert (ret == 2); assert (wctob (wc) == EOF); assert (mbsinit (&state)); input[1] = '\0'; input[2] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 3, 1, &state); assert (ret == (size_t)(-2)); assert (wc == (wchar_t) 0xBADFACE); assert (!mbsinit (&state)); input[3] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 4, 4, &state); assert (ret == 1); assert (wctob (wc) == EOF); assert (mbsinit (&state)); input[4] = '\0'; /* Test support of NULL first argument. */ ret = mbrtowc (NULL, input + 5, 3, &state); assert (ret == 2); assert (mbsinit (&state)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 5, 3, &state); assert (ret == 2); assert (wctob (wc) == EOF); assert (mbsinit (&state)); input[5] = '\0'; input[6] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 7, 1, &state); assert (ret == 1); assert (wc == '>'); assert (mbsinit (&state)); } break; case '4': /* Locale encoding is GB18030. */ printf("GB18030 ...\n"); { char input[] = "B\250\271\201\060\211\070er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); if (setlocale (LC_ALL, "en_US.GB18030") == NULL) { fprintf(stderr, "unable to set GB18030 locale, skipping\n"); break; } wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); assert (ret == 1); assert (wc == 'B'); assert (mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); assert (ret == (size_t)(-2)); assert (wc == (wchar_t) 0xBADFACE); assert (!mbsinit (&state)); input[1] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 2, 7, &state); assert (ret == 1); assert (wctob (wc) == EOF); assert (mbsinit (&state)); input[2] = '\0'; /* Test support of NULL first argument. */ ret = mbrtowc (NULL, input + 3, 6, &state); assert (ret == 4); assert (mbsinit (&state)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 3, 6, &state); assert (ret == 4); assert (wctob (wc) == EOF); assert (mbsinit (&state)); input[3] = '\0'; input[4] = '\0'; input[5] = '\0'; input[6] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 7, 2, &state); assert (ret == 1); assert (wc == 'e'); assert (mbsinit (&state)); input[5] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 8, 1, &state); assert (ret == 1); assert (wc == 'r'); assert (mbsinit (&state)); } break; } } return 0; }
static int test_one_locale (const char *name, int codepage) { mbstate_t state; wchar_t wc; size_t ret; # if 1 /* Portable code to set the locale. */ { char name_with_codepage[1024]; sprintf (name_with_codepage, "%s.%d", name, codepage); /* Set the locale. */ if (setlocale (LC_ALL, name_with_codepage) == NULL) return 77; } # else /* Hacky way to set a locale.codepage combination that setlocale() refuses to set. */ { /* Codepage of the current locale, set with setlocale(). Not necessarily the same as GetACP(). */ extern __declspec(dllimport) unsigned int __lc_codepage; /* Set the locale. */ if (setlocale (LC_ALL, name) == NULL) return 77; /* Clobber the codepage and MB_CUR_MAX, both set by setlocale(). */ __lc_codepage = codepage; switch (codepage) { case 1252: case 1256: MB_CUR_MAX = 1; break; case 932: case 950: case 936: MB_CUR_MAX = 2; break; case 54936: case 65001: MB_CUR_MAX = 4; break; } /* Test whether the codepage is really available. */ memset (&state, '\0', sizeof (mbstate_t)); if (mbrtowc (&wc, " ", 1, &state) == (size_t)(-1)) return 77; } # endif /* Test zero-length input. */ { memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "x", 0, &state); /* gnulib's implementation returns (size_t)(-2). The AIX 5.1 implementation returns (size_t)(-1). glibc's implementation returns 0. */ ASSERT (ret == (size_t)(-2) || ret == (size_t)(-1) || ret == 0); ASSERT (mbsinit (&state)); } /* Test NUL byte input. */ { memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "", 1, &state); ASSERT (ret == 0); ASSERT (wc == 0); ASSERT (mbsinit (&state)); ret = mbrtowc (NULL, "", 1, &state); ASSERT (ret == 0); ASSERT (mbsinit (&state)); } /* Test single-byte input. */ { int c; char buf[1]; memset (&state, '\0', sizeof (mbstate_t)); for (c = 0; c < 0x100; c++) switch (c) { case '\t': case '\v': case '\f': case ' ': case '!': case '"': case '#': case '%': case '&': case '\'': case '(': case ')': case '*': case '+': case ',': case '-': case '.': case '/': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case ':': case ';': case '<': case '=': case '>': case '?': case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z': case '[': case '\\': case ']': case '^': case '_': case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n': case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u': case 'v': case 'w': case 'x': case 'y': case 'z': case '{': case '|': case '}': case '~': /* c is in the ISO C "basic character set". */ buf[0] = c; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, buf, 1, &state); ASSERT (ret == 1); ASSERT (wc == c); ASSERT (mbsinit (&state)); ret = mbrtowc (NULL, buf, 1, &state); ASSERT (ret == 1); ASSERT (mbsinit (&state)); break; } } /* Test special calling convention, passing a NULL pointer. */ { memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, NULL, 5, &state); ASSERT (ret == 0); ASSERT (wc == (wchar_t) 0xBADFACE); ASSERT (mbsinit (&state)); } switch (codepage) { case 1252: /* Locale encoding is CP1252, an extension of ISO-8859-1. */ { char input[] = "B\374\337er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == (unsigned char) '\374'); ASSERT (wc == 0x00FC); ASSERT (mbsinit (&state)); input[1] = '\0'; /* Test support of NULL first argument. */ ret = mbrtowc (NULL, input + 2, 3, &state); ASSERT (ret == 1); ASSERT (mbsinit (&state)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 2, 3, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == (unsigned char) '\337'); ASSERT (wc == 0x00DF); ASSERT (mbsinit (&state)); input[2] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 3, 2, &state); ASSERT (ret == 1); ASSERT (wc == 'e'); ASSERT (mbsinit (&state)); input[3] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 4, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'r'); ASSERT (mbsinit (&state)); } return 0; case 1256: /* Locale encoding is CP1256, not the same as ISO-8859-6. */ { char input[] = "x\302\341\346y"; /* "xآلوy" */ memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'x'); ASSERT (mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == (unsigned char) '\302'); ASSERT (wc == 0x0622); ASSERT (mbsinit (&state)); input[1] = '\0'; /* Test support of NULL first argument. */ ret = mbrtowc (NULL, input + 2, 3, &state); ASSERT (ret == 1); ASSERT (mbsinit (&state)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 2, 3, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == (unsigned char) '\341'); ASSERT (wc == 0x0644); ASSERT (mbsinit (&state)); input[2] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 3, 2, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == (unsigned char) '\346'); ASSERT (wc == 0x0648); ASSERT (mbsinit (&state)); input[3] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 4, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'y'); ASSERT (mbsinit (&state)); } return 0; case 932: /* Locale encoding is CP932, similar to Shift_JIS. */ { char input[] = "<\223\372\226\173\214\352>"; /* "<日本語>" */ memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == '<'); ASSERT (mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 1, 2, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); ASSERT (wc == 0x65E5); ASSERT (mbsinit (&state)); input[1] = '\0'; input[2] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 3, 1, &state); ASSERT (ret == (size_t)(-2)); ASSERT (wc == (wchar_t) 0xBADFACE); ASSERT (!mbsinit (&state)); input[3] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 4, 4, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == EOF); ASSERT (wc == 0x672C); ASSERT (mbsinit (&state)); input[4] = '\0'; /* Test support of NULL first argument. */ ret = mbrtowc (NULL, input + 5, 3, &state); ASSERT (ret == 2); ASSERT (mbsinit (&state)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 5, 3, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); ASSERT (wc == 0x8A9E); ASSERT (mbsinit (&state)); input[5] = '\0'; input[6] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 7, 1, &state); ASSERT (ret == 1); ASSERT (wc == '>'); ASSERT (mbsinit (&state)); /* Test some invalid input. */ memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "\225\377", 2, &state); /* 0x95 0xFF */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); } return 0; case 950: /* Locale encoding is CP950, similar to Big5. */ { char input[] = "<\244\351\245\273\273\171>"; /* "<日本語>" */ memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == '<'); ASSERT (mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 1, 2, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); ASSERT (wc == 0x65E5); ASSERT (mbsinit (&state)); input[1] = '\0'; input[2] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 3, 1, &state); ASSERT (ret == (size_t)(-2)); ASSERT (wc == (wchar_t) 0xBADFACE); ASSERT (!mbsinit (&state)); input[3] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 4, 4, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == EOF); ASSERT (wc == 0x672C); ASSERT (mbsinit (&state)); input[4] = '\0'; /* Test support of NULL first argument. */ ret = mbrtowc (NULL, input + 5, 3, &state); ASSERT (ret == 2); ASSERT (mbsinit (&state)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 5, 3, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); ASSERT (wc == 0x8A9E); ASSERT (mbsinit (&state)); input[5] = '\0'; input[6] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 7, 1, &state); ASSERT (ret == 1); ASSERT (wc == '>'); ASSERT (mbsinit (&state)); /* Test some invalid input. */ memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "\225\377", 2, &state); /* 0x95 0xFF */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); } return 0; case 936: /* Locale encoding is CP936 = GBK, an extension of GB2312. */ { char input[] = "<\310\325\261\276\325\132>"; /* "<日本語>" */ memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == '<'); ASSERT (mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 1, 2, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); ASSERT (wc == 0x65E5); ASSERT (mbsinit (&state)); input[1] = '\0'; input[2] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 3, 1, &state); ASSERT (ret == (size_t)(-2)); ASSERT (wc == (wchar_t) 0xBADFACE); ASSERT (!mbsinit (&state)); input[3] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 4, 4, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == EOF); ASSERT (wc == 0x672C); ASSERT (mbsinit (&state)); input[4] = '\0'; /* Test support of NULL first argument. */ ret = mbrtowc (NULL, input + 5, 3, &state); ASSERT (ret == 2); ASSERT (mbsinit (&state)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 5, 3, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); ASSERT (wc == 0x8A9E); ASSERT (mbsinit (&state)); input[5] = '\0'; input[6] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 7, 1, &state); ASSERT (ret == 1); ASSERT (wc == '>'); ASSERT (mbsinit (&state)); /* Test some invalid input. */ memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "\225\377", 2, &state); /* 0x95 0xFF */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); } return 0; case 54936: /* Locale encoding is CP54936 = GB18030. */ { char input[] = "B\250\271\201\060\211\070er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); ASSERT (wc == (wchar_t) 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 2, 7, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == EOF); ASSERT (wc == 0x00FC); ASSERT (mbsinit (&state)); input[2] = '\0'; /* Test support of NULL first argument. */ ret = mbrtowc (NULL, input + 3, 6, &state); ASSERT (ret == 4); ASSERT (mbsinit (&state)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 3, 6, &state); ASSERT (ret == 4); ASSERT (wctob (wc) == EOF); ASSERT (wc == 0x00DF); ASSERT (mbsinit (&state)); input[3] = '\0'; input[4] = '\0'; input[5] = '\0'; input[6] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 7, 2, &state); ASSERT (ret == 1); ASSERT (wc == 'e'); ASSERT (mbsinit (&state)); input[5] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 8, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'r'); ASSERT (mbsinit (&state)); /* Test some invalid input. */ memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "\225\377", 2, &state); /* 0x95 0xFF */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "\201\045", 2, &state); /* 0x81 0x25 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "\201\060\377", 3, &state); /* 0x81 0x30 0xFF */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "\201\060\377\064", 4, &state); /* 0x81 0x30 0xFF 0x34 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "\201\060\211\072", 4, &state); /* 0x81 0x30 0x89 0x3A */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); } return 0; case 65001: /* Locale encoding is CP65001 = UTF-8. */ { char input[] = "B\303\274\303\237er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); ASSERT (wc == (wchar_t) 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 2, 5, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == EOF); ASSERT (wc == 0x00FC); ASSERT (mbsinit (&state)); input[2] = '\0'; /* Test support of NULL first argument. */ ret = mbrtowc (NULL, input + 3, 4, &state); ASSERT (ret == 2); ASSERT (mbsinit (&state)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 3, 4, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); ASSERT (wc == 0x00DF); ASSERT (mbsinit (&state)); input[3] = '\0'; input[4] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 5, 2, &state); ASSERT (ret == 1); ASSERT (wc == 'e'); ASSERT (mbsinit (&state)); input[5] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 6, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'r'); ASSERT (mbsinit (&state)); /* Test some invalid input. */ memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "\303\300", 2, &state); /* 0xC3 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "\343\300", 2, &state); /* 0xE3 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "\343\300\200", 3, &state); /* 0xE3 0xC0 0x80 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "\343\200\300", 3, &state); /* 0xE3 0x80 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "\363\300", 2, &state); /* 0xF3 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "\363\300\200\200", 4, &state); /* 0xF3 0xC0 0x80 0x80 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "\363\200\300", 3, &state); /* 0xF3 0x80 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "\363\200\300\200", 4, &state); /* 0xF3 0x80 0xC0 0x80 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "\363\200\200\300", 4, &state); /* 0xF3 0x80 0x80 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); } return 0; default: return 1; } }
void TestAddendum( void ) { wchar_t wc; wchar_t wcs[10]; wchar_t * wcsPtr; int status; mbstate_t state; unsigned char mbc[MB_LEN_MAX]; unsigned char mbcs[10*MB_LEN_MAX+1]; unsigned char * mbcsPtr; errno_t rc; size_t retval; int violations = NumViolations; status = wctob( L'!' ); VERIFY( status == '!' ); status = mbtowc( &wc, "\x90\x90", 2 ); #ifndef DUMMY_DBCS VERIFY( status == 2 ); status = wctob( wc ); VERIFY( status == EOF ); #else VERIFY( status == 1 ); status = wctob( wc ); VERIFY( status == 0x90 ); #endif status = sisinit( NULL ); VERIFY( status != 0 ); state = 0; status = sisinit( &state ); VERIFY( status == 0 ); state = 123; status = sisinit( &state ); VERIFY( status == 0 ); status = mbrlen( "\0""!", 2, &state ); VERIFY( status == 0 ); status = mbrlen( "!", 2, &state ); VERIFY( status == 1 ); wc = L'\0'; rc = wcrtomb_s( &retval, mbc, MB_LEN_MAX, wc, &state ); VERIFY( rc == 0 ); VERIFY( *mbc == '\0' ); VERIFY( retval == 1 ); VERIFY( violations == NumViolations ); rc = wcrtomb_s( &retval, mbc, MB_LEN_MAX, L'X', &state ); VERIFY( rc == 0 ); VERIFY( *mbc == 'X' ); VERIFY( retval == 1 ); VERIFY( violations == NumViolations ); rc = wcrtomb_s( &retval, NULL, 0, L'X', &state ); VERIFY( rc == 0 ); VERIFY( retval == 1 ); VERIFY( violations == NumViolations ); _mbscpy( mbcs, "Foo!\x90\x90" ); mbcsPtr = mbcs; wcs[5] = wcs[6] = L'-'; rc = mbsrtowcs_s( &retval, wcs, 10, (const char**)(&mbcsPtr), 6, &state ); VERIFY( rc == 0 ); VERIFY( retval == 5 ); VERIFY( wcs[0] == L'F' ); VERIFY( wcs[1] == L'o' ); VERIFY( wcs[2] == L'o' ); VERIFY( wcs[3] == L'!' ); mbcsPtr = mbcs; rc = mbsrtowcs_s( &retval, NULL, 0, (const char**)(&mbcsPtr), 1, &state ); VERIFY( rc == 0 ); VERIFY( retval == 5 ); wcsPtr = wcs; _mbsset( mbcs, _mbsnextc("#") ); rc = wcsrtombs_s( &retval, mbcs, 10, (const wchar_t**)(&wcsPtr), 6, &state ); VERIFY( rc == 0 ); VERIFY( retval == 6 ); mbcs[retval] = '\0'; VERIFY( _mbscmp( mbcs, "Foo!\x90\x90" ) == 0 ); wcsPtr = wcs; rc = wcsrtombs_s( &retval, NULL, 0, (const wchar_t**)(&wcsPtr), 20, &state ); VERIFY( rc == 0 ); VERIFY( retval == 6 ); /***********************************************************************/ /* test runtime-constraints */ /***********************************************************************/ *mbc = 'X'; rc = wcrtomb_s( NULL, mbc, MB_LEN_MAX, wc, &state ); VERIFY( rc != 0 ); VERIFY( *mbc == '\0' ); VERIFY( ++violations == NumViolations ); *mbc = 'X'; rc = wcrtomb_s( &retval, mbc, MB_LEN_MAX, L'X', NULL ); VERIFY( rc != 0 ); VERIFY( *mbc == '\0' ); VERIFY( retval == -1 ); VERIFY( ++violations == NumViolations ); rc = wcrtomb_s( &retval, NULL, MB_LEN_MAX, L'X', &state ); VERIFY( rc != 0 ); VERIFY( retval == -1 ); VERIFY( ++violations == NumViolations ); *mbc = 'X'; rc = wcrtomb_s( &retval, mbc, 0, L'X', &state ); VERIFY( rc != 0 ); VERIFY( *mbc == 'X' ); VERIFY( retval == -1 ); VERIFY( ++violations == NumViolations ); #if RSIZE_MAX != SIZE_MAX rc = wcrtomb_s( &retval, mbc, ~0, L'X', &state ); VERIFY( rc != 0 ); VERIFY( retval == -1 ); VERIFY( *mbc == 'X' ); VERIFY( ++violations == NumViolations ); #endif mbcsPtr = mbcs; rc = mbsrtowcs_s( NULL, NULL, 0, (const char**)(&mbcsPtr), 1, &state ); VERIFY( rc != 0 ); VERIFY( ++violations == NumViolations ); rc = mbsrtowcs_s( &retval, NULL, 0, NULL, 1, &state ); VERIFY( rc != 0 ); VERIFY( retval == -1 ); VERIFY( ++violations == NumViolations ); mbcsPtr = NULL; rc = mbsrtowcs_s( &retval, NULL, 0, (const char**)(&mbcsPtr), 1, &state ); VERIFY( rc != 0 ); VERIFY( retval == -1 ); VERIFY( ++violations == NumViolations ); rc = mbsrtowcs_s( &retval, NULL, 0, (const char**)(&wcsPtr), 1, NULL ); VERIFY( rc != 0 ); VERIFY( retval == -1 ); VERIFY( ++violations == NumViolations ); rc = mbsrtowcs_s( &retval, NULL, 111, (const char**)(&wcsPtr), 1, &state ); VERIFY( rc != 0 ); VERIFY( retval == -1 ); VERIFY( ++violations == NumViolations ); wcsPtr = wcs; rc = wcsrtombs_s( &retval, mbcs, 5, (const wchar_t**)(&wcsPtr), 10, &state ); VERIFY( rc != 0 ); VERIFY( retval == -1 ); VERIFY( ++violations == NumViolations ); }
int main (int argc, char *argv[]) { mbstate_t state; wchar_t wc; size_t ret; /* configure should already have checked that the locale is supported. */ if (setlocale (LC_ALL, "") == NULL) return 1; /* Test zero-length input. */ { memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "x", 0, &state); ASSERT (ret == (size_t)(-2)); ASSERT (mbsinit (&state)); } /* Test NUL byte input. */ { memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, "", 1, &state); ASSERT (ret == 0); ASSERT (wc == 0); ASSERT (mbsinit (&state)); ret = mbrtowc (NULL, "", 1, &state); ASSERT (ret == 0); ASSERT (mbsinit (&state)); } /* Test single-byte input. */ { int c; char buf[1]; memset (&state, '\0', sizeof (mbstate_t)); for (c = 0; c < 0x100; c++) switch (c) { case '\t': case '\v': case '\f': case ' ': case '!': case '"': case '#': case '%': case '&': case '\'': case '(': case ')': case '*': case '+': case ',': case '-': case '.': case '/': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case ':': case ';': case '<': case '=': case '>': case '?': case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z': case '[': case '\\': case ']': case '^': case '_': case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n': case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u': case 'v': case 'w': case 'x': case 'y': case 'z': case '{': case '|': case '}': case '~': /* c is in the ISO C "basic character set". */ buf[0] = c; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, buf, 1, &state); ASSERT (ret == 1); ASSERT (wc == c); ASSERT (mbsinit (&state)); ret = mbrtowc (NULL, buf, 1, &state); ASSERT (ret == 1); ASSERT (mbsinit (&state)); break; } } /* Test special calling convention, passing a NULL pointer. */ { memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, NULL, 5, &state); ASSERT (ret == 0); ASSERT (wc == (wchar_t) 0xBADFACE); ASSERT (mbsinit (&state)); } if (argc > 1) switch (argv[1][0]) { case '1': /* Locale encoding is ISO-8859-1 or ISO-8859-15. */ { char input[] = "B\374\337er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == (unsigned char) '\374'); ASSERT (mbsinit (&state)); input[1] = '\0'; /* Test support of NULL first argument. */ ret = mbrtowc (NULL, input + 2, 3, &state); ASSERT (ret == 1); ASSERT (mbsinit (&state)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 2, 3, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == (unsigned char) '\337'); ASSERT (mbsinit (&state)); input[2] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 3, 2, &state); ASSERT (ret == 1); ASSERT (wc == 'e'); ASSERT (mbsinit (&state)); input[3] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 4, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'r'); ASSERT (mbsinit (&state)); } return 0; case '2': /* Locale encoding is UTF-8. */ { char input[] = "B\303\274\303\237er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); ASSERT (wc == (wchar_t) 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 2, 5, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == EOF); ASSERT (mbsinit (&state)); input[2] = '\0'; /* Test support of NULL first argument. */ ret = mbrtowc (NULL, input + 3, 4, &state); ASSERT (ret == 2); ASSERT (mbsinit (&state)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 3, 4, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); ASSERT (mbsinit (&state)); input[3] = '\0'; input[4] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 5, 2, &state); ASSERT (ret == 1); ASSERT (wc == 'e'); ASSERT (mbsinit (&state)); input[5] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 6, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'r'); ASSERT (mbsinit (&state)); } return 0; case '3': /* Locale encoding is EUC-JP. */ { char input[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */ memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == '<'); ASSERT (mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 1, 2, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); ASSERT (mbsinit (&state)); input[1] = '\0'; input[2] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 3, 1, &state); ASSERT (ret == (size_t)(-2)); ASSERT (wc == (wchar_t) 0xBADFACE); ASSERT (!mbsinit (&state)); input[3] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 4, 4, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == EOF); ASSERT (mbsinit (&state)); input[4] = '\0'; /* Test support of NULL first argument. */ ret = mbrtowc (NULL, input + 5, 3, &state); ASSERT (ret == 2); ASSERT (mbsinit (&state)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 5, 3, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); ASSERT (mbsinit (&state)); input[5] = '\0'; input[6] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 7, 1, &state); ASSERT (ret == 1); ASSERT (wc == '>'); ASSERT (mbsinit (&state)); } return 0; case '4': /* Locale encoding is GB18030. */ { char input[] = "B\250\271\201\060\211\070er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); ASSERT (wc == (wchar_t) 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 2, 7, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == EOF); ASSERT (mbsinit (&state)); input[2] = '\0'; /* Test support of NULL first argument. */ ret = mbrtowc (NULL, input + 3, 6, &state); ASSERT (ret == 4); ASSERT (mbsinit (&state)); wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 3, 6, &state); ASSERT (ret == 4); ASSERT (wctob (wc) == EOF); ASSERT (mbsinit (&state)); input[3] = '\0'; input[4] = '\0'; input[5] = '\0'; input[6] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 7, 2, &state); ASSERT (ret == 1); ASSERT (wc == 'e'); ASSERT (mbsinit (&state)); input[5] = '\0'; wc = (wchar_t) 0xBADFACE; ret = mbrtowc (&wc, input + 8, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'r'); ASSERT (mbsinit (&state)); } return 0; } return 1; }