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