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;
}
