libs/wine/wctomb.c

   1 /*
   2  * WideCharToMultiByte implementation
   3  *
   4  * Copyright 2000 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <string.h>
  22
  23 #include "wine/unicode.h"
  24
  25 /* search for a character in the unicode_compose_table; helper for compose() */
  26 static inline int binary_search( WCHAR ch, int low, int high )
  27 {
  28     extern const WCHAR unicode_compose_table[];
  29     while (low <= high)
  30     {
  31         int pos = (low + high) / 2;
  32         if (unicode_compose_table[2*pos] < ch)
  33         {
  34             low = pos + 1;
  35             continue;
  36         }
  37         if (unicode_compose_table[2*pos] > ch)
  38         {
  39             high = pos - 1;
  40             continue;
  41         }
  42         return pos;
  43     }
  44     return -1;
  45 }
  46
  47 /* return the result of the composition of two Unicode chars, or 0 if none */
  48 WCHAR compose( const WCHAR *str )
  49 {
  50     extern const WCHAR unicode_compose_table[];
  51     extern const unsigned int unicode_compose_table_size;
  52
  53     int idx = 1, low = 0, high = unicode_compose_table_size - 1;
  54     for (;;)
  55     {
  56         int pos = binary_search( str[idx], low, high );
  57         if (pos == -1) return 0;
  58         if (!idx--) return unicode_compose_table[2*pos+1];
  59         low = unicode_compose_table[2*pos+1];
  60         high = unicode_compose_table[2*pos+3] - 1;
  61     }
  62 }
  63
  64
  65 /****************************************************************/
  66 /* sbcs support */
  67
  68 /* check if 'ch' is an acceptable sbcs mapping for 'wch' */
  69 static inline int is_valid_sbcs_mapping( const struct sbcs_table *table, int flags,
  70                                          WCHAR wch, unsigned char ch )
  71 {
  72     if ((flags & WC_NO_BEST_FIT_CHARS) || ch == (unsigned char)table->info.def_char)
  73         return (table->cp2uni[ch] == wch);
  74     return 1;
  75 }
  76
  77 /* query necessary dst length for src string */
  78 static int get_length_sbcs( const struct sbcs_table *table, int flags,
  79                             const WCHAR *src, unsigned int srclen, int *used )
  80 {
  81     const unsigned char  * const uni2cp_low = table->uni2cp_low;
  82     const unsigned short * const uni2cp_high = table->uni2cp_high;
  83     int ret, tmp;
  84     WCHAR composed;
  85
  86     if (!used) used = &tmp;  /* avoid checking on every char */
  87     *used = 0;
  88
  89     for (ret = 0; srclen; ret++, src++, srclen--)
  90     {
  91         WCHAR wch = *src;
  92         unsigned char ch;
  93
  94         if ((flags & WC_COMPOSITECHECK) && (srclen > 1) && (composed = compose(src)))
  95         {
  96             /* now check if we can use the composed char */
  97             ch = uni2cp_low[uni2cp_high[composed >> 8] + (composed & 0xff)];
  98             if (is_valid_sbcs_mapping( table, flags, composed, ch ))
  99             {
 100                 /* we have a good mapping, use it */
 101                 src++;
 102                 srclen--;
 103                 continue;
 104             }
 105             /* no mapping for the composed char, check the other flags */
 106             if (flags & WC_DEFAULTCHAR) /* use the default char instead */
 107             {
 108                 *used = 1;
 109                 src++;  /* skip the non-spacing char */
 110                 srclen--;
 111                 continue;
 112             }
 113             if (flags & WC_DISCARDNS) /* skip the second char of the composition */
 114             {
 115                 src++;
 116                 srclen--;
 117             }
 118             /* WC_SEPCHARS is the default */
 119         }
 120         if (!*used)
 121         {
 122             ch = uni2cp_low[uni2cp_high[wch >> 8] + (wch & 0xff)];
 123             *used = !is_valid_sbcs_mapping( table, flags, wch, ch );
 124         }
 125     }
 126     return ret;
 127 }
 128
 129 /* wcstombs for single-byte code page */
 130 static inline int wcstombs_sbcs( const struct sbcs_table *table,
 131                                  const WCHAR *src, unsigned int srclen,
 132                                  char *dst, unsigned int dstlen )
 133 {
 134     const unsigned char  * const uni2cp_low = table->uni2cp_low;
 135     const unsigned short * const uni2cp_high = table->uni2cp_high;
 136     int ret = srclen;
 137
 138     if (dstlen < srclen)
 139     {
 140         /* buffer too small: fill it up to dstlen and return error */
 141         srclen = dstlen;
 142         ret = -1;
 143     }
 144
 145     while (srclen >= 16)
 146     {
 147         dst[0]  = uni2cp_low[uni2cp_high[src[0]  >> 8] + (src[0]  & 0xff)];
 148         dst[1]  = uni2cp_low[uni2cp_high[src[1]  >> 8] + (src[1]  & 0xff)];
 149         dst[2]  = uni2cp_low[uni2cp_high[src[2]  >> 8] + (src[2]  & 0xff)];
 150         dst[3]  = uni2cp_low[uni2cp_high[src[3]  >> 8] + (src[3]  & 0xff)];
 151         dst[4]  = uni2cp_low[uni2cp_high[src[4]  >> 8] + (src[4]  & 0xff)];
 152         dst[5]  = uni2cp_low[uni2cp_high[src[5]  >> 8] + (src[5]  & 0xff)];
 153         dst[6]  = uni2cp_low[uni2cp_high[src[6]  >> 8] + (src[6]  & 0xff)];
 154         dst[7]  = uni2cp_low[uni2cp_high[src[7]  >> 8] + (src[7]  & 0xff)];
 155         dst[8]  = uni2cp_low[uni2cp_high[src[8]  >> 8] + (src[8]  & 0xff)];
 156         dst[9]  = uni2cp_low[uni2cp_high[src[9]  >> 8] + (src[9]  & 0xff)];
 157         dst[10] = uni2cp_low[uni2cp_high[src[10] >> 8] + (src[10] & 0xff)];
 158         dst[11] = uni2cp_low[uni2cp_high[src[11] >> 8] + (src[11] & 0xff)];
 159         dst[12] = uni2cp_low[uni2cp_high[src[12] >> 8] + (src[12] & 0xff)];
 160         dst[13] = uni2cp_low[uni2cp_high[src[13] >> 8] + (src[13] & 0xff)];
 161         dst[14] = uni2cp_low[uni2cp_high[src[14] >> 8] + (src[14] & 0xff)];
 162         dst[15] = uni2cp_low[uni2cp_high[src[15] >> 8] + (src[15] & 0xff)];
 163         src += 16;
 164         dst += 16;
 165         srclen -= 16;
 166     }
 167
 168     /* now handle remaining characters */
 169     src += srclen;
 170     dst += srclen;
 171     switch(srclen)
 172     {
 173     case 15: dst[-15] = uni2cp_low[uni2cp_high[src[-15] >> 8] + (src[-15] & 0xff)];
 174     case 14: dst[-14] = uni2cp_low[uni2cp_high[src[-14] >> 8] + (src[-14] & 0xff)];
 175     case 13: dst[-13] = uni2cp_low[uni2cp_high[src[-13] >> 8] + (src[-13] & 0xff)];
 176     case 12: dst[-12] = uni2cp_low[uni2cp_high[src[-12] >> 8] + (src[-12] & 0xff)];
 177     case 11: dst[-11] = uni2cp_low[uni2cp_high[src[-11] >> 8] + (src[-11] & 0xff)];
 178     case 10: dst[-10] = uni2cp_low[uni2cp_high[src[-10] >> 8] + (src[-10] & 0xff)];
 179     case 9:  dst[-9]  = uni2cp_low[uni2cp_high[src[-9]  >> 8] + (src[-9]  & 0xff)];
 180     case 8:  dst[-8]  = uni2cp_low[uni2cp_high[src[-8]  >> 8] + (src[-8]  & 0xff)];
 181     case 7:  dst[-7]  = uni2cp_low[uni2cp_high[src[-7]  >> 8] + (src[-7]  & 0xff)];
 182     case 6:  dst[-6]  = uni2cp_low[uni2cp_high[src[-6]  >> 8] + (src[-6]  & 0xff)];
 183     case 5:  dst[-5]  = uni2cp_low[uni2cp_high[src[-5]  >> 8] + (src[-5]  & 0xff)];
 184     case 4:  dst[-4]  = uni2cp_low[uni2cp_high[src[-4]  >> 8] + (src[-4]  & 0xff)];
 185     case 3:  dst[-3]  = uni2cp_low[uni2cp_high[src[-3]  >> 8] + (src[-3]  & 0xff)];
 186     case 2:  dst[-2]  = uni2cp_low[uni2cp_high[src[-2]  >> 8] + (src[-2]  & 0xff)];
 187     case 1:  dst[-1]  = uni2cp_low[uni2cp_high[src[-1]  >> 8] + (src[-1]  & 0xff)];
 188     case 0: break;
 189     }
 190     return ret;
 191 }
 192
 193 /* slow version of wcstombs_sbcs that handles the various flags */
 194 static int wcstombs_sbcs_slow( const struct sbcs_table *table, int flags,
 195                                const WCHAR *src, unsigned int srclen,
 196                                char *dst, unsigned int dstlen,
 197                                const char *defchar, int *used )
 198 {
 199     const unsigned char  * const uni2cp_low = table->uni2cp_low;
 200     const unsigned short * const uni2cp_high = table->uni2cp_high;
 201     unsigned char def;
 202     unsigned int len;
 203     int tmp;
 204     WCHAR composed;
 205
 206     if (!defchar)
 207         def = table->info.def_char & 0xff;
 208     else
 209         def = *defchar;
 210
 211     if (!used) used = &tmp;  /* avoid checking on every char */
 212     *used = 0;
 213
 214     for (len = dstlen; srclen && len; dst++, len--, src++, srclen--)
 215     {
 216         WCHAR wch = *src;
 217
 218         if ((flags & WC_COMPOSITECHECK) && (srclen > 1) && (composed = compose(src)))
 219         {
 220             /* now check if we can use the composed char */
 221             *dst = uni2cp_low[uni2cp_high[composed >> 8] + (composed & 0xff)];
 222             if (is_valid_sbcs_mapping( table, flags, composed, *dst ))
 223             {
 224                 /* we have a good mapping, use it */
 225                 src++;
 226                 srclen--;
 227                 continue;
 228             }
 229             /* no mapping for the composed char, check the other flags */
 230             if (flags & WC_DEFAULTCHAR) /* use the default char instead */
 231             {
 232                 *dst = def;
 233                 *used = 1;
 234                 src++;  /* skip the non-spacing char */
 235                 srclen--;
 236                 continue;
 237             }
 238             if (flags & WC_DISCARDNS) /* skip the second char of the composition */
 239             {
 240                 src++;
 241                 srclen--;
 242             }
 243             /* WC_SEPCHARS is the default */
 244         }
 245
 246         *dst = uni2cp_low[uni2cp_high[wch >> 8] + (wch & 0xff)];
 247         if (!is_valid_sbcs_mapping( table, flags, wch, *dst ))
 248         {
 249             *dst = def;
 250             *used = 1;
 251         }
 252     }
 253     if (srclen) return -1;  /* overflow */
 254     return dstlen - len;
 255 }
 256
 257
 258 /****************************************************************/
 259 /* dbcs support */
 260
 261 /* check if 'ch' is an acceptable dbcs mapping for 'wch' */
 262 static inline int is_valid_dbcs_mapping( const struct dbcs_table *table, int flags,
 263                                          WCHAR wch, unsigned short ch )
 264 {
 265     if ((flags & WC_NO_BEST_FIT_CHARS) || ch == table->info.def_char)
 266     {
 267         /* check if char maps back to the same Unicode value */
 268         if (ch & 0xff00)
 269         {
 270             unsigned char off = table->cp2uni_leadbytes[ch >> 8];
 271             return (table->cp2uni[(off << 8) + (ch & 0xff)] == wch);
 272         }
 273         return (table->cp2uni[ch & 0xff] == wch);
 274     }
 275     return 1;
 276 }
 277
 278 /* query necessary dst length for src string */
 279 static int get_length_dbcs( const struct dbcs_table *table, int flags,
 280                             const WCHAR *src, unsigned int srclen,
 281                             const char *defchar, int *used )
 282 {
 283     const unsigned short * const uni2cp_low = table->uni2cp_low;
 284     const unsigned short * const uni2cp_high = table->uni2cp_high;
 285     WCHAR defchar_value = table->info.def_char;
 286     WCHAR composed;
 287     int len, tmp;
 288
 289     if (!defchar && !used && !(flags & WC_COMPOSITECHECK))
 290     {
 291         for (len = 0; srclen; srclen--, src++, len++)
 292         {
 293             if (uni2cp_low[uni2cp_high[*src >> 8] + (*src & 0xff)] & 0xff00) len++;
 294         }
 295         return len;
 296     }
 297
 298     if (defchar) defchar_value = defchar[1] ? ((defchar[0] << 8) | defchar[1]) : defchar[0];
 299     if (!used) used = &tmp;  /* avoid checking on every char */
 300     *used = 0;
 301     for (len = 0; srclen; len++, srclen--, src++)
 302     {
 303         unsigned short res;
 304         WCHAR wch = *src;
 305
 306         if ((flags & WC_COMPOSITECHECK) && (srclen > 1) && (composed = compose(src)))
 307         {
 308             /* now check if we can use the composed char */
 309             res = uni2cp_low[uni2cp_high[composed >> 8] + (composed & 0xff)];
 310
 311             if (is_valid_dbcs_mapping( table, flags, composed, res ))
 312             {
 313                 /* we have a good mapping for the composed char, use it */
 314                 if (res & 0xff00) len++;
 315                 src++;
 316                 srclen--;
 317                 continue;
 318             }
 319             /* no mapping for the composed char, check the other flags */
 320             if (flags & WC_DEFAULTCHAR) /* use the default char instead */
 321             {
 322                 if (defchar_value & 0xff00) len++;
 323                 *used = 1;
 324                 src++;  /* skip the non-spacing char */
 325                 srclen--;
 326                 continue;
 327             }
 328             if (flags & WC_DISCARDNS) /* skip the second char of the composition */
 329             {
 330                 src++;
 331                 srclen--;
 332             }
 333             /* WC_SEPCHARS is the default */
 334         }
 335
 336         res = uni2cp_low[uni2cp_high[wch >> 8] + (wch & 0xff)];
 337         if (!is_valid_dbcs_mapping( table, flags, wch, res ))
 338         {
 339             res = defchar_value;
 340             *used = 1;
 341         }
 342         if (res & 0xff00) len++;
 343     }
 344     return len;
 345 }
 346
 347 /* wcstombs for double-byte code page */
 348 static inline int wcstombs_dbcs( const struct dbcs_table *table,
 349                                  const WCHAR *src, unsigned int srclen,
 350                                  char *dst, unsigned int dstlen )
 351 {
 352     const unsigned short * const uni2cp_low = table->uni2cp_low;
 353     const unsigned short * const uni2cp_high = table->uni2cp_high;
 354     int len;
 355
 356     for (len = dstlen; srclen && len; len--, srclen--, src++)
 357     {
 358         unsigned short res = uni2cp_low[uni2cp_high[*src >> 8] + (*src & 0xff)];
 359         if (res & 0xff00)
 360         {
 361             if (len == 1) break;  /* do not output a partial char */
 362             len--;
 363             *dst++ = res >> 8;
 364         }
 365         *dst++ = (char)res;
 366     }
 367     if (srclen) return -1;  /* overflow */
 368     return dstlen - len;
 369 }
 370
 371 /* slow version of wcstombs_dbcs that handles the various flags */
 372 static int wcstombs_dbcs_slow( const struct dbcs_table *table, int flags,
 373                                const WCHAR *src, unsigned int srclen,
 374                                char *dst, unsigned int dstlen,
 375                                const char *defchar, int *used )
 376 {
 377     const unsigned short * const uni2cp_low = table->uni2cp_low;
 378     const unsigned short * const uni2cp_high = table->uni2cp_high;
 379     WCHAR defchar_value = table->info.def_char;
 380     WCHAR composed;
 381     int len, tmp;
 382
 383     if (defchar) defchar_value = defchar[1] ? ((defchar[0] << 8) | defchar[1]) : defchar[0];
 384     if (!used) used = &tmp;  /* avoid checking on every char */
 385     *used = 0;
 386
 387     for (len = dstlen; srclen && len; len--, srclen--, src++)
 388     {
 389         unsigned short res;
 390         WCHAR wch = *src;
 391
 392         if ((flags & WC_COMPOSITECHECK) && (srclen > 1) && (composed = compose(src)))
 393         {
 394             /* now check if we can use the composed char */
 395             res = uni2cp_low[uni2cp_high[composed >> 8] + (composed & 0xff)];
 396
 397             if (is_valid_dbcs_mapping( table, flags, composed, res ))
 398             {
 399                 /* we have a good mapping for the composed char, use it */
 400                 src++;
 401                 srclen--;
 402                 goto output_char;
 403             }
 404             /* no mapping for the composed char, check the other flags */
 405             if (flags & WC_DEFAULTCHAR) /* use the default char instead */
 406             {
 407                 res = defchar_value;
 408                 *used = 1;
 409                 src++;  /* skip the non-spacing char */
 410                 srclen--;
 411                 goto output_char;
 412             }
 413             if (flags & WC_DISCARDNS) /* skip the second char of the composition */
 414             {
 415                 src++;
 416                 srclen--;
 417             }
 418             /* WC_SEPCHARS is the default */
 419         }
 420
 421         res = uni2cp_low[uni2cp_high[wch >> 8] + (wch & 0xff)];
 422         if (!is_valid_dbcs_mapping( table, flags, wch, res ))
 423         {
 424             res = defchar_value;
 425             *used = 1;
 426         }
 427
 428     output_char:
 429         if (res & 0xff00)
 430         {
 431             if (len == 1) break;  /* do not output a partial char */
 432             len--;
 433             *dst++ = res >> 8;
 434         }
 435         *dst++ = (char)res;
 436     }
 437     if (srclen) return -1;  /* overflow */
 438     return dstlen - len;
 439 }
 440
 441 /* wide char to multi byte string conversion */
 442 /* return -1 on dst buffer overflow */
 443 int wine_cp_wcstombs( const union cptable *table, int flags,
 444                       const WCHAR *src, int srclen,
 445                       char *dst, int dstlen, const char *defchar, int *used )
 446 {
 447     if (table->info.char_size == 1)
 448     {
 449         if (flags || defchar || used)
 450         {
 451             if (!dstlen) return get_length_sbcs( &table->sbcs, flags, src, srclen, used );
 452             return wcstombs_sbcs_slow( &table->sbcs, flags, src, srclen,
 453                                        dst, dstlen, defchar, used );
 454         }
 455         if (!dstlen) return srclen;
 456         return wcstombs_sbcs( &table->sbcs, src, srclen, dst, dstlen );
 457     }
 458     else /* mbcs */
 459     {
 460         if (!dstlen) return get_length_dbcs( &table->dbcs, flags, src, srclen, defchar, used );
 461         if (flags || defchar || used)
 462             return wcstombs_dbcs_slow( &table->dbcs, flags, src, srclen,
 463                                        dst, dstlen, defchar, used );
 464         return wcstombs_dbcs( &table->dbcs, src, srclen, dst, dstlen );
 465     }
 466 }
 467
 468 /* CP_SYMBOL implementation */
 469 /* return -1 on dst buffer overflow, -2 on invalid character */
 470 int wine_cpsymbol_wcstombs( const WCHAR *src, int srclen, char *dst, int dstlen)
 471 {
 472     int len, i;
 473     if( dstlen == 0) return srclen;
 474     len = dstlen > srclen ? srclen : dstlen;
 475     for( i = 0; i < len; i++)
 476     {
 477         WCHAR w = src [ i ];
 478         if( w < 0x20 )
 479             dst[i] = w;
 480         else if( w >= 0xf020 && w < 0xf100)
 481             dst[i] = w - 0xf000;
 482         else
 483             return -2;
 484     }
 485     if( srclen > len) return -1;
 486     return len;
 487 }