Ignore:
Timestamp:
Apr 10, 2003, 12:28:07 PM (22 years ago)
Author:
sandervl
Message:

PF: MSVCRT update

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/msvcrt/mbcs.c

    r9633 r10005  
    3535#include "wine/debug.h"
    3636
     37#include <string.h>
     38#include <ctype.h>
     39
    3740WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
    3841
    … …  
    6770unsigned char* __p__mbctype(void)
    6871{
     72  dprintf(("MSVCRT: Query for __p__mbctype"));
    6973  return MSVCRT_mbctype;
    7074}
    … …  
    7579int* __p___mb_cur_max(void)
    7680{
     81  dprintf(("MSVCRT: Query for __p__mb_cur_max"));
    7782  return &MSVCRT___mb_cur_max;
    7883}
    … …  
    8388unsigned int _mbsnextc(const unsigned char* str)
    8489{
     90  dprintf(("MSVCRT: _mbsnextc"));
    8591  if(MSVCRT___mb_cur_max > 1 && MSVCRT_isleadbyte(*str))
    8692    return *str << 8 | str[1];
    … …  
    9399unsigned int _mbctolower(unsigned int c)
    94100{
     101    dprintf(("MSVCRT: _mbctolower"));
    95102    if (MSVCRT_isleadbyte(c))
    96103    {
    … …  
    106113unsigned int _mbctoupper(unsigned int c)
    107114{
     115     dprintf(("MSVCRT: _mbctoupper"));
    108116    if (MSVCRT_isleadbyte(c))
    109117    {
    … …  
    119127unsigned char* _mbsdec(const unsigned char* start, const unsigned char* cur)
    120128{
     129  dprintf(("MSVCRT: _mbsdec"));
    121130  if(MSVCRT___mb_cur_max > 1)
    122131    return (char *)(_ismbstrail(start,cur-1) ? cur - 2 : cur -1);
    … …  
    130139unsigned char* _mbsinc(const unsigned char* str)
    131140{
     141  dprintf(("MSVCRT: _mbsinc"));
    132142  if(MSVCRT___mb_cur_max > 1 && MSVCRT_isleadbyte(*str))
    133143    return (unsigned char*)str + 2; /* MB char */
    … …  
    141151unsigned char* _mbsninc(const unsigned char* str, MSVCRT_size_t num)
    142152{
     153  dprintf(("MSVCRT: _mbsninc"));
    143154  if(!str || num < 1)
    144155    return NULL;
    … …  
    157168unsigned int _mbclen(const unsigned char* str)
    158169{
     170  dprintf(("MSVCRT: _mbclen"));
    159171  return MSVCRT_isleadbyte(*str) ? 2 : 1;
    160172}
    … …  
    165177int MSVCRT_mblen(const char* str, MSVCRT_size_t size)
    166178{
     179  dprintf(("MSVCRT: mblen"));
    167180  if (str && *str && size)
    168181  {
    … …  
    180193MSVCRT_size_t _mbslen(const unsigned char* str)
    181194{
     195  dprintf(("MSVCRT: _mbslen"));
    182196  if(MSVCRT___mb_cur_max > 1)
    183197  {
    … …  
    198212MSVCRT_size_t _mbstrlen(const char* str)
    199213{
     214  dprintf(("MSVCRT: _mbstrlen"));
    200215  if(MSVCRT___mb_cur_max > 1)
    201216  {
    … …  
    219234void _mbccpy(unsigned char* dest, const unsigned char* src)
    220235{
     236  dprintf(("MSVCRT: _mbccpy"));
    221237  *dest++ = *src;
    222238  if(MSVCRT___mb_cur_max > 1 && MSVCRT_isleadbyte(*src))
    … …  
    231247unsigned char* _mbsncpy(unsigned char* dst, const unsigned char* src, MSVCRT_size_t n)
    232248{
     249  dprintf(("MSVCRT: _mbsncpy"));
    233250  if(!n)
    234251    return dst;
    … …  
    254271unsigned char* _mbsnbcpy(unsigned char* dst, const unsigned char* src, MSVCRT_size_t n)
    255272{
     273  dprintf(("MSVCRT: _mbsnbcpy"));
    256274  if(!n)
    257275    return dst;
    … …  
    288306int _mbscmp(const unsigned char* str, const unsigned char* cmp)
    289307{
     308  dprintf(("MSVCRT: _mbscmp"));
    290309  if(MSVCRT___mb_cur_max > 1)
    291310  {
    … …  
    308327
    309328/*********************************************************************
    310  *              _mbsicmp(MSVCRT.@)
    311  */
    312 int _mbsicmp(const unsigned char* str, const unsigned char* cmp)
     329 *              _mbsicoll(MSVCRT.@)
     330 * FIXME: handle locales.
     331 */
     332int _mbsicoll(const unsigned char* str, const unsigned char* cmp)
    313333{
    314334  if(MSVCRT___mb_cur_max > 1)
    … …  
    332352
    333353/*********************************************************************
     354 *              _mbsicmp(MSVCRT.@)
     355 */
     356int _mbsicmp(const unsigned char* str, const unsigned char* cmp)
     357{
     358  dprintf(("MSVCRT: _mbsicmp"));
     359  if(MSVCRT___mb_cur_max > 1)
     360  {
     361    unsigned int strc, cmpc;
     362    do {
     363      if(!*str)
     364        return *cmp ? -1 : 0;
     365      if(!*cmp)
     366        return 1;
     367      strc = _mbctolower(_mbsnextc(str));
     368      cmpc = _mbctolower(_mbsnextc(cmp));
     369      if(strc != cmpc)
     370        return strc < cmpc ? -1 : 1;
     371      str +=(strc > 255) ? 2 : 1;
     372      cmp +=(strc > 255) ? 2 : 1; /* equal, use same increment */
     373    } while(1);
     374  }
     375  return _stricmp(str, cmp); /* ASCII CP */
     376}
     377
     378/*********************************************************************
    334379 *              _mbsncmp(MSVCRT.@)
    335380 */
    336381int _mbsncmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
    337382{
     383  dprintf(("MSVCRT: _mbsncmp"));
    338384  if(!len)
    339385    return 0;
    … …  
    367413int _mbsnbcmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
    368414{
     415  dprintf(("MSVCRT: _mbsnbcmp"));
    369416  if (!len)
    370417    return 0;
    … …  
    412459int _mbsnicmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
    413460{
     461  dprintf(("MSVCRT: _mbsnicmp"));
    414462  /* FIXME: No tolower() for mb strings yet */
    415463  if(MSVCRT___mb_cur_max > 1)
    … …  
    439487int _mbsnbicmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
    440488{
     489  dprintf(("MSVCRT: _mbsnbicmp"));
    441490  if (!len)
    442491    return 0;
    … …  
    486535unsigned char* _mbschr(const unsigned char* s, unsigned int x)
    487536{
     537  dprintf(("MSVCRT: _mbschr"));
    488538  if(MSVCRT___mb_cur_max > 1)
    489539  {
    … …  
    507557unsigned char* _mbsrchr(const unsigned char* s, unsigned int x)
    508558{
     559  dprintf(("MSVCRT: _mbsrchr"));
    509560  if(MSVCRT___mb_cur_max > 1)
    510561  {
    … …  
    526577
    527578/*********************************************************************
     579 *              _mbstok(MSVCRT.@)
     580 *
     581 * Find and extract tokens from strings
     582 */
     583unsigned char* _mbstok(unsigned char *str, const unsigned char *delim)
     584{
     585    MSVCRT_thread_data *data = msvcrt_get_thread_data();
     586    char *ret;
     587
     588    if(MSVCRT___mb_cur_max > 1)
     589    {
     590        unsigned int c;
     591
     592        if (!str)
     593            if (!(str = data->mbstok_next)) return NULL;
     594
     595        while ((c = _mbsnextc(str)) && _mbschr(delim, c)) {
     596            str += c > 255 ? 2 : 1;
     597        }
     598        if (!*str) return NULL;
     599        ret = str++;
     600        while ((c = _mbsnextc(str)) && !_mbschr(delim, c)) {
     601            str += c > 255 ? 2 : 1;
     602        }
     603        if (*str) {
     604            *str++ = 0;
     605            if (c > 255) *str++ = 0;
     606        }
     607        data->mbstok_next = str;
     608        return ret;
     609    }
     610    return strtok(str, delim);  /* ASCII CP */
     611}
     612
     613/*********************************************************************
    528614 *              mbtowc(MSVCRT.@)
    529615 */
    530616int MSVCRT_mbtowc(MSVCRT_wchar_t *dst, const char* str, MSVCRT_size_t n)
    531617{
     618  dprintf(("MSVCRT: _mbtowc"));
    532619  if(n <= 0 || !str)
    533620    return 0;
    … …  
    547634unsigned int _mbbtombc(unsigned int c)
    548635{
     636  dprintf(("MSVCRT: _mbbtombc"));
    549637  if(MSVCRT___mb_cur_max > 1 &&
    550638     ((c >= 0x20 && c <=0x7e) ||(c >= 0xa1 && c <= 0xdf)))
    … …  
    562650int _ismbbkana(unsigned int c)
    563651{
     652  dprintf(("MSVCRT: _ismbbkana"));
    564653  /* FIXME: use lc_ctype when supported, not lc_all */
    565654  if(MSVCRT_current_lc_all_cp == 932)
    … …  
    577666{
    578667    MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
     668    dprintf(("MSVCRT: _ismbcdigit"));
    579669    return (get_char_typeW( wch ) & C1_DIGIT);
    580670}
    … …  
    752842
    753843  if(MSVCRT___mb_cur_max == 1 || c < 256)
    754     return _strset(str, c); /* ASCII CP or SB char */
     844    return MSVCRT__strset(str, c); /* ASCII CP or SB char */
    755845
    756846  c &= 0xffff; /* Strip high bits */
    … …  
    768858
    769859/*********************************************************************
     860 *              _mbsnbset(MSVCRT.@)
     861 */
     862unsigned char* _mbsnbset(unsigned char *str, unsigned int c, MSVCRT_size_t len)
     863{
     864    unsigned char *ret = str;
     865
     866    if(!len)
     867        return ret;
     868
     869    if(MSVCRT___mb_cur_max == 1 || c < 256)
     870        return _strnset(str, c, len); /* ASCII CP or SB char */
     871
     872    c &= 0xffff; /* Strip high bits */
     873
     874    while(str[0] && str[1] && (len > 1))
     875    {
     876        *str++ = c >> 8;
     877        len--;
     878        *str++ = c & 0xff;
     879        len--;
     880    }
     881    if(len && str[0]) {
     882        /* as per msdn pad with a blank character */
     883        str[0] = ' ';
     884    }
     885
     886    return ret;
     887}
     888
     889/*********************************************************************
    770890 *              _mbsnset(MSVCRT.@)
    771891 */
    … …  
    778898
    779899  if(MSVCRT___mb_cur_max == 1 || c < 256)
    780     return _strnset(str, c, len); /* ASCII CP or SB char */
     900    return MSVCRT__strnset(str, c, len); /* ASCII CP or SB char */
    781901
    782902  c &= 0xffff; /* Strip high bits */
    … …  
    842962}
    843963
     964
     965/*********************************************************************
     966 *              _mbsnbcat(MSVCRT.@)
     967 */
     968unsigned char* _mbsnbcat(unsigned char* dst, const unsigned char* src, MSVCRT_size_t len)
     969{
     970    if(MSVCRT___mb_cur_max > 1)
     971    {
     972        char *res = dst;
     973        while (*dst) {
     974            if (MSVCRT_isleadbyte(*dst++)) {
     975                if (*dst) {
     976                    dst++;
     977                } else {
     978                    /* as per msdn overwrite the lead byte in front of '\0' */
     979                    dst--;
     980                    break;
     981                }
     982            }
     983        }
     984        while (*src && len--) *dst++ = *src++;
     985        *dst = '\0';
     986        return res;
     987    }
     988    return strncat(dst, src, len); /* ASCII CP */
     989}
    844990
    845991/*********************************************************************
Note: See TracChangeset for help on using the changeset viewer.