Assorted spelling fixes.
[wine] / 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 static 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) return (table->cp2uni[ch] == wch);
73     if (ch != (unsigned char)table->info.def_char) return 1;
74     return (wch == table->info.def_unicode_char);
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 (ch == table->info.def_char && wch != table->info.def_unicode_char) return 0;
266     if (flags & WC_NO_BEST_FIT_CHARS)
267     {
268         /* check if char maps back to the same Unicode value */
269         if (ch & 0xff00)
270         {
271             unsigned char off = table->cp2uni_leadbytes[ch >> 8];
272             return (table->cp2uni[(off << 8) + (ch & 0xff)] == wch);
273         }
274         return (table->cp2uni[ch & 0xff] == wch);
275     }
276     return 1;
277 }
278
279 /* query necessary dst length for src string */
280 static int get_length_dbcs( const struct dbcs_table *table, int flags,
281                             const WCHAR *src, unsigned int srclen,
282                             const char *defchar, int *used )
283 {
284     const unsigned short * const uni2cp_low = table->uni2cp_low;
285     const unsigned short * const uni2cp_high = table->uni2cp_high;
286     WCHAR defchar_value = table->info.def_char;
287     WCHAR composed;
288     int len, tmp;
289
290     if (!defchar && !used && !(flags & WC_COMPOSITECHECK))
291     {
292         for (len = 0; srclen; srclen--, src++, len++)
293         {
294             if (uni2cp_low[uni2cp_high[*src >> 8] + (*src & 0xff)] & 0xff00) len++;
295         }
296         return len;
297     }
298
299     if (defchar) defchar_value = defchar[1] ? ((defchar[0] << 8) | defchar[1]) : defchar[0];
300     if (!used) used = &tmp;  /* avoid checking on every char */
301     *used = 0;
302     for (len = 0; srclen; len++, srclen--, src++)
303     {
304         unsigned short res;
305         WCHAR wch = *src;
306
307         if ((flags & WC_COMPOSITECHECK) && (srclen > 1) && (composed = compose(src)))
308         {
309             /* now check if we can use the composed char */
310             res = uni2cp_low[uni2cp_high[composed >> 8] + (composed & 0xff)];
311
312             if (is_valid_dbcs_mapping( table, flags, composed, res ))
313             {
314                 /* we have a good mapping for the composed char, use it */
315                 if (res & 0xff00) len++;
316                 src++;
317                 srclen--;
318                 continue;
319             }
320             /* no mapping for the composed char, check the other flags */
321             if (flags & WC_DEFAULTCHAR) /* use the default char instead */
322             {
323                 if (defchar_value & 0xff00) len++;
324                 *used = 1;
325                 src++;  /* skip the non-spacing char */
326                 srclen--;
327                 continue;
328             }
329             if (flags & WC_DISCARDNS) /* skip the second char of the composition */
330             {
331                 src++;
332                 srclen--;
333             }
334             /* WC_SEPCHARS is the default */
335         }
336
337         res = uni2cp_low[uni2cp_high[wch >> 8] + (wch & 0xff)];
338         if (!is_valid_dbcs_mapping( table, flags, wch, res ))
339         {
340             res = defchar_value;
341             *used = 1;
342         }
343         if (res & 0xff00) len++;
344     }
345     return len;
346 }
347
348 /* wcstombs for double-byte code page */
349 static inline int wcstombs_dbcs( const struct dbcs_table *table,
350                                  const WCHAR *src, unsigned int srclen,
351                                  char *dst, unsigned int dstlen )
352 {
353     const unsigned short * const uni2cp_low = table->uni2cp_low;
354     const unsigned short * const uni2cp_high = table->uni2cp_high;
355     int len;
356
357     for (len = dstlen; srclen && len; len--, srclen--, src++)
358     {
359         unsigned short res = uni2cp_low[uni2cp_high[*src >> 8] + (*src & 0xff)];
360         if (res & 0xff00)
361         {
362             if (len == 1) break;  /* do not output a partial char */
363             len--;
364             *dst++ = res >> 8;
365         }
366         *dst++ = (char)res;
367     }
368     if (srclen) return -1;  /* overflow */
369     return dstlen - len;
370 }
371
372 /* slow version of wcstombs_dbcs that handles the various flags */
373 static int wcstombs_dbcs_slow( const struct dbcs_table *table, int flags,
374                                const WCHAR *src, unsigned int srclen,
375                                char *dst, unsigned int dstlen,
376                                const char *defchar, int *used )
377 {
378     const unsigned short * const uni2cp_low = table->uni2cp_low;
379     const unsigned short * const uni2cp_high = table->uni2cp_high;
380     WCHAR defchar_value = table->info.def_char;
381     WCHAR composed;
382     int len, tmp;
383
384     if (defchar) defchar_value = defchar[1] ? ((defchar[0] << 8) | defchar[1]) : defchar[0];
385     if (!used) used = &tmp;  /* avoid checking on every char */
386     *used = 0;
387
388     for (len = dstlen; srclen && len; len--, srclen--, src++)
389     {
390         unsigned short res;
391         WCHAR wch = *src;
392
393         if ((flags & WC_COMPOSITECHECK) && (srclen > 1) && (composed = compose(src)))
394         {
395             /* now check if we can use the composed char */
396             res = uni2cp_low[uni2cp_high[composed >> 8] + (composed & 0xff)];
397
398             if (is_valid_dbcs_mapping( table, flags, composed, res ))
399             {
400                 /* we have a good mapping for the composed char, use it */
401                 src++;
402                 srclen--;
403                 goto output_char;
404             }
405             /* no mapping for the composed char, check the other flags */
406             if (flags & WC_DEFAULTCHAR) /* use the default char instead */
407             {
408                 res = defchar_value;
409                 *used = 1;
410                 src++;  /* skip the non-spacing char */
411                 srclen--;
412                 goto output_char;
413             }
414             if (flags & WC_DISCARDNS) /* skip the second char of the composition */
415             {
416                 src++;
417                 srclen--;
418             }
419             /* WC_SEPCHARS is the default */
420         }
421
422         res = uni2cp_low[uni2cp_high[wch >> 8] + (wch & 0xff)];
423         if (!is_valid_dbcs_mapping( table, flags, wch, res ))
424         {
425             res = defchar_value;
426             *used = 1;
427         }
428
429     output_char:
430         if (res & 0xff00)
431         {
432             if (len == 1) break;  /* do not output a partial char */
433             len--;
434             *dst++ = res >> 8;
435         }
436         *dst++ = (char)res;
437     }
438     if (srclen) return -1;  /* overflow */
439     return dstlen - len;
440 }
441
442 /* wide char to multi byte string conversion */
443 /* return -1 on dst buffer overflow */
444 int wine_cp_wcstombs( const union cptable *table, int flags,
445                       const WCHAR *src, int srclen,
446                       char *dst, int dstlen, const char *defchar, int *used )
447 {
448     if (table->info.char_size == 1)
449     {
450         if (flags || defchar || used)
451         {
452             if (!dstlen) return get_length_sbcs( &table->sbcs, flags, src, srclen, used );
453             return wcstombs_sbcs_slow( &table->sbcs, flags, src, srclen,
454                                        dst, dstlen, defchar, used );
455         }
456         if (!dstlen) return srclen;
457         return wcstombs_sbcs( &table->sbcs, src, srclen, dst, dstlen );
458     }
459     else /* mbcs */
460     {
461         if (!dstlen) return get_length_dbcs( &table->dbcs, flags, src, srclen, defchar, used );
462         if (flags || defchar || used)
463             return wcstombs_dbcs_slow( &table->dbcs, flags, src, srclen,
464                                        dst, dstlen, defchar, used );
465         return wcstombs_dbcs( &table->dbcs, src, srclen, dst, dstlen );
466     }
467 }
468
469 /* CP_SYMBOL implementation */
470 /* return -1 on dst buffer overflow, -2 on invalid character */
471 int wine_cpsymbol_wcstombs( const WCHAR *src, int srclen, char *dst, int dstlen)
472 {
473     int len, i;
474     if( dstlen == 0) return srclen;
475     len = dstlen > srclen ? srclen : dstlen;
476     for( i = 0; i < len; i++)
477     {
478         WCHAR w = src [ i ];
479         if( w < 0x20 )
480             dst[i] = w;
481         else if( w >= 0xf020 && w < 0xf100)
482             dst[i] = w - 0xf000;
483         else
484             return -2;
485     }
486     if( srclen > len) return -1;
487     return len;
488 }