daily update
[binutils.git] / binutils / winduni.c
blobbf5dbd43a127e952a54b0e2cfd681738eab70268
1 /* winduni.c -- unicode support for the windres program.
2 Copyright 1997, 1998, 2000, 2001, 2003, 2007
3 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor, Cygnus Support.
5 Rewritten by Kai Tietz, Onevision.
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
25 /* This file contains unicode support routines for the windres
26 program. Ideally, we would have generic unicode support which
27 would work on all systems. However, we don't. Instead, on a
28 Windows host, we are prepared to call some Windows routines. This
29 means that we will generate different output on Windows and Unix
30 hosts, but that seems better than not really supporting unicode at
31 all. */
33 #include "sysdep.h"
34 #include "bfd.h"
35 #include "libiberty.h" /* for xstrdup */
36 #include "bucomm.h"
37 /* Must be include before windows.h and winnls.h. */
38 #if defined (_WIN32) || defined (__CYGWIN__)
39 #include <windows.h>
40 #include <winnls.h>
41 #endif
42 #include "winduni.h"
43 #include "safe-ctype.h"
45 #if HAVE_ICONV_H
46 #include <iconv.h>
47 #endif
49 static rc_uint_type wind_WideCharToMultiByte (rc_uint_type, const unichar *, char *, rc_uint_type);
50 static rc_uint_type wind_MultiByteToWideChar (rc_uint_type, const char *, unichar *, rc_uint_type);
51 static int unichar_isascii (const unichar *, rc_uint_type);
53 /* Convert an ASCII string to a unicode string. We just copy it,
54 expanding chars to shorts, rather than doing something intelligent. */
56 #if !defined (_WIN32) && !defined (__CYGWIN__)
58 /* Codepages mapped. */
59 static local_iconv_map codepages[] =
61 { 0, "MS-ANSI" },
62 { 1, "WINDOWS-1252" },
63 { 437, "MS-ANSI" },
64 { 737, "MS-GREEK" },
65 { 775, "WINBALTRIM" },
66 { 850, "MS-ANSI" },
67 { 852, "MS-EE" },
68 { 857, "MS-TURK" },
69 { 862, "CP862" },
70 { 864, "CP864" },
71 { 866, "MS-CYRL" },
72 { 874, "WINDOWS-874" },
73 { 932, "CP932" },
74 { 936, "CP936" },
75 { 949, "CP949" },
76 { 950, "CP950" },
77 { 1250, "WINDOWS-1250" },
78 { 1251, "WINDOWS-1251" },
79 { 1252, "WINDOWS-1252" },
80 { 1253, "WINDOWS-1253" },
81 { 1254, "WINDOWS-1254" },
82 { 1255, "WINDOWS-1255" },
83 { 1256, "WINDOWS-1256" },
84 { 1257, "WINDOWS-1257" },
85 { 1258, "WINDOWS-1258" },
86 { CP_UTF7, "UTF-7" },
87 { CP_UTF8, "UTF-8" },
88 { CP_UTF16, "UTF-16" },
89 { (rc_uint_type) -1, NULL }
92 /* Languages supported. */
93 static const wind_language_t languages[] =
95 { 0x0000, 437, 1252, "Neutral", "Neutral" },
96 { 0x0401, 864, 1256, "Arabic", "Saudi Arabia" }, { 0x0402, 866, 1251, "Bulgarian", "Bulgaria" },
97 { 0x0403, 850, 1252, "Catalan", "Spain" }, { 0x0404, 950, 950, "Chinese", "Taiwan" },
98 { 0x0405, 852, 1250, "Czech", "Czech Republic" }, { 0x0406, 850, 1252, "Danish", "Denmark" },
99 { 0x0407, 850, 1252, "German", "Germany" }, { 0x0408, 737, 1253, "Greek", "Greece" },
100 { 0x0409, 437, 1252, "English", "United States" }, { 0x040A, 850, 1252, "Spanish - Traditional Sort", "Spain" },
101 { 0x040B, 850, 1252, "Finnish", "Finland" }, { 0x040C, 850, 1252, "French", "France" },
102 { 0x040D, 862, 1255, "Hebrew", "Israel" }, { 0x040E, 852, 1250, "Hungarian", "Hungary" },
103 { 0x040F, 850, 1252, "Icelandic", "Iceland" }, { 0x0410, 850, 1252, "Italian", "Italy" },
104 { 0x0411, 932, 932, "Japanese", "Japan" }, { 0x0412, 949, 949, "Korean", "Korea (south)" },
105 { 0x0413, 850, 1252, "Dutch", "Netherlands" }, { 0x0414, 850, 1252, "Norwegian (Bokmål)", "Norway" },
106 { 0x0415, 852, 1250, "Polish", "Poland" }, { 0x0416, 850, 1252, "Portuguese", "Brazil" },
107 { 0x0418, 852, 1250, "Romanian", "Romania" }, { 0x0419, 866, 1251, "Russian", "Russia" },
108 { 0x041A, 852, 1250, "Croatian", "Croatia" }, { 0x041B, 852, 1250, "Slovak", "Slovakia" },
109 { 0x041C, 852, 1250, "Albanian", "Albania" }, { 0x041D, 850, 1252, "Swedish", "Sweden" },
110 { 0x041E, 874, 874, "Thai", "Thailand" }, { 0x041F, 857, 1254, "Turkish", "Turkey" },
111 { 0x0421, 850, 1252, "Indonesian", "Indonesia" }, { 0x0422, 866, 1251, "Ukrainian", "Ukraine" },
112 { 0x0423, 866, 1251, "Belarusian", "Belarus" }, { 0x0424, 852, 1250, "Slovene", "Slovenia" },
113 { 0x0425, 775, 1257, "Estonian", "Estonia" }, { 0x0426, 775, 1257, "Latvian", "Latvia" },
114 { 0x0427, 775, 1257, "Lithuanian", "Lithuania" },
115 { 0x0429, 864, 1256, "Arabic", "Farsi" }, { 0x042A,1258, 1258, "Vietnamese", "Vietnam" },
116 { 0x042D, 850, 1252, "Basque", "Spain" },
117 { 0x042F, 866, 1251, "Macedonian", "Former Yugoslav Republic of Macedonia" },
118 { 0x0436, 850, 1252, "Afrikaans", "South Africa" },
119 { 0x0438, 850, 1252, "Faroese", "Faroe Islands" },
120 { 0x043C, 437, 1252, "Irish", "Ireland" },
121 { 0x043E, 850, 1252, "Malay", "Malaysia" },
122 { 0x0801, 864, 1256, "Arabic", "Iraq" },
123 { 0x0804, 936, 936, "Chinese (People's republic of China)", "People's republic of China" },
124 { 0x0807, 850, 1252, "German", "Switzerland" },
125 { 0x0809, 850, 1252, "English", "United Kingdom" }, { 0x080A, 850, 1252, "Spanish", "Mexico" },
126 { 0x080C, 850, 1252, "French", "Belgium" },
127 { 0x0810, 850, 1252, "Italian", "Switzerland" },
128 { 0x0813, 850, 1252, "Dutch", "Belgium" }, { 0x0814, 850, 1252, "Norwegian (Nynorsk)", "Norway" },
129 { 0x0816, 850, 1252, "Portuguese", "Portugal" },
130 { 0x081A, 852, 1252, "Serbian (latin)", "Yugoslavia" },
131 { 0x081D, 850, 1252, "Swedish (Finland)", "Finland" },
132 { 0x0C01, 864, 1256, "Arabic", "Egypt" },
133 { 0x0C04, 950, 950, "Chinese", "Hong Kong" },
134 { 0x0C07, 850, 1252, "German", "Austria" },
135 { 0x0C09, 850, 1252, "English", "Australia" }, { 0x0C0A, 850, 1252, "Spanish - International Sort", "Spain" },
136 { 0x0C0C, 850, 1252, "French", "Canada"},
137 { 0x0C1A, 855, 1251, "Serbian (Cyrillic)", "Serbia" },
138 { 0x1001, 864, 1256, "Arabic", "Libya" },
139 { 0x1004, 936, 936, "Chinese", "Singapore" },
140 { 0x1007, 850, 1252, "German", "Luxembourg" },
141 { 0x1009, 850, 1252, "English", "Canada" },
142 { 0x100A, 850, 1252, "Spanish", "Guatemala" },
143 { 0x100C, 850, 1252, "French", "Switzerland" },
144 { 0x1401, 864, 1256, "Arabic", "Algeria" },
145 { 0x1407, 850, 1252, "German", "Liechtenstein" },
146 { 0x1409, 850, 1252, "English", "New Zealand" }, { 0x140A, 850, 1252, "Spanish", "Costa Rica" },
147 { 0x140C, 850, 1252, "French", "Luxembourg" },
148 { 0x1801, 864, 1256, "Arabic", "Morocco" },
149 { 0x1809, 850, 1252, "English", "Ireland" }, { 0x180A, 850, 1252, "Spanish", "Panama" },
150 { 0x180C, 850, 1252, "French", "Monaco" },
151 { 0x1C01, 864, 1256, "Arabic", "Tunisia" },
152 { 0x1C09, 437, 1252, "English", "South Africa" }, { 0x1C0A, 850, 1252, "Spanish", "Dominican Republic" },
153 { 0x2001, 864, 1256, "Arabic", "Oman" },
154 { 0x2009, 850, 1252, "English", "Jamaica" }, { 0x200A, 850, 1252, "Spanish", "Venezuela" },
155 { 0x2401, 864, 1256, "Arabic", "Yemen" },
156 { 0x2409, 850, 1252, "English", "Caribbean" }, { 0x240A, 850, 1252, "Spanish", "Colombia" },
157 { 0x2801, 864, 1256, "Arabic", "Syria" },
158 { 0x2809, 850, 1252, "English", "Belize" }, { 0x280A, 850, 1252, "Spanish", "Peru" },
159 { 0x2C01, 864, 1256, "Arabic", "Jordan" },
160 { 0x2C09, 437, 1252, "English", "Trinidad & Tobago" },{ 0x2C0A, 850, 1252, "Spanish", "Argentina" },
161 { 0x3001, 864, 1256, "Arabic", "Lebanon" },
162 { 0x3009, 437, 1252, "English", "Zimbabwe" }, { 0x300A, 850, 1252, "Spanish", "Ecuador" },
163 { 0x3401, 864, 1256, "Arabic", "Kuwait" },
164 { 0x3409, 437, 1252, "English", "Philippines" }, { 0x340A, 850, 1252, "Spanish", "Chile" },
165 { 0x3801, 864, 1256, "Arabic", "United Arab Emirates" },
166 { 0x380A, 850, 1252, "Spanish", "Uruguay" },
167 { 0x3C01, 864, 1256, "Arabic", "Bahrain" },
168 { 0x3C0A, 850, 1252, "Spanish", "Paraguay" },
169 { 0x4001, 864, 1256, "Arabic", "Qatar" },
170 { 0x400A, 850, 1252, "Spanish", "Bolivia" },
171 { 0x440A, 850, 1252, "Spanish", "El Salvador" },
172 { 0x480A, 850, 1252, "Spanish", "Honduras" },
173 { 0x4C0A, 850, 1252, "Spanish", "Nicaragua" },
174 { 0x500A, 850, 1252, "Spanish", "Puerto Rico" },
175 { (unsigned) -1, 0, 0, NULL, NULL }
178 #endif
180 /* Specifies the default codepage to be used for unicode
181 transformations. By default this is CP_ACP. */
182 rc_uint_type wind_default_codepage = CP_ACP;
184 /* Specifies the currently used codepage for unicode
185 transformations. By default this is CP_ACP. */
186 rc_uint_type wind_current_codepage = CP_ACP;
188 /* Convert an ASCII string to a unicode string. We just copy it,
189 expanding chars to shorts, rather than doing something intelligent. */
191 void
192 unicode_from_ascii (rc_uint_type *length, unichar **unicode, const char *ascii)
194 unicode_from_codepage (length, unicode, ascii, wind_current_codepage);
197 /* Convert an unicode string to an ASCII string. We just copy it,
198 shrink shorts to chars, rather than doing something intelligent.
199 Shorts with not within the char range are replaced by '_'. */
201 void
202 ascii_from_unicode (rc_uint_type *length, const unichar *unicode, char **ascii)
204 codepage_from_unicode (length, unicode, ascii, wind_current_codepage);
207 /* Print the unicode string UNICODE to the file E. LENGTH is the
208 number of characters to print, or -1 if we should print until the
209 end of the string. FIXME: On a Windows host, we should be calling
210 some Windows function, probably WideCharToMultiByte. */
212 void
213 unicode_print (FILE *e, const unichar *unicode, rc_uint_type length)
215 while (1)
217 unichar ch;
219 if (length == 0)
220 return;
221 if ((bfd_signed_vma) length > 0)
222 --length;
224 ch = *unicode;
226 if (ch == 0 && (bfd_signed_vma) length < 0)
227 return;
229 ++unicode;
231 if ((ch & 0x7f) == ch)
233 if (ch == '\\')
234 fputs ("\\\\", e);
235 else if (ch == '"')
236 fputs ("\"\"", e);
237 else if (ISPRINT (ch))
238 putc (ch, e);
239 else
241 switch (ch)
243 case ESCAPE_A:
244 fputs ("\\a", e);
245 break;
247 case ESCAPE_B:
248 fputs ("\\b", e);
249 break;
251 case ESCAPE_F:
252 fputs ("\\f", e);
253 break;
255 case ESCAPE_N:
256 fputs ("\\n", e);
257 break;
259 case ESCAPE_R:
260 fputs ("\\r", e);
261 break;
263 case ESCAPE_T:
264 fputs ("\\t", e);
265 break;
267 case ESCAPE_V:
268 fputs ("\\v", e);
269 break;
271 default:
272 fprintf (e, "\\%03o", (unsigned int) ch);
273 break;
277 else if ((ch & 0xff) == ch)
278 fprintf (e, "\\%03o", (unsigned int) ch);
279 else
280 fprintf (e, "\\x%04x", (unsigned int) ch);
284 /* Print a unicode string to a file. */
286 void
287 ascii_print (FILE *e, const char *s, rc_uint_type length)
289 while (1)
291 char ch;
293 if (length == 0)
294 return;
295 if ((bfd_signed_vma) length > 0)
296 --length;
298 ch = *s;
300 if (ch == 0 && (bfd_signed_vma) length < 0)
301 return;
303 ++s;
305 if ((ch & 0x7f) == ch)
307 if (ch == '\\')
308 fputs ("\\\\", e);
309 else if (ch == '"')
310 fputs ("\"\"", e);
311 else if (ISPRINT (ch))
312 putc (ch, e);
313 else
315 switch (ch)
317 case ESCAPE_A:
318 fputs ("\\a", e);
319 break;
321 case ESCAPE_B:
322 fputs ("\\b", e);
323 break;
325 case ESCAPE_F:
326 fputs ("\\f", e);
327 break;
329 case ESCAPE_N:
330 fputs ("\\n", e);
331 break;
333 case ESCAPE_R:
334 fputs ("\\r", e);
335 break;
337 case ESCAPE_T:
338 fputs ("\\t", e);
339 break;
341 case ESCAPE_V:
342 fputs ("\\v", e);
343 break;
345 default:
346 fprintf (e, "\\%03o", (unsigned int) ch);
347 break;
351 else
352 fprintf (e, "\\%03o", (unsigned int) ch & 0xff);
356 rc_uint_type
357 unichar_len (const unichar *unicode)
359 rc_uint_type r = 0;
361 if (unicode)
362 while (unicode[r] != 0)
363 r++;
364 else
365 --r;
366 return r;
369 unichar *
370 unichar_dup (const unichar *unicode)
372 unichar *r;
373 int len;
375 if (! unicode)
376 return NULL;
377 for (len = 0; unicode[len] != 0; ++len)
379 ++len;
380 r = ((unichar *) res_alloc (len * sizeof (unichar)));
381 memcpy (r, unicode, len * sizeof (unichar));
382 return r;
385 unichar *
386 unichar_dup_uppercase (const unichar *u)
388 unichar *r = unichar_dup (u);
389 int i;
391 if (! r)
392 return NULL;
394 for (i = 0; r[i] != 0; ++i)
396 if (r[i] >= 'a' && r[i] <= 'z')
397 r[i] &= 0xdf;
399 return r;
402 static int
403 unichar_isascii (const unichar *u, rc_uint_type len)
405 rc_uint_type i;
407 if ((bfd_signed_vma) len < 0)
409 if (u)
410 len = (rc_uint_type) unichar_len (u);
411 else
412 len = 0;
415 for (i = 0; i < len; i++)
416 if ((u[i] & 0xff80) != 0)
417 return 0;
418 return 1;
421 void
422 unicode_print_quoted (FILE *e, const unichar *u, rc_uint_type len)
424 if (! unichar_isascii (u, len))
425 fputc ('L', e);
426 fputc ('"', e);
427 unicode_print (e, u, len);
428 fputc ('"', e);
432 unicode_is_valid_codepage (rc_uint_type cp)
434 if ((cp & 0xffff) != cp)
435 return 0;
436 if (cp == CP_UTF16 || cp == CP_ACP)
437 return 1;
439 #if !defined (_WIN32) && !defined (__CYGWIN__)
440 if (! wind_find_codepage_info (cp))
441 return 0;
442 return 1;
443 #else
444 return !! IsValidCodePage ((UINT) cp);
445 #endif
448 #if defined (_WIN32) || defined (__CYGWIN__)
450 #define max_cp_string_len 6
452 static unsigned int
453 codepage_from_langid (unsigned short langid)
455 char cp_string [max_cp_string_len];
456 int c;
458 memset (cp_string, 0, max_cp_string_len);
459 /* LOCALE_RETURN_NUMBER flag would avoid strtoul conversion,
460 but is unavailable on Win95. */
461 c = GetLocaleInfoA (MAKELCID (langid, SORT_DEFAULT),
462 LOCALE_IDEFAULTANSICODEPAGE,
463 cp_string, max_cp_string_len);
464 /* If codepage data for an LCID is not installed on users's system,
465 GetLocaleInfo returns an empty string. Fall back to system ANSI
466 default. */
467 if (c == 0)
468 return CP_ACP;
469 return strtoul (cp_string, 0, 10);
472 static unsigned int
473 wincodepage_from_langid (unsigned short langid)
475 char cp_string [max_cp_string_len];
476 int c;
478 memset (cp_string, 0, max_cp_string_len);
479 /* LOCALE_RETURN_NUMBER flag would avoid strtoul conversion,
480 but is unavailable on Win95. */
481 c = GetLocaleInfoA (MAKELCID (langid, SORT_DEFAULT),
482 LOCALE_IDEFAULTCODEPAGE,
483 cp_string, max_cp_string_len);
484 /* If codepage data for an LCID is not installed on users's system,
485 GetLocaleInfo returns an empty string. Fall back to system ANSI
486 default. */
487 if (c == 0)
488 return CP_OEM;
489 return strtoul (cp_string, 0, 10);
492 static char *
493 lang_from_langid (unsigned short langid)
495 char cp_string[261];
496 int c;
498 memset (cp_string, 0, 261);
499 c = GetLocaleInfoA (MAKELCID (langid, SORT_DEFAULT),
500 LOCALE_SENGLANGUAGE,
501 cp_string, 260);
502 /* If codepage data for an LCID is not installed on users's system,
503 GetLocaleInfo returns an empty string. Fall back to system ANSI
504 default. */
505 if (c == 0)
506 strcpy (cp_string, "Neutral");
507 return xstrdup (cp_string);
510 static char *
511 country_from_langid (unsigned short langid)
513 char cp_string[261];
514 int c;
516 memset (cp_string, 0, 261);
517 c = GetLocaleInfoA (MAKELCID (langid, SORT_DEFAULT),
518 LOCALE_SENGCOUNTRY,
519 cp_string, 260);
520 /* If codepage data for an LCID is not installed on users's system,
521 GetLocaleInfo returns an empty string. Fall back to system ANSI
522 default. */
523 if (c == 0)
524 strcpy (cp_string, "Neutral");
525 return xstrdup (cp_string);
528 #endif
530 const wind_language_t *
531 wind_find_language_by_id (unsigned id)
533 #if !defined (_WIN32) && !defined (__CYGWIN__)
534 int i;
536 if (! id)
537 return NULL;
538 for (i = 0; languages[i].id != (unsigned) -1 && languages[i].id != id; i++)
540 if (languages[i].id == id)
541 return &languages[i];
542 return NULL;
543 #else
544 static wind_language_t wl;
546 wl.id = id;
547 wl.doscp = codepage_from_langid ((unsigned short) id);
548 wl.wincp = wincodepage_from_langid ((unsigned short) id);
549 wl.name = lang_from_langid ((unsigned short) id);
550 wl.country = country_from_langid ((unsigned short) id);
552 return & wl;
553 #endif
556 const local_iconv_map *
557 wind_find_codepage_info (unsigned cp)
559 #if !defined (_WIN32) && !defined (__CYGWIN__)
560 int i;
562 for (i = 0; codepages[i].codepage != (rc_uint_type) -1 && codepages[i].codepage != cp; i++)
564 if (codepages[i].codepage == (rc_uint_type) -1)
565 return NULL;
566 return &codepages[i];
567 #else
568 static local_iconv_map lim;
569 if (!unicode_is_valid_codepage (cp))
570 return NULL;
571 lim.codepage = cp;
572 lim.iconv_name = "";
573 return & lim;
574 #endif
577 /* Convert an Codepage string to a unicode string. */
579 void
580 unicode_from_codepage (rc_uint_type *length, unichar **u, const char *src, rc_uint_type cp)
582 rc_uint_type len;
584 len = wind_MultiByteToWideChar (cp, src, NULL, 0);
585 if (len)
587 *u = ((unichar *) res_alloc (len));
588 wind_MultiByteToWideChar (cp, src, *u, len);
590 /* Discount the trailing '/0'. If MultiByteToWideChar failed,
591 this will set *length to -1. */
592 len -= sizeof (unichar);
594 if (length != NULL)
595 *length = len / sizeof (unichar);
598 /* Convert an unicode string to an codepage string. */
600 void
601 codepage_from_unicode (rc_uint_type *length, const unichar *unicode, char **ascii, rc_uint_type cp)
603 rc_uint_type len;
605 len = wind_WideCharToMultiByte (cp, unicode, NULL, 0);
606 if (len)
608 *ascii = (char *) res_alloc (len * sizeof (char));
609 wind_WideCharToMultiByte (cp, unicode, *ascii, len);
611 /* Discount the trailing '/0'. If MultiByteToWideChar failed,
612 this will set *length to -1. */
613 len--;
615 if (length != NULL)
616 *length = len;
619 #ifdef HAVE_ICONV_H
620 static int
621 iconv_onechar (iconv_t cd, const char *s, char *d, int d_len, const char **n_s, char **n_d)
623 int i;
625 for (i = 1; i <= 32; i++)
627 char *tmp_d = d;
628 const char *tmp_s = s;
629 size_t ret;
630 size_t s_left = (size_t) i;
631 size_t d_left = (size_t) d_len;
633 ret = iconv (cd, & tmp_s, & s_left, & tmp_d, & d_left);
635 if (ret != (size_t) -1)
637 *n_s = tmp_s;
638 *n_d = tmp_d;
639 return 0;
643 return 1;
646 static const char *
647 wind_iconv_cp (rc_uint_type cp)
649 const local_iconv_map *lim = wind_find_codepage_info (cp);
651 if (!lim)
652 return NULL;
653 return lim->iconv_name;
655 #endif /* HAVE_ICONV_H */
657 static rc_uint_type
658 wind_MultiByteToWideChar (rc_uint_type cp, const char *mb,
659 unichar *u, rc_uint_type u_len)
661 rc_uint_type ret = 0;
663 #if defined (_WIN32) || defined (__CYGWIN__)
664 ret = (rc_uint_type) MultiByteToWideChar (cp, MB_PRECOMPOSED,
665 mb, -1, u, u_len);
666 /* Convert to bytes. */
667 ret *= sizeof (unichar);
669 #elif defined (HAVE_ICONV_H)
670 int first = 1;
671 char tmp[32];
672 char *p_tmp;
673 const char *iconv_name = wind_iconv_cp (cp);
675 if (!mb || !iconv_name)
676 return 0;
677 iconv_t cd = iconv_open ("UTF-16", iconv_name);
679 while (1)
681 int iret;
682 const char *n_mb;
683 char *n_tmp;
685 p_tmp = tmp;
686 iret = iconv_onechar (cd, (const char *) mb, p_tmp, 32, & n_mb, & n_tmp);
687 if (first)
689 first = 0;
690 continue;
692 if (!iret)
694 size_t l_tmp = (size_t) (n_tmp - p_tmp);
696 if (u)
698 if ((size_t) u_len < l_tmp)
699 break;
700 memcpy (u, tmp, l_tmp);
701 u += l_tmp/2;
702 u_len -= l_tmp;
704 ret += l_tmp;
706 else
707 break;
708 if (tmp[0] == 0 && tmp[1] == 0)
709 break;
710 mb = n_mb;
712 iconv_close (cd);
713 #else
714 if (cp)
715 ret = 0;
716 ret = strlen (mb) + 1;
717 ret *= sizeof (unichar);
718 if (u != NULL && u_len != 0)
722 *u++ = ((unichar) *mb) & 0xff;
723 --u_len; mb++;
725 while (u_len != 0 && mb[-1] != 0);
727 if (u != NULL && u_len != 0)
728 *u = 0;
729 #endif
730 return ret;
733 static rc_uint_type
734 wind_WideCharToMultiByte (rc_uint_type cp, const unichar *u, char *mb, rc_uint_type mb_len)
736 rc_uint_type ret = 0;
737 #if defined (_WIN32) || defined (__CYGWIN__)
738 WINBOOL used_def = FALSE;
740 ret = (rc_uint_type) WideCharToMultiByte (cp, 0, u, -1, mb, mb_len,
741 NULL, & used_def);
742 #elif defined (HAVE_ICONV_H)
743 int first = 1;
744 char tmp[32];
745 char *p_tmp;
746 const char *iconv_name = wind_iconv_cp (cp);
748 if (!u || !iconv_name)
749 return 0;
750 iconv_t cd = iconv_open (iconv_name, "UTF-16");
752 while (1)
754 int iret;
755 const char *n_u;
756 char *n_tmp;
758 p_tmp = tmp;
759 iret = iconv_onechar (cd, (const char *) u, p_tmp, 32, &n_u, & n_tmp);
760 if (first)
762 first = 0;
763 continue;
765 if (!iret)
767 size_t l_tmp = (size_t) (n_tmp - p_tmp);
769 if (mb)
771 if ((size_t) mb_len < l_tmp)
772 break;
773 memcpy (mb, tmp, l_tmp);
774 mb += l_tmp;
775 mb_len -= l_tmp;
777 ret += l_tmp;
779 else
780 break;
781 if (u[0] == 0)
782 break;
783 u = (const unichar *) n_u;
785 iconv_close (cd);
786 #else
787 if (cp)
788 ret = 0;
790 while (u[ret] != 0)
791 ++ret;
793 ++ret;
795 if (mb)
797 while (*u != 0 && mb_len != 0)
799 if (u[0] == (u[0] & 0x7f))
800 *mb++ = (char) u[0];
801 else
802 *mb++ = '_';
803 ++u; --mb_len;
805 if (mb_len != 0)
806 *mb = 0;
808 #endif
809 return ret;