void main() { _setmbcp( 932 ); printf( "%#6.4x\n", mb1[0] << 8 | mb1[1] ); _mbccpy( mb1, mb2 ); printf( "%#6.4x\n", mb1[0] << 8 | mb1[1] ); }
/* * Translate foo/dir1\\dir2" \\"bar"grok --> foo\\dir1\\dir2 \\"bargrok. */ char *PathConvertWithoutQuotes( const char *path ) /************************************************/ { char * out; char * p; bool backslash = FALSE; /* true if last char was a '\\' */ bool inquote = FALSE; /* true if inside a quoted string */ /*** Allocate a buffer for the new string (should be big enough) ***/ out = AllocMem( 2 * ( strlen(path) + 1 + 2 ) ); p = out; /*** Convert the path one character at a time ***/ while( *path != '\0' ) { if( *path == '"' ) { if( inquote ) { if( backslash ) { *p++ = '"'; /* handle \" within a string */ backslash = FALSE; } else { inquote = FALSE; } } else { inquote = TRUE; } } else if( *path == '\\' ) { *p++ = '\\'; if( backslash ) { backslash = FALSE; } else { backslash = TRUE; } } else if( *path == '/' ) { if( inquote ) { *p++ = '/'; } else { *p++ = '\\'; } backslash = FALSE; } else { /* copy an ordinary character */ _mbccpy( (unsigned char *)p, (unsigned char *)path ); /* copy an ordinary character */ p = (char *)_mbsinc( (unsigned char *)p ); backslash = FALSE; } path = (char *)_mbsinc( (unsigned char *)path ); } *p++ = '\0'; return( out ); }
/* * Translate foo/dir1\\dir2" \\"bar"grok --> "foo\\dir1\\dir2 \\"bargrok". */ char *PathConvert( const char *pathname, char quote ) /***************************************************/ { const unsigned char *path = (const unsigned char *)pathname; char *out; unsigned char *p; bool quoteends = FALSE; /* quote the whole filename */ bool backslash = FALSE; /* true if last char was a '\\' */ bool inquote = FALSE; /* true if inside a quoted string */ /*** Allocate a buffer for the new string (should be big enough) ***/ out = AllocMem( 2 * ( strlen( (char *)path ) + 1 + 2 ) ); p = (unsigned char *)out; /*** Determine if path contains any bizarre characters ***/ if( _mbschr( path, ' ' ) != NULL || _mbschr( path, '\t' ) != NULL || _mbschr( path, '"' ) != NULL || _mbschr( path, '\'' ) != NULL || _mbschr( path, '`' ) != NULL || _mbschr( path, quote ) != NULL ) { quoteends = TRUE; *p++ = quote; } /*** Convert the path one character at a time ***/ while( *path != '\0' ) { if( *path == '"' ) { if( inquote ) { if( backslash ) { *p++ = '"'; /* handle \" within a string */ backslash = FALSE; } else { inquote = FALSE; } } else { inquote = TRUE; } } else if( *path == '\\' ) { *p++ = '\\'; if( backslash ) { backslash = FALSE; } else { backslash = TRUE; } } else if( *path == '/' ) { if( inquote ) { *p++ = '/'; } else { *p++ = '\\'; } backslash = FALSE; } else { _mbccpy( p, path ); /* copy an ordinary character */ p = _mbsinc( p ); backslash = FALSE; } path = _mbsinc( path ); } if( quoteends ) *p++ = quote; *p++ = '\0'; return( out ); }
/* * _AddLine - add a line to the lines data structures */ void _AddLine( LPWDATA w, const void *in_data, unsigned len ) { int i; BOOL hadbreak; HWND hwnd; int tabcnt = 0; int nlcnt = 0; int curbufoff = 0; const char *data; #ifdef _MBCS static char leadByte; static int leadByteWaiting; unsigned char ch[MB_CUR_MAX+1]; LPBYTE p; #else char ch; #endif data = (const char *)in_data; hwnd = w->hwnd; _AccessWinLines(); if( w->LineTail != NULL && !w->LineTail->has_cr ) { FARstrcpy( w->tmpbuff->data, w->LineTail->data ); #ifdef _MBCS curbufoff = FAR_mbslen( (LPBYTE)w->tmpbuff->data ); #else curbufoff = FARstrlen( w->tmpbuff->data ); #endif if( curbufoff > w->buffoff ) { w->buffoff = curbufoff; } } if( w->no_advance ) { curbufoff = 0; } for( i = 0; i < len; i ++ ) { w->no_advance = FALSE; do { hadbreak = FALSE; #ifdef _MBCS /* MBCS */ if( tabcnt ) { _mbccpy( ch, (unsigned char *)" " ); /* copy the character */ ch[_mbclen( ch )] = '\0'; /* terminate char with NULL */ tabcnt--; } else if( nlcnt ) { _mbccpy( ch, (unsigned char *)"\n" ); /* copy the character */ ch[_mbclen( ch )] = '\0'; /* terminate char with NULL */ nlcnt--; } else { if( !leadByteWaiting ) { if( _ismbblead( *data ) ) { leadByteWaiting = 1; leadByte = *data; ch[0] = '\0'; } else { ch[0] = *data; ch[1] = '\0'; } } else { leadByteWaiting = 0; ch[0] = leadByte; ch[1] = *data; ch[2] = '\0'; } data++; } if( !_mbccmp( ch, (unsigned char *)"\t" ) ) { tabcnt = TAB( curbufoff + 1 ); continue; } else if( !_mbccmp( ch, (unsigned char *)"\f" ) ) { nlcnt = w->height; continue; } else if( !_mbccmp( ch, (unsigned char *)"\r" ) ) { curbufoff = 0; w->no_advance = TRUE; w->tmpbuff->has_cr = TRUE; continue; } else if( !_mbccmp( ch, (unsigned char *)"\n" ) ) { hadbreak = TRUE; newLine( w ); curbufoff = w->buffoff; } else if( !_mbccmp( ch, (unsigned char *)"\b" ) ) { if( curbufoff > 0 ) { p = FAR_mbsninc( (LPBYTE)w->tmpbuff->data, curbufoff - 1 ); if( _ismbblead( *p ) ) { *p = ' '; /* stomp lead byte */ /* char split into 2; don't change curbufoff */ } else { curbufoff--; /* back up one character */ } } } else if( ch[0] != '\0' ) { FAR_mbccpy( FAR_mbsninc( (LPBYTE)w->tmpbuff->data, curbufoff ), ch ); curbufoff++; if( curbufoff > w->buffoff ) { w->buffoff = curbufoff; } if( TOOWIDE( w->buffoff, w ) ) { hadbreak = TRUE; newLine( w ); curbufoff = w->buffoff; } } #else /* SBCS */ if( tabcnt ) { ch = ' '; tabcnt--; } else if( nlcnt ) { ch = '\n'; nlcnt--; } else { ch = data[i]; } if( ch == '\t' ) { tabcnt = TAB( curbufoff + 1 ); continue; } else if( ch == '\f' ) { nlcnt = w->height; continue; } else if( ch == '\r' ) { curbufoff = 0; w->no_advance = TRUE; w->tmpbuff->has_cr = TRUE; continue; } else if( ch == '\n' ) { hadbreak = TRUE; newLine( w ); curbufoff = w->buffoff; } else if( ch == '\b' ) { if( curbufoff > 0 ) { curbufoff--; } } else { w->tmpbuff->data[curbufoff++] = ch; if( curbufoff > w->buffoff ) { w->buffoff = curbufoff; } if( TOOWIDE( w->buffoff, w ) ) { hadbreak = TRUE; newLine( w ); curbufoff = w->buffoff; } } #endif } while( tabcnt || nlcnt ); } if( !hadbreak ) { updateBuff( w ); } _ReleaseWinLines(); } /* _AddLine */
_WCRTLINK wint_t (ungetwc)( wint_t c, FILE *fp ) #endif { if( c == __F_NAME(EOF,WEOF) ) { /* cannot push EOF */ return( c ); } _ValidFile( fp, __F_NAME(EOF,WEOF) ); _AccessFile( fp ); /*** Deal with stream orientation ***/ #ifndef __NETWARE__ #ifdef __WIDECHAR__ if( _FP_ORIENTATION(fp) != _WIDE_ORIENTED ) { if( _FP_ORIENTATION(fp) == _NOT_ORIENTED ) { _FP_ORIENTATION(fp) = _WIDE_ORIENTED; } else { _ReleaseFile( fp ); return( WEOF ); } } #else if( _FP_ORIENTATION(fp) != _BYTE_ORIENTED ) { if( _FP_ORIENTATION(fp) == _NOT_ORIENTED ) { _FP_ORIENTATION(fp) = _BYTE_ORIENTED; } else { _ReleaseFile( fp ); return( EOF ); } } #endif #endif if( fp->_flag & _DIRTY ) { /* cannot unget after a put */ _ReleaseFile( fp ); return( __F_NAME(EOF,WEOF) ); } if(( fp->_flag & _READ ) == 0 ) { /* not open for input */ _ReleaseFile( fp ); return( __F_NAME(EOF,WEOF) ); } if( _FP_BASE(fp) == NULL ) { /* no buffer allocated */ __ioalloc( fp ); } #ifdef __WIDECHAR__ if( fp->_flag & _BINARY ) { /*** Leave the character in wide form ***/ if( fp->_cnt == 0 ) { /* read buffer is empty */ fp->_cnt = sizeof(wchar_t); fp->_ptr = _FP_BASE(fp) + fp->_bufsize - sizeof(wchar_t); fp->_flag |= _UNGET; /* 10-mar-90 */ memcpy( fp->_ptr, &c, sizeof(wchar_t) ); } else if( fp->_ptr != _FP_BASE(fp) ) { fp->_cnt += sizeof(wchar_t); fp->_ptr -= sizeof(wchar_t); fp->_flag |= _UNGET; memcpy( fp->_ptr, &c, sizeof(wchar_t) ); } else { /* read buffer is full */ _ReleaseFile( fp ); return( WEOF ); } } else { char mbc[MB_CUR_MAX]; int mbcLen; /*** Convert the character to multibyte form ***/ if( wctomb( mbc, c ) == -1 ) { __set_errno( EILSEQ ); return( WEOF ); } mbcLen = _mbclen( mbc ); /*** Store the converted character ***/ if( fp->_cnt == 0 ) { /* read buffer is empty */ fp->_cnt = mbcLen; fp->_ptr = _FP_BASE(fp) + fp->_bufsize - mbcLen; fp->_flag |= _UNGET; /* 10-mar-90 */ _mbccpy( fp->_ptr, mbc ); } else if( fp->_ptr != _FP_BASE(fp) ) { fp->_cnt += mbcLen; fp->_ptr -= mbcLen; fp->_flag |= _UNGET; _mbccpy( fp->_ptr, mbc ); } else { /* read buffer is full */ _ReleaseFile( fp ); return( WEOF ); } } #else if( fp->_cnt == 0 ) { /* read buffer is empty */ fp->_cnt = CHARSIZE; fp->_ptr = _FP_BASE(fp) + fp->_bufsize - CHARSIZE; fp->_flag |= _UNGET; /* 10-mar-90 */ *(CHAR_TYPE*)(fp->_ptr) = c; } else if( fp->_ptr != _FP_BASE(fp) ) { fp->_cnt += CHARSIZE; fp->_ptr -= CHARSIZE; if( *(CHAR_TYPE*)(fp->_ptr) != c ) fp->_flag |= _UNGET; /* 10-mar-90 */ *(CHAR_TYPE*)(fp->_ptr) = c; } else { /* read buffer is full */ _ReleaseFile( fp ); return( EOF ); } #endif fp->_flag &= ~ _EOF; _ReleaseFile( fp ); return( (UCHAR_TYPE) c ); }
_WCRTLINK INTCHAR_TYPE __F_NAME(ungetc,ungetwc)( INTCHAR_TYPE c, FILE *fp ) { if( c == INTCHAR_EOF ) { /* cannot push EOF */ return( c ); } _ValidFile( fp, INTCHAR_EOF ); _AccessFile( fp ); /*** Deal with stream orientation ***/ ORIENT_STREAM( fp, INTCHAR_EOF ); if( fp->_flag & _DIRTY ) { /* cannot unget after a put */ _ReleaseFile( fp ); return( INTCHAR_EOF ); } if(( fp->_flag & _READ ) == 0 ) { /* not open for input */ _ReleaseFile( fp ); return( INTCHAR_EOF ); } if( _FP_BASE( fp ) == NULL ) { /* no buffer allocated */ __ioalloc( fp ); } #ifdef __WIDECHAR__ if( fp->_flag & _BINARY ) { /*** Leave the character in wide form ***/ if( fp->_cnt == 0 ) { /* read buffer is empty */ fp->_cnt = sizeof( wchar_t ); fp->_ptr = _FP_BASE( fp ) + fp->_bufsize - sizeof( wchar_t ); fp->_flag |= _UNGET; /* 10-mar-90 */ memcpy( fp->_ptr, &c, sizeof( wchar_t ) ); } else if( fp->_ptr != _FP_BASE( fp ) ) { fp->_cnt += sizeof( wchar_t ); fp->_ptr -= sizeof( wchar_t ); fp->_flag |= _UNGET; memcpy( fp->_ptr, &c, sizeof( wchar_t ) ); } else { /* read buffer is full */ _ReleaseFile( fp ); return( WEOF ); } } else { unsigned char mbc[MB_CUR_MAX]; int mbcLen; /*** Convert the character to multibyte form ***/ if( wctomb( (char *)mbc, c ) == -1 ) { _RWD_errno = EILSEQ; return( WEOF ); } mbcLen = _mbclen( mbc ); /*** Store the converted character ***/ if( fp->_cnt == 0 ) { /* read buffer is empty */ fp->_cnt = mbcLen; fp->_ptr = _FP_BASE( fp ) + fp->_bufsize - mbcLen; fp->_flag |= _UNGET; /* 10-mar-90 */ _mbccpy( fp->_ptr, mbc ); } else if( fp->_ptr != _FP_BASE( fp ) ) { fp->_cnt += mbcLen; fp->_ptr -= mbcLen; fp->_flag |= _UNGET; _mbccpy( fp->_ptr, mbc ); } else { /* read buffer is full */ _ReleaseFile( fp ); return( WEOF ); } } #else if( fp->_cnt == 0 ) { /* read buffer is empty */ fp->_cnt = 1; fp->_ptr = _FP_BASE( fp ) + fp->_bufsize - 1; fp->_flag |= _UNGET; /* 10-mar-90 */ *fp->_ptr = c; } else if( fp->_ptr != _FP_BASE( fp ) ) { fp->_cnt++; fp->_ptr--; if( *fp->_ptr != c ) { fp->_flag |= _UNGET; /* 10-mar-90 */ } *fp->_ptr = c; } else { /* read buffer is full */ _ReleaseFile( fp ); return( EOF ); } #endif fp->_flag &= ~ _EOF; _ReleaseFile( fp ); return( (UCHAR_TYPE)c ); }
/* * _GetString - read in a string, return the length */ int _GetString( LPWDATA w, char *str, int maxbuff ) { HWND hwnd; int buff_end = 0; int curr_pos = 0; BOOL escape = FALSE; BOOL insert_flag = FALSE; int maxlen = maxbuff; LPSTR res; int wt; int len; int i; int scan; #ifdef _MBCS unsigned char *p; int expectingTrailByte = 0; int overwrote = 0; unsigned char ci; unsigned char cx; #else char ci; char cx; #endif #ifdef _MBCS res = _MemAlloc( MB_CUR_MAX * ( maxbuff + 1 ) ); #else res = _MemAlloc( maxbuff + 1 ); #endif if( res == NULL) return( 0 ); hwnd = w->hwnd; _MoveToLine( w, _GetLastLineNumber( w ), FALSE ); _NewCursor( w, SMALL_CURSOR ); _SetInputMode( w, TRUE ); _GotEOF = FALSE; str[0] = 0; while( 1 ) { w->curr_pos = curr_pos; _DisplayCursor( w ); while( !_KeyboardHit( TRUE ) ); ci = _GetKeyboard( &scan ); #if defined( __OS2__ ) WinShowCursor( hwnd, FALSE ); #else HideCaret( hwnd ); #endif if( escape ) { #ifdef _MBCS p = __mbsninc( (unsigned char *)str, curr_pos++ ); *p = ci; #else str[curr_pos++] = ci; #endif escape = FALSE; } else if( (ci == CTRL_V) || (scan != 0xFF) ) { if( ci == CTRL_V ) { escape = TRUE; /* This is a VI thing - */ ci = '^'; /* it permits insertion of any key */ } if( insert_flag ) { if( buff_end < maxlen && !TOOWIDE( buff_end, w ) ) { #ifdef _MBCS if( !expectingTrailByte ) { /* shift over two bytes */ if( _ismbblead( ci ) ) { expectingTrailByte = 1; p = __mbsninc( (unsigned char *)str, curr_pos ); for( i = strlen( (char *)p ); i >= 0; i-- ) p[i + 2] = p[i]; p[0] = ci; } else { /* shift over one byte */ p = __mbsninc( (unsigned char *)str, curr_pos ); for( i = strlen( (char *)p ); i >= 0; i-- ) p[i + 1] = p[i]; p[0] = ci; } } else { expectingTrailByte = 0; p = __mbsninc( (unsigned char *)str, curr_pos ); p[1] = ci; } overwrote = 0; #else for( i = buff_end; i >= curr_pos; i-- ) str[i + 1] = str[i]; buff_end++; str[curr_pos] = ci; #endif } else { continue; } } else if( curr_pos == buff_end ) { if( buff_end < maxlen ) { #ifdef _MBCS if( !expectingTrailByte ) { if( _ismbblead( ci ) ) { expectingTrailByte = 1; p = __mbsninc( (unsigned char *)str, buff_end ); } else { p = __mbsninc( (unsigned char *)str, buff_end ); } p[0] = ci; p[1] = p[2] = 0; } else { expectingTrailByte = 0; p = __mbsninc( (unsigned char *)str, buff_end ); p[1] = ci; p[2] = 0; } overwrote = 0; #else str[buff_end++] = ci; str[buff_end] = 0; #endif } else { continue; } } else { #ifdef _MBCS p = __mbsninc( (unsigned char *)str, curr_pos ); if( !expectingTrailByte ) { if( _ismbblead( ci ) ) { expectingTrailByte = 1; if( !_ismbblead( *p ) ) { for( i = strlen( (char *)p + 1 ); i >= 0; i-- ) { p[i + 2] = p[i + 1]; /* shift over one byte */ } } p[0] = ci; } else { if( _ismbblead( *p ) ) { /* shift over one byte */ for( i = 1; i <= strlen( (char *)p + 1 ); i++ ) { p[i] = p[i + 1]; } } p[0] = ci; } } else { expectingTrailByte = 0; p[1] = ci; } overwrote = 1; #else str[curr_pos] = ci; #endif } #ifdef _MBCS if( !escape && !expectingTrailByte ) { curr_pos++; if( !overwrote ) { buff_end++; } } #else if( !escape ) { curr_pos++; } #endif } else { cx = ci; if( cx >= 0x80 ) cx -= 0x80; switch( cx ) { case VK_HOME: curr_pos = 0; break; case VK_END: curr_pos = buff_end; break; case VK_RETURN: #ifdef __OS2__ case VK_ENTER: #endif #ifdef _MBCS p = __mbsninc( (unsigned char *)str, buff_end ); *p = '\0'; #else str[buff_end] = 0; #endif _NewCursor( w, ORIGINAL_CURSOR ); #ifdef _MBCS _UpdateInputLine( w, str, __mbslen( (unsigned char *)str ), TRUE ); #else _UpdateInputLine( w, str, strlen( str ), TRUE ); #endif _SetInputMode( w, FALSE ); FARstrcat( res, str ); FARstrcpy( str, res ); _MemFree( res ); /* return number of bytes */ return( strlen( str ) ); case VK_LEFT: if( curr_pos > 0 ) curr_pos--; break; case VK_RIGHT: if( curr_pos < buff_end ) curr_pos++; break; case VK_DELETE: if( curr_pos == buff_end ) break; /* DEL, not BS */ if( curr_pos < buff_end ) curr_pos++; /* fall through to VK_BACK... */ case VK_BACK: if( curr_pos > 0 ) { #ifdef _MBCS p = __mbsninc( (unsigned char *)str, curr_pos - 1 ); for( i = curr_pos; i < buff_end; i++ ) { _mbccpy( __mbsninc( p, i - curr_pos ), __mbsninc( p, i - curr_pos + 1 ) ); } p = __mbsninc( (unsigned char *)str, i - 1 ); *p = '\0'; #else for( i = curr_pos; i <= buff_end; i++ ) str[i - 1] = str[i]; #endif buff_end--; curr_pos--; } break; case VK_INSERT: if( insert_flag ) { insert_flag = FALSE; _NewCursor( w, SMALL_CURSOR ); } else { insert_flag = TRUE; _NewCursor( w, FAT_CURSOR ); } break; default: continue; } } /* * update line. if line was split, then we must reset * the current line info. */ #ifdef _MBCS wt = _UpdateInputLine( w, str, expectingTrailByte ? __mbslen( (unsigned char *)str ) - 1 : __mbslen( (unsigned char *)str ), FALSE ); #else wt = _UpdateInputLine( w, str, strlen( str ), FALSE ); #endif if( wt >= 0 ) { #ifdef _MBCS len = __mbslen( (unsigned char *)str ); p = __mbsninc( (unsigned char *)str, len - wt ); ci = *p; *p = '\0'; FARstrcat( res, str ); *p = ci; for( i = 0; i <= wt; i++ ) str[i] = str[len - wt + i]; #else len = strlen( str ); ci = str[ len - wt ]; str[ len - wt ] = 0; FARstrcat( res, str ); str[ len - wt ] = ci; for( i = 0; i <= wt; i++ ) str[i] = str[len - wt + i]; #endif curr_pos = wt; buff_end = wt; maxlen -= len + 1; } } } /* _GetString */
static void test_mbcp(void) { int mb_orig_max = *p__mb_cur_max; int curr_mbcp = _getmbcp(); unsigned char *mbstring = (unsigned char *)"\xb0\xb1\xb2 \xb3\xb4 \xb5"; /* incorrect string */ unsigned char *mbstring2 = (unsigned char *)"\xb0\xb1\xb2\xb3Q\xb4\xb5"; /* correct string */ unsigned char *mbsonlylead = (unsigned char *)"\xb0\0\xb1\xb2 \xb3"; unsigned char buf[16]; int step; /* _mbtype tests */ /* An SBCS codepage test. The ctype of characters on e.g. CP1252 or CP1250 differs slightly * between versions of Windows. Also Windows 9x seems to ignore the codepage and always uses * CP1252 (or the ACP?) so we test only a few ASCII characters */ _setmbcp(1252); expect_eq(p_mbctype[10], 0, char, "%x"); expect_eq(p_mbctype[50], 0, char, "%x"); expect_eq(p_mbctype[66], _SBUP, char, "%x"); expect_eq(p_mbctype[100], _SBLOW, char, "%x"); expect_eq(p_mbctype[128], 0, char, "%x"); _setmbcp(1250); expect_eq(p_mbctype[10], 0, char, "%x"); expect_eq(p_mbctype[50], 0, char, "%x"); expect_eq(p_mbctype[66], _SBUP, char, "%x"); expect_eq(p_mbctype[100], _SBLOW, char, "%x"); expect_eq(p_mbctype[128], 0, char, "%x"); /* double byte code pages */ test_codepage(932); test_codepage(936); test_codepage(949); test_codepage(950); _setmbcp(936); ok(*p__mb_cur_max == mb_orig_max, "__mb_cur_max shouldn't be updated (is %d != %d)\n", *p__mb_cur_max, mb_orig_max); ok(_ismbblead('\354'), "\354 should be a lead byte\n"); ok(_ismbblead(' ') == FALSE, "' ' should not be a lead byte\n"); ok(_ismbblead(0x1234b0), "0x1234b0 should not be a lead byte\n"); ok(_ismbblead(0x123420) == FALSE, "0x123420 should not be a lead byte\n"); ok(_ismbbtrail('\xb0'), "\xa0 should be a trail byte\n"); ok(_ismbbtrail(' ') == FALSE, "' ' should not be a trail byte\n"); /* _ismbslead */ expect_eq(_ismbslead(mbstring, &mbstring[0]), -1, int, "%d"); expect_eq(_ismbslead(mbstring, &mbstring[1]), FALSE, int, "%d"); expect_eq(_ismbslead(mbstring, &mbstring[2]), -1, int, "%d"); expect_eq(_ismbslead(mbstring, &mbstring[3]), FALSE, int, "%d"); expect_eq(_ismbslead(mbstring, &mbstring[4]), -1, int, "%d"); expect_eq(_ismbslead(mbstring, &mbstring[5]), FALSE, int, "%d"); expect_eq(_ismbslead(mbstring, &mbstring[6]), FALSE, int, "%d"); expect_eq(_ismbslead(mbstring, &mbstring[7]), -1, int, "%d"); expect_eq(_ismbslead(mbstring, &mbstring[8]), FALSE, int, "%d"); expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[0]), -1, int, "%d"); expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[1]), FALSE, int, "%d"); expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[2]), FALSE, int, "%d"); expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[5]), FALSE, int, "%d"); /* _ismbstrail */ expect_eq(_ismbstrail(mbstring, &mbstring[0]), FALSE, int, "%d"); expect_eq(_ismbstrail(mbstring, &mbstring[1]), -1, int, "%d"); expect_eq(_ismbstrail(mbstring, &mbstring[2]), FALSE, int, "%d"); expect_eq(_ismbstrail(mbstring, &mbstring[3]), -1, int, "%d"); expect_eq(_ismbstrail(mbstring, &mbstring[4]), FALSE, int, "%d"); expect_eq(_ismbstrail(mbstring, &mbstring[5]), -1, int, "%d"); expect_eq(_ismbstrail(mbstring, &mbstring[6]), FALSE, int, "%d"); expect_eq(_ismbstrail(mbstring, &mbstring[7]), FALSE, int, "%d"); expect_eq(_ismbstrail(mbstring, &mbstring[8]), -1, int, "%d"); expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[0]), FALSE, int, "%d"); expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[1]), -1, int, "%d"); expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[2]), FALSE, int, "%d"); expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[3]), FALSE, int, "%d"); expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[4]), FALSE, int, "%d"); expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[5]), FALSE, int, "%d"); /* _mbsbtype */ expect_eq(_mbsbtype(mbstring, 0), _MBC_LEAD, int, "%d"); expect_eq(_mbsbtype(mbstring, 1), _MBC_TRAIL, int, "%d"); expect_eq(_mbsbtype(mbstring, 2), _MBC_LEAD, int, "%d"); expect_eq(_mbsbtype(mbstring, 3), _MBC_ILLEGAL, int, "%d"); expect_eq(_mbsbtype(mbstring, 4), _MBC_LEAD, int, "%d"); expect_eq(_mbsbtype(mbstring, 5), _MBC_TRAIL, int, "%d"); expect_eq(_mbsbtype(mbstring, 6), _MBC_SINGLE, int, "%d"); expect_eq(_mbsbtype(mbstring, 7), _MBC_LEAD, int, "%d"); expect_eq(_mbsbtype(mbstring, 8), _MBC_ILLEGAL, int, "%d"); expect_eq(_mbsbtype(mbsonlylead, 0), _MBC_LEAD, int, "%d"); expect_eq(_mbsbtype(mbsonlylead, 1), _MBC_ILLEGAL, int, "%d"); expect_eq(_mbsbtype(mbsonlylead, 2), _MBC_ILLEGAL, int, "%d"); expect_eq(_mbsbtype(mbsonlylead, 3), _MBC_ILLEGAL, int, "%d"); expect_eq(_mbsbtype(mbsonlylead, 4), _MBC_ILLEGAL, int, "%d"); expect_eq(_mbsbtype(mbsonlylead, 5), _MBC_ILLEGAL, int, "%d"); /* _mbsnextc */ expect_eq(_mbsnextc(mbstring), 0xb0b1, int, "%x"); expect_eq(_mbsnextc(&mbstring[2]), 0xb220, int, "%x"); /* lead + invalid tail */ expect_eq(_mbsnextc(&mbstring[3]), 0x20, int, "%x"); /* single char */ /* _mbclen/_mbslen */ expect_eq(_mbclen(mbstring), 2, int, "%d"); expect_eq(_mbclen(&mbstring[2]), 2, int, "%d"); expect_eq(_mbclen(&mbstring[3]), 1, int, "%d"); expect_eq(_mbslen(mbstring2), 4, int, "%d"); expect_eq(_mbslen(mbsonlylead), 0, int, "%d"); /* lead + NUL not counted as character */ expect_eq(_mbslen(mbstring), 4, int, "%d"); /* lead + invalid trail counted */ /* _mbccpy/_mbsncpy */ memset(buf, 0xff, sizeof(buf)); _mbccpy(buf, mbstring); expect_bin(buf, "\xb0\xb1\xff", 3); memset(buf, 0xff, sizeof(buf)); _mbsncpy(buf, mbstring, 1); expect_bin(buf, "\xb0\xb1\xff", 3); memset(buf, 0xff, sizeof(buf)); _mbsncpy(buf, mbstring, 2); expect_bin(buf, "\xb0\xb1\xb2 \xff", 5); memset(buf, 0xff, sizeof(buf)); _mbsncpy(buf, mbstring, 3); expect_bin(buf, "\xb0\xb1\xb2 \xb3\xb4\xff", 7); memset(buf, 0xff, sizeof(buf)); _mbsncpy(buf, mbstring, 4); expect_bin(buf, "\xb0\xb1\xb2 \xb3\xb4 \xff", 8); memset(buf, 0xff, sizeof(buf)); _mbsncpy(buf, mbstring, 5); expect_bin(buf, "\xb0\xb1\xb2 \xb3\xb4 \0\0\xff", 10); memset(buf, 0xff, sizeof(buf)); _mbsncpy(buf, mbsonlylead, 6); expect_bin(buf, "\0\0\0\0\0\0\0\xff", 8); memset(buf, 0xff, sizeof(buf)); _mbsnbcpy(buf, mbstring2, 2); expect_bin(buf, "\xb0\xb1\xff", 3); _mbsnbcpy(buf, mbstring2, 3); expect_bin(buf, "\xb0\xb1\0\xff", 4); _mbsnbcpy(buf, mbstring2, 4); expect_bin(buf, "\xb0\xb1\xb2\xb3\xff", 5); memset(buf, 0xff, sizeof(buf)); _mbsnbcpy(buf, mbsonlylead, 5); expect_bin(buf, "\0\0\0\0\0\xff", 6); /* _mbsinc/mbsdec */ step = _mbsinc(mbstring) - mbstring; ok(step == 2, "_mbsinc adds %d (exp. 2)\n", step); step = _mbsinc(&mbstring[2]) - &mbstring[2]; /* lead + invalid tail */ ok(step == 2, "_mbsinc adds %d (exp. 2)\n", step); step = _mbsninc(mbsonlylead, 1) - mbsonlylead; ok(step == 0, "_mbsninc adds %d (exp. 0)\n", step); step = _mbsninc(mbsonlylead, 2) - mbsonlylead; /* lead + NUL byte + lead + char */ ok(step == 0, "_mbsninc adds %d (exp. 0)\n", step); step = _mbsninc(mbstring2, 0) - mbstring2; ok(step == 0, "_mbsninc adds %d (exp. 2)\n", step); step = _mbsninc(mbstring2, 1) - mbstring2; ok(step == 2, "_mbsninc adds %d (exp. 2)\n", step); step = _mbsninc(mbstring2, 2) - mbstring2; ok(step == 4, "_mbsninc adds %d (exp. 4)\n", step); step = _mbsninc(mbstring2, 3) - mbstring2; ok(step == 5, "_mbsninc adds %d (exp. 5)\n", step); step = _mbsninc(mbstring2, 4) - mbstring2; ok(step == 7, "_mbsninc adds %d (exp. 7)\n", step); step = _mbsninc(mbstring2, 5) - mbstring2; ok(step == 7, "_mbsninc adds %d (exp. 7)\n", step); step = _mbsninc(mbstring2, 17) - mbstring2; ok(step == 7, "_mbsninc adds %d (exp. 7)\n", step); /* functions that depend on locale codepage, not mbcp. * we hope the current locale to be SBCS because setlocale(LC_ALL, ".1252") seems not to work yet * (as of Wine 0.9.43) */ if (*p__mb_cur_max == 1) { expect_eq(mblen((char *)mbstring, 3), 1, int, "%x"); expect_eq(_mbstrlen((char *)mbstring2), 7, int, "%d"); }