2 * iconv library implemented with Win32 API.
\r
4 * This file is placed in the public domain.
\r
6 * Maintainer: Yukihiro Nakadaira <yukihiro.nakadaira@gmail.com>
\r
8 * If $WINICONV_LIBICONV_DLL environment variable was defined, win_iconv
\r
9 * loads the specified DLL dynamically and uses it. If loading the DLL
\r
10 * or iconv_open() failed, falls back to internal conversion.
\r
11 * $WINICONV_LIBICONV_DLL is a comma separated list. The first loadable
\r
12 * DLL is used. The specified DLL should have iconv_open(),
\r
13 * iconv_close() and iconv() functions. Or these functions can be
\r
14 * libiconv_open(), libiconv_close() and libiconv().
\r
16 * Win32 API does not support strict encoding conversion for some
\r
17 * codepage. And MLang function drop or replace invalid bytes and does
\r
18 * not return useful error status as iconv. This implementation cannot
\r
19 * be used for encoding validation purpose.
\r
22 /* for WC_NO_BEST_FIT_CHARS */
\r
24 # define WINVER 0x0500
\r
28 #include <windows.h>
\r
36 # define USE_LIBICONV_DLL
\r
39 #if !defined(DEFAULT_LIBICONV_DLL)
\r
40 # define DEFAULT_LIBICONV_DLL ""
\r
43 #define MB_CHAR_MAX 16
\r
45 #define UNICODE_MODE_BOM_DONE 1
\r
46 #define UNICODE_MODE_SWAPPED 2
\r
48 #define FLAG_USE_BOM_ENDIAN 1
\r
49 #define FLAG_TRANSLIT 2 /* //TRANSLIT */
\r
50 #define FLAG_IGNORE 4 /* //IGNORE (not implemented) */
\r
52 #define return_error(code) \
\r
58 #define xstrlcpy(dst, src, size) \
\r
60 strncpy(dst, src, size); \
\r
61 dst[size - 1] = 0; \
\r
64 #define xstrlcpyn(dst, src, srclen, size) \
\r
65 xstrlcpy(dst, src, xmin((srclen) + 1, size))
\r
67 #define xmin(a, b) ((a) < (b) ? (a) : (b))
\r
68 #define xmax(a, b) ((a) > (b) ? (a) : (b))
\r
70 #define STATIC_STRLEN(arr) (sizeof(arr) - 1)
\r
72 typedef unsigned char uchar;
\r
73 typedef unsigned short ushort;
\r
74 typedef unsigned int uint;
\r
76 typedef void* iconv_t;
\r
78 iconv_t iconv_open(const char *tocode, const char *fromcode);
\r
79 int iconv_close(iconv_t cd);
\r
80 size_t iconv(iconv_t cd, const char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);
\r
82 /* libiconv interface for vim */
\r
83 #if defined(MAKE_DLL)
\r
85 iconvctl (iconv_t cd, int request, void* argument)
\r
92 typedef struct compat_t compat_t;
\r
93 typedef struct csconv_t csconv_t;
\r
94 typedef struct rec_iconv_t rec_iconv_t;
\r
96 typedef iconv_t (*f_iconv_open)(const char *tocode, const char *fromcode);
\r
97 typedef int (*f_iconv_close)(iconv_t cd);
\r
98 typedef size_t (*f_iconv)(iconv_t cd, const char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);
\r
99 typedef int* (*f_errno)(void);
\r
100 typedef int (*f_mbtowc)(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
\r
101 typedef int (*f_wctomb)(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
\r
102 typedef int (*f_mblen)(csconv_t *cv, const uchar *buf, int bufsize);
\r
103 typedef int (*f_flush)(csconv_t *cv, uchar *buf, int bufsize);
\r
105 #define COMPAT_IN 1
\r
106 #define COMPAT_OUT 2
\r
108 /* unicode mapping for compatibility with other conversion table. */
\r
126 struct rec_iconv_t {
\r
128 f_iconv_close iconv_close;
\r
133 #if defined(USE_LIBICONV_DLL)
\r
138 static int win_iconv_open(rec_iconv_t *cd, const char *tocode, const char *fromcode);
\r
139 static int win_iconv_close(iconv_t cd);
\r
140 static size_t win_iconv(iconv_t cd, const char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);
\r
142 static int load_mlang();
\r
143 static csconv_t make_csconv(const char *name);
\r
144 static int name_to_codepage(const char *name);
\r
145 static uint utf16_to_ucs4(const ushort *wbuf);
\r
146 static void ucs4_to_utf16(uint wc, ushort *wbuf, int *wbufsize);
\r
147 static int is_unicode(int codepage);
\r
148 static int mbtowc_flags(int codepage);
\r
149 static int must_use_null_useddefaultchar(int codepage);
\r
150 static void check_utf_bom(rec_iconv_t *cd, ushort *wbuf, int *wbufsize);
\r
151 static char *strrstr(const char *str, const char *token);
\r
153 #if defined(USE_LIBICONV_DLL)
\r
154 static int libiconv_iconv_open(rec_iconv_t *cd, const char *tocode, const char *fromcode);
\r
155 static PVOID MyImageDirectoryEntryToData(LPVOID Base, BOOLEAN MappedAsImage, USHORT DirectoryEntry, PULONG Size);
\r
156 static HMODULE find_imported_module_by_funcname(HMODULE hModule, const char *funcname);
\r
158 static HMODULE hwiniconv;
\r
159 static HMODULE hlastdll; /* keep dll loaded for efficiency (unnecessary?) */
\r
162 static int sbcs_mblen(csconv_t *cv, const uchar *buf, int bufsize);
\r
163 static int dbcs_mblen(csconv_t *cv, const uchar *buf, int bufsize);
\r
164 static int mbcs_mblen(csconv_t *cv, const uchar *buf, int bufsize);
\r
165 static int utf8_mblen(csconv_t *cv, const uchar *buf, int bufsize);
\r
166 static int eucjp_mblen(csconv_t *cv, const uchar *buf, int bufsize);
\r
168 static int kernel_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
\r
169 static int kernel_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
\r
170 static int mlang_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
\r
171 static int mlang_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
\r
172 static int utf16_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
\r
173 static int utf16_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
\r
174 static int utf32_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
\r
175 static int utf32_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
\r
176 static int iso2022jp_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
\r
177 static int iso2022jp_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
\r
178 static int iso2022jp_flush(csconv_t *cv, uchar *buf, int bufsize);
\r
183 } codepage_alias[] = {
\r
184 {65001, "CP65001"},
\r
190 {1200, "UTF-16LE"},
\r
195 {1201, "UTF-16BE"},
\r
197 {1201, "unicodeFFFE"},
\r
199 {12000, "CP12000"},
\r
200 {12000, "UTF32LE"},
\r
201 {12000, "UTF-32LE"},
\r
203 {12001, "CP12001"},
\r
204 {12001, "UTF32BE"},
\r
205 {12001, "UTF-32BE"},
\r
207 #ifndef GLIB_COMPILATION
\r
209 * Default is big endian.
\r
210 * See rfc2781 4.3 Interpreting text labelled as UTF-16.
\r
217 /* Default is little endian, because the platform is */
\r
225 /* copy from libiconv `iconv -l` */
\r
226 /* !IsValidCodePage(367) */
\r
227 {20127, "ANSI_X3.4-1968"},
\r
228 {20127, "ANSI_X3.4-1986"},
\r
232 {20127, "ISO-IR-6"},
\r
233 {20127, "ISO646-US"},
\r
234 {20127, "ISO_646.IRV:1991"},
\r
236 {20127, "US-ASCII"},
\r
237 {20127, "CSASCII"},
\r
239 /* !IsValidCodePage(819) */
\r
242 {28591, "ISO-8859-1"},
\r
243 {28591, "ISO-IR-100"},
\r
244 {28591, "ISO8859-1"},
\r
245 {28591, "ISO_8859-1"},
\r
246 {28591, "ISO_8859-1:1987"},
\r
249 {28591, "CSISOLATIN1"},
\r
253 {1250, "WINDOWS-1250"},
\r
257 {1251, "WINDOWS-1251"},
\r
261 {1252, "WINDOWS-1252"},
\r
264 {1253, "MS-GREEK"},
\r
265 {1253, "WINDOWS-1253"},
\r
269 {1254, "WINDOWS-1254"},
\r
273 {1255, "WINDOWS-1255"},
\r
277 {1256, "WINDOWS-1256"},
\r
280 {1257, "WINBALTRIM"},
\r
281 {1257, "WINDOWS-1257"},
\r
284 {1258, "WINDOWS-1258"},
\r
289 {850, "CSPC850MULTILINGUAL"},
\r
291 /* !IsValidCodePage(862) */
\r
295 {862, "CSPC862LATINHEBREW"},
\r
302 /* !IsValidCodePage(154) */
\r
304 {154, "CYRILLIC-ASIAN"},
\r
307 {154, "CSPTCP154"},
\r
309 /* !IsValidCodePage(1133) */
\r
311 {1133, "IBM-CP1133"},
\r
314 {874, "WINDOWS-874"},
\r
316 /* !IsValidCodePage(51932) */
\r
317 {51932, "CP51932"},
\r
318 {51932, "MS51932"},
\r
319 {51932, "WINDOWS-51932"},
\r
324 {932, "SHIFFT_JIS"},
\r
325 {932, "SHIFFT_JIS-MS"},
\r
328 {932, "SJIS-OPEN"},
\r
330 {932, "WINDOWS-31J"},
\r
331 {932, "WINDOWS-932"},
\r
332 {932, "CSWINDOWS31J"},
\r
334 {50221, "CP50221"},
\r
335 {50221, "ISO-2022-JP"},
\r
336 {50221, "ISO-2022-JP-MS"},
\r
337 {50221, "ISO2022-JP"},
\r
338 {50221, "ISO2022-JP-MS"},
\r
339 {50221, "MS50221"},
\r
340 {50221, "WINDOWS-50221"},
\r
345 {936, "WINDOWS-936"},
\r
360 {437, "CSPC8CODEPAGE437"},
\r
366 {775, "CSPC775BALTIC"},
\r
373 /* !IsValidCodePage(853) */
\r
386 /* !IsValidCodePage(858) */
\r
420 /* !IsValidCodePage(1152) */
\r
424 * Code Page Identifiers
\r
425 * http://msdn2.microsoft.com/en-us/library/ms776446.aspx
\r
427 {37, "IBM037"}, /* IBM EBCDIC US-Canada */
\r
428 {437, "IBM437"}, /* OEM United States */
\r
429 {500, "IBM500"}, /* IBM EBCDIC International */
\r
430 {708, "ASMO-708"}, /* Arabic (ASMO 708) */
\r
431 /* 709 Arabic (ASMO-449+, BCON V4) */
\r
432 /* 710 Arabic - Transparent Arabic */
\r
433 {720, "DOS-720"}, /* Arabic (Transparent ASMO); Arabic (DOS) */
\r
434 {737, "ibm737"}, /* OEM Greek (formerly 437G); Greek (DOS) */
\r
435 {775, "ibm775"}, /* OEM Baltic; Baltic (DOS) */
\r
436 {850, "ibm850"}, /* OEM Multilingual Latin 1; Western European (DOS) */
\r
437 {852, "ibm852"}, /* OEM Latin 2; Central European (DOS) */
\r
438 {855, "IBM855"}, /* OEM Cyrillic (primarily Russian) */
\r
439 {857, "ibm857"}, /* OEM Turkish; Turkish (DOS) */
\r
440 {858, "IBM00858"}, /* OEM Multilingual Latin 1 + Euro symbol */
\r
441 {860, "IBM860"}, /* OEM Portuguese; Portuguese (DOS) */
\r
442 {861, "ibm861"}, /* OEM Icelandic; Icelandic (DOS) */
\r
443 {862, "DOS-862"}, /* OEM Hebrew; Hebrew (DOS) */
\r
444 {863, "IBM863"}, /* OEM French Canadian; French Canadian (DOS) */
\r
445 {864, "IBM864"}, /* OEM Arabic; Arabic (864) */
\r
446 {865, "IBM865"}, /* OEM Nordic; Nordic (DOS) */
\r
447 {866, "cp866"}, /* OEM Russian; Cyrillic (DOS) */
\r
448 {869, "ibm869"}, /* OEM Modern Greek; Greek, Modern (DOS) */
\r
449 {870, "IBM870"}, /* IBM EBCDIC Multilingual/ROECE (Latin 2); IBM EBCDIC Multilingual Latin 2 */
\r
450 {874, "windows-874"}, /* ANSI/OEM Thai (same as 28605, ISO 8859-15); Thai (Windows) */
\r
451 {875, "cp875"}, /* IBM EBCDIC Greek Modern */
\r
452 {932, "shift_jis"}, /* ANSI/OEM Japanese; Japanese (Shift-JIS) */
\r
453 {932, "shift-jis"}, /* alternative name for it */
\r
454 {936, "gb2312"}, /* ANSI/OEM Simplified Chinese (PRC, Singapore); Chinese Simplified (GB2312) */
\r
455 {949, "ks_c_5601-1987"}, /* ANSI/OEM Korean (Unified Hangul Code) */
\r
456 {950, "big5"}, /* ANSI/OEM Traditional Chinese (Taiwan; Hong Kong SAR, PRC); Chinese Traditional (Big5) */
\r
457 {1026, "IBM1026"}, /* IBM EBCDIC Turkish (Latin 5) */
\r
458 {1047, "IBM01047"}, /* IBM EBCDIC Latin 1/Open System */
\r
459 {1140, "IBM01140"}, /* IBM EBCDIC US-Canada (037 + Euro symbol); IBM EBCDIC (US-Canada-Euro) */
\r
460 {1141, "IBM01141"}, /* IBM EBCDIC Germany (20273 + Euro symbol); IBM EBCDIC (Germany-Euro) */
\r
461 {1142, "IBM01142"}, /* IBM EBCDIC Denmark-Norway (20277 + Euro symbol); IBM EBCDIC (Denmark-Norway-Euro) */
\r
462 {1143, "IBM01143"}, /* IBM EBCDIC Finland-Sweden (20278 + Euro symbol); IBM EBCDIC (Finland-Sweden-Euro) */
\r
463 {1144, "IBM01144"}, /* IBM EBCDIC Italy (20280 + Euro symbol); IBM EBCDIC (Italy-Euro) */
\r
464 {1145, "IBM01145"}, /* IBM EBCDIC Latin America-Spain (20284 + Euro symbol); IBM EBCDIC (Spain-Euro) */
\r
465 {1146, "IBM01146"}, /* IBM EBCDIC United Kingdom (20285 + Euro symbol); IBM EBCDIC (UK-Euro) */
\r
466 {1147, "IBM01147"}, /* IBM EBCDIC France (20297 + Euro symbol); IBM EBCDIC (France-Euro) */
\r
467 {1148, "IBM01148"}, /* IBM EBCDIC International (500 + Euro symbol); IBM EBCDIC (International-Euro) */
\r
468 {1149, "IBM01149"}, /* IBM EBCDIC Icelandic (20871 + Euro symbol); IBM EBCDIC (Icelandic-Euro) */
\r
469 {1250, "windows-1250"}, /* ANSI Central European; Central European (Windows) */
\r
470 {1251, "windows-1251"}, /* ANSI Cyrillic; Cyrillic (Windows) */
\r
471 {1252, "windows-1252"}, /* ANSI Latin 1; Western European (Windows) */
\r
472 {1253, "windows-1253"}, /* ANSI Greek; Greek (Windows) */
\r
473 {1254, "windows-1254"}, /* ANSI Turkish; Turkish (Windows) */
\r
474 {1255, "windows-1255"}, /* ANSI Hebrew; Hebrew (Windows) */
\r
475 {1256, "windows-1256"}, /* ANSI Arabic; Arabic (Windows) */
\r
476 {1257, "windows-1257"}, /* ANSI Baltic; Baltic (Windows) */
\r
477 {1258, "windows-1258"}, /* ANSI/OEM Vietnamese; Vietnamese (Windows) */
\r
478 {1361, "Johab"}, /* Korean (Johab) */
\r
479 {10000, "macintosh"}, /* MAC Roman; Western European (Mac) */
\r
480 {10001, "x-mac-japanese"}, /* Japanese (Mac) */
\r
481 {10002, "x-mac-chinesetrad"}, /* MAC Traditional Chinese (Big5); Chinese Traditional (Mac) */
\r
482 {10003, "x-mac-korean"}, /* Korean (Mac) */
\r
483 {10004, "x-mac-arabic"}, /* Arabic (Mac) */
\r
484 {10005, "x-mac-hebrew"}, /* Hebrew (Mac) */
\r
485 {10006, "x-mac-greek"}, /* Greek (Mac) */
\r
486 {10007, "x-mac-cyrillic"}, /* Cyrillic (Mac) */
\r
487 {10008, "x-mac-chinesesimp"}, /* MAC Simplified Chinese (GB 2312); Chinese Simplified (Mac) */
\r
488 {10010, "x-mac-romanian"}, /* Romanian (Mac) */
\r
489 {10017, "x-mac-ukrainian"}, /* Ukrainian (Mac) */
\r
490 {10021, "x-mac-thai"}, /* Thai (Mac) */
\r
491 {10029, "x-mac-ce"}, /* MAC Latin 2; Central European (Mac) */
\r
492 {10079, "x-mac-icelandic"}, /* Icelandic (Mac) */
\r
493 {10081, "x-mac-turkish"}, /* Turkish (Mac) */
\r
494 {10082, "x-mac-croatian"}, /* Croatian (Mac) */
\r
495 {20000, "x-Chinese_CNS"}, /* CNS Taiwan; Chinese Traditional (CNS) */
\r
496 {20001, "x-cp20001"}, /* TCA Taiwan */
\r
497 {20002, "x_Chinese-Eten"}, /* Eten Taiwan; Chinese Traditional (Eten) */
\r
498 {20003, "x-cp20003"}, /* IBM5550 Taiwan */
\r
499 {20004, "x-cp20004"}, /* TeleText Taiwan */
\r
500 {20005, "x-cp20005"}, /* Wang Taiwan */
\r
501 {20105, "x-IA5"}, /* IA5 (IRV International Alphabet No. 5, 7-bit); Western European (IA5) */
\r
502 {20106, "x-IA5-German"}, /* IA5 German (7-bit) */
\r
503 {20107, "x-IA5-Swedish"}, /* IA5 Swedish (7-bit) */
\r
504 {20108, "x-IA5-Norwegian"}, /* IA5 Norwegian (7-bit) */
\r
505 {20127, "us-ascii"}, /* US-ASCII (7-bit) */
\r
506 {20261, "x-cp20261"}, /* T.61 */
\r
507 {20269, "x-cp20269"}, /* ISO 6937 Non-Spacing Accent */
\r
508 {20273, "IBM273"}, /* IBM EBCDIC Germany */
\r
509 {20277, "IBM277"}, /* IBM EBCDIC Denmark-Norway */
\r
510 {20278, "IBM278"}, /* IBM EBCDIC Finland-Sweden */
\r
511 {20280, "IBM280"}, /* IBM EBCDIC Italy */
\r
512 {20284, "IBM284"}, /* IBM EBCDIC Latin America-Spain */
\r
513 {20285, "IBM285"}, /* IBM EBCDIC United Kingdom */
\r
514 {20290, "IBM290"}, /* IBM EBCDIC Japanese Katakana Extended */
\r
515 {20297, "IBM297"}, /* IBM EBCDIC France */
\r
516 {20420, "IBM420"}, /* IBM EBCDIC Arabic */
\r
517 {20423, "IBM423"}, /* IBM EBCDIC Greek */
\r
518 {20424, "IBM424"}, /* IBM EBCDIC Hebrew */
\r
519 {20833, "x-EBCDIC-KoreanExtended"}, /* IBM EBCDIC Korean Extended */
\r
520 {20838, "IBM-Thai"}, /* IBM EBCDIC Thai */
\r
521 {20866, "koi8-r"}, /* Russian (KOI8-R); Cyrillic (KOI8-R) */
\r
522 {20871, "IBM871"}, /* IBM EBCDIC Icelandic */
\r
523 {20880, "IBM880"}, /* IBM EBCDIC Cyrillic Russian */
\r
524 {20905, "IBM905"}, /* IBM EBCDIC Turkish */
\r
525 {20924, "IBM00924"}, /* IBM EBCDIC Latin 1/Open System (1047 + Euro symbol) */
\r
526 {20932, "EUC-JP"}, /* Japanese (JIS 0208-1990 and 0121-1990) */
\r
527 {20936, "x-cp20936"}, /* Simplified Chinese (GB2312); Chinese Simplified (GB2312-80) */
\r
528 {20949, "x-cp20949"}, /* Korean Wansung */
\r
529 {21025, "cp1025"}, /* IBM EBCDIC Cyrillic Serbian-Bulgarian */
\r
530 /* 21027 (deprecated) */
\r
531 {21866, "koi8-u"}, /* Ukrainian (KOI8-U); Cyrillic (KOI8-U) */
\r
532 {28591, "iso-8859-1"}, /* ISO 8859-1 Latin 1; Western European (ISO) */
\r
533 {28591, "iso8859-1"}, /* ISO 8859-1 Latin 1; Western European (ISO) */
\r
534 {28592, "iso-8859-2"}, /* ISO 8859-2 Central European; Central European (ISO) */
\r
535 {28592, "iso8859-2"}, /* ISO 8859-2 Central European; Central European (ISO) */
\r
536 {28593, "iso-8859-3"}, /* ISO 8859-3 Latin 3 */
\r
537 {28593, "iso8859-3"}, /* ISO 8859-3 Latin 3 */
\r
538 {28594, "iso-8859-4"}, /* ISO 8859-4 Baltic */
\r
539 {28594, "iso8859-4"}, /* ISO 8859-4 Baltic */
\r
540 {28595, "iso-8859-5"}, /* ISO 8859-5 Cyrillic */
\r
541 {28595, "iso8859-5"}, /* ISO 8859-5 Cyrillic */
\r
542 {28596, "iso-8859-6"}, /* ISO 8859-6 Arabic */
\r
543 {28596, "iso8859-6"}, /* ISO 8859-6 Arabic */
\r
544 {28597, "iso-8859-7"}, /* ISO 8859-7 Greek */
\r
545 {28597, "iso8859-7"}, /* ISO 8859-7 Greek */
\r
546 {28598, "iso-8859-8"}, /* ISO 8859-8 Hebrew; Hebrew (ISO-Visual) */
\r
547 {28598, "iso8859-8"}, /* ISO 8859-8 Hebrew; Hebrew (ISO-Visual) */
\r
548 {28599, "iso-8859-9"}, /* ISO 8859-9 Turkish */
\r
549 {28599, "iso8859-9"}, /* ISO 8859-9 Turkish */
\r
550 {28603, "iso-8859-13"}, /* ISO 8859-13 Estonian */
\r
551 {28603, "iso8859-13"}, /* ISO 8859-13 Estonian */
\r
552 {28605, "iso-8859-15"}, /* ISO 8859-15 Latin 9 */
\r
553 {28605, "iso8859-15"}, /* ISO 8859-15 Latin 9 */
\r
554 {29001, "x-Europa"}, /* Europa 3 */
\r
555 {38598, "iso-8859-8-i"}, /* ISO 8859-8 Hebrew; Hebrew (ISO-Logical) */
\r
556 {38598, "iso8859-8-i"}, /* ISO 8859-8 Hebrew; Hebrew (ISO-Logical) */
\r
557 {50220, "iso-2022-jp"}, /* ISO 2022 Japanese with no halfwidth Katakana; Japanese (JIS) */
\r
558 {50221, "csISO2022JP"}, /* ISO 2022 Japanese with halfwidth Katakana; Japanese (JIS-Allow 1 byte Kana) */
\r
559 {50222, "iso-2022-jp"}, /* ISO 2022 Japanese JIS X 0201-1989; Japanese (JIS-Allow 1 byte Kana - SO/SI) */
\r
560 {50225, "iso-2022-kr"}, /* ISO 2022 Korean */
\r
561 {50225, "iso2022-kr"}, /* ISO 2022 Korean */
\r
562 {50227, "x-cp50227"}, /* ISO 2022 Simplified Chinese; Chinese Simplified (ISO 2022) */
\r
563 /* 50229 ISO 2022 Traditional Chinese */
\r
564 /* 50930 EBCDIC Japanese (Katakana) Extended */
\r
565 /* 50931 EBCDIC US-Canada and Japanese */
\r
566 /* 50933 EBCDIC Korean Extended and Korean */
\r
567 /* 50935 EBCDIC Simplified Chinese Extended and Simplified Chinese */
\r
568 /* 50936 EBCDIC Simplified Chinese */
\r
569 /* 50937 EBCDIC US-Canada and Traditional Chinese */
\r
570 /* 50939 EBCDIC Japanese (Latin) Extended and Japanese */
\r
571 {51932, "euc-jp"}, /* EUC Japanese */
\r
572 {51936, "EUC-CN"}, /* EUC Simplified Chinese; Chinese Simplified (EUC) */
\r
573 {51949, "euc-kr"}, /* EUC Korean */
\r
574 /* 51950 EUC Traditional Chinese */
\r
575 {52936, "hz-gb-2312"}, /* HZ-GB2312 Simplified Chinese; Chinese Simplified (HZ) */
\r
576 {54936, "GB18030"}, /* Windows XP and later: GB18030 Simplified Chinese (4 byte); Chinese Simplified (GB18030) */
\r
577 {57002, "x-iscii-de"}, /* ISCII Devanagari */
\r
578 {57003, "x-iscii-be"}, /* ISCII Bengali */
\r
579 {57004, "x-iscii-ta"}, /* ISCII Tamil */
\r
580 {57005, "x-iscii-te"}, /* ISCII Telugu */
\r
581 {57006, "x-iscii-as"}, /* ISCII Assamese */
\r
582 {57007, "x-iscii-or"}, /* ISCII Oriya */
\r
583 {57008, "x-iscii-ka"}, /* ISCII Kannada */
\r
584 {57009, "x-iscii-ma"}, /* ISCII Malayalam */
\r
585 {57010, "x-iscii-gu"}, /* ISCII Gujarati */
\r
586 {57011, "x-iscii-pa"}, /* ISCII Punjabi */
\r
592 * SJIS SHIFTJIS table CP932 table
\r
593 * ---- --------------------------- --------------------------------
\r
594 * 5C U+00A5 YEN SIGN U+005C REVERSE SOLIDUS
\r
595 * 7E U+203E OVERLINE U+007E TILDE
\r
596 * 815C U+2014 EM DASH U+2015 HORIZONTAL BAR
\r
597 * 815F U+005C REVERSE SOLIDUS U+FF3C FULLWIDTH REVERSE SOLIDUS
\r
598 * 8160 U+301C WAVE DASH U+FF5E FULLWIDTH TILDE
\r
599 * 8161 U+2016 DOUBLE VERTICAL LINE U+2225 PARALLEL TO
\r
600 * 817C U+2212 MINUS SIGN U+FF0D FULLWIDTH HYPHEN-MINUS
\r
601 * 8191 U+00A2 CENT SIGN U+FFE0 FULLWIDTH CENT SIGN
\r
602 * 8192 U+00A3 POUND SIGN U+FFE1 FULLWIDTH POUND SIGN
\r
603 * 81CA U+00AC NOT SIGN U+FFE2 FULLWIDTH NOT SIGN
\r
605 * EUC-JP and ISO-2022-JP should be compatible with CP932.
\r
607 * Kernel and MLang have different Unicode mapping table. Make sure
\r
608 * which API is used.
\r
610 static compat_t cp932_compat[] = {
\r
611 {0x00A5, 0x005C, COMPAT_OUT},
\r
612 {0x203E, 0x007E, COMPAT_OUT},
\r
613 {0x2014, 0x2015, COMPAT_OUT},
\r
614 {0x301C, 0xFF5E, COMPAT_OUT},
\r
615 {0x2016, 0x2225, COMPAT_OUT},
\r
616 {0x2212, 0xFF0D, COMPAT_OUT},
\r
617 {0x00A2, 0xFFE0, COMPAT_OUT},
\r
618 {0x00A3, 0xFFE1, COMPAT_OUT},
\r
619 {0x00AC, 0xFFE2, COMPAT_OUT},
\r
623 static compat_t cp20932_compat[] = {
\r
624 {0x00A5, 0x005C, COMPAT_OUT},
\r
625 {0x203E, 0x007E, COMPAT_OUT},
\r
626 {0x2014, 0x2015, COMPAT_OUT},
\r
627 {0xFF5E, 0x301C, COMPAT_OUT|COMPAT_IN},
\r
628 {0x2225, 0x2016, COMPAT_OUT|COMPAT_IN},
\r
629 {0xFF0D, 0x2212, COMPAT_OUT|COMPAT_IN},
\r
630 {0xFFE0, 0x00A2, COMPAT_OUT|COMPAT_IN},
\r
631 {0xFFE1, 0x00A3, COMPAT_OUT|COMPAT_IN},
\r
632 {0xFFE2, 0x00AC, COMPAT_OUT|COMPAT_IN},
\r
636 static compat_t *cp51932_compat = cp932_compat;
\r
638 /* cp20932_compat for kernel. cp932_compat for mlang. */
\r
639 static compat_t *cp5022x_compat = cp932_compat;
\r
641 typedef HRESULT (WINAPI *CONVERTINETSTRING)(
\r
643 DWORD dwSrcEncoding,
\r
644 DWORD dwDstEncoding,
\r
650 typedef HRESULT (WINAPI *CONVERTINETMULTIBYTETOUNICODE)(
\r
652 DWORD dwSrcEncoding,
\r
654 LPINT lpnMultiCharCount,
\r
656 LPINT lpnWideCharCount
\r
658 typedef HRESULT (WINAPI *CONVERTINETUNICODETOMULTIBYTE)(
\r
662 LPINT lpnWideCharCount,
\r
664 LPINT lpnMultiCharCount
\r
666 typedef HRESULT (WINAPI *ISCONVERTINETSTRINGAVAILABLE)(
\r
667 DWORD dwSrcEncoding,
\r
668 DWORD dwDstEncoding
\r
670 typedef HRESULT (WINAPI *LCIDTORFC1766A)(
\r
675 typedef HRESULT (WINAPI *LCIDTORFC1766W)(
\r
680 typedef HRESULT (WINAPI *RFC1766TOLCIDA)(
\r
684 typedef HRESULT (WINAPI *RFC1766TOLCIDW)(
\r
688 static CONVERTINETSTRING ConvertINetString;
\r
689 static CONVERTINETMULTIBYTETOUNICODE ConvertINetMultiByteToUnicode;
\r
690 static CONVERTINETUNICODETOMULTIBYTE ConvertINetUnicodeToMultiByte;
\r
691 static ISCONVERTINETSTRINGAVAILABLE IsConvertINetStringAvailable;
\r
692 static LCIDTORFC1766A LcidToRfc1766A;
\r
693 static RFC1766TOLCIDA Rfc1766ToLcidA;
\r
699 if (ConvertINetString != NULL)
\r
701 h = LoadLibrary("mlang.dll");
\r
704 ConvertINetString = (CONVERTINETSTRING)GetProcAddress(h, "ConvertINetString");
\r
705 ConvertINetMultiByteToUnicode = (CONVERTINETMULTIBYTETOUNICODE)GetProcAddress(h, "ConvertINetMultiByteToUnicode");
\r
706 ConvertINetUnicodeToMultiByte = (CONVERTINETUNICODETOMULTIBYTE)GetProcAddress(h, "ConvertINetUnicodeToMultiByte");
\r
707 IsConvertINetStringAvailable = (ISCONVERTINETSTRINGAVAILABLE)GetProcAddress(h, "IsConvertINetStringAvailable");
\r
708 LcidToRfc1766A = (LCIDTORFC1766A)GetProcAddress(h, "LcidToRfc1766A");
\r
709 Rfc1766ToLcidA = (RFC1766TOLCIDA)GetProcAddress(h, "Rfc1766ToLcidA");
\r
714 iconv_open(const char *tocode, const char *fromcode)
\r
718 cd = (rec_iconv_t *)calloc(1, sizeof(rec_iconv_t));
\r
722 return (iconv_t)(-1);
\r
725 #if defined(USE_LIBICONV_DLL)
\r
726 if (libiconv_iconv_open(cd, tocode, fromcode))
\r
727 return (iconv_t)cd;
\r
730 if (win_iconv_open(cd, tocode, fromcode))
\r
731 return (iconv_t)cd;
\r
735 return (iconv_t)(-1);
\r
739 iconv_close(iconv_t _cd)
\r
741 rec_iconv_t *cd = (rec_iconv_t *)_cd;
\r
742 int r = cd->iconv_close(cd->cd);
\r
743 int e = *(cd->_errno());
\r
744 #if defined(USE_LIBICONV_DLL)
\r
745 if (cd->hlibiconv != NULL)
\r
746 FreeLibrary(cd->hlibiconv);
\r
754 iconv(iconv_t _cd, const char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft)
\r
756 rec_iconv_t *cd = (rec_iconv_t *)_cd;
\r
757 size_t r = cd->iconv(cd->cd, inbuf, inbytesleft, outbuf, outbytesleft);
\r
758 errno = *(cd->_errno());
\r
763 win_iconv_open(rec_iconv_t *cd, const char *tocode, const char *fromcode)
\r
765 cd->from = make_csconv(fromcode);
\r
766 cd->to = make_csconv(tocode);
\r
767 if (cd->from.codepage == -1 || cd->to.codepage == -1)
\r
769 cd->iconv_close = win_iconv_close;
\r
770 cd->iconv = win_iconv;
\r
771 cd->_errno = _errno;
\r
772 cd->cd = (iconv_t)cd;
\r
777 win_iconv_close(iconv_t cd)
\r
783 win_iconv(iconv_t _cd, const char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft)
\r
785 rec_iconv_t *cd = (rec_iconv_t *)_cd;
\r
786 ushort wbuf[MB_CHAR_MAX]; /* enough room for one character */
\r
795 if (inbuf == NULL || *inbuf == NULL)
\r
797 if (outbuf != NULL && *outbuf != NULL && cd->to.flush != NULL)
\r
799 outsize = cd->to.flush(&cd->to, (uchar *)*outbuf, *outbytesleft);
\r
801 return (size_t)(-1);
\r
802 *outbuf += outsize;
\r
803 *outbytesleft -= outsize;
\r
805 if (is_unicode(cd->from.codepage) && (cd->from.mode & UNICODE_MODE_SWAPPED))
\r
806 cd->from.codepage ^= 1;
\r
812 while (*inbytesleft != 0)
\r
814 mode = cd->from.mode;
\r
815 wsize = MB_CHAR_MAX;
\r
817 insize = cd->from.mbtowc(&cd->from, (const uchar *)*inbuf, *inbytesleft, wbuf, &wsize);
\r
819 return (size_t)(-1);
\r
821 if (is_unicode(cd->from.codepage) && !(cd->from.mode & UNICODE_MODE_BOM_DONE))
\r
823 check_utf_bom(cd, wbuf, &wsize);
\r
824 cd->from.mode |= UNICODE_MODE_BOM_DONE;
\r
830 *inbytesleft -= insize;
\r
834 if (cd->from.compat != NULL)
\r
836 wc = utf16_to_ucs4(wbuf);
\r
837 cp = cd->from.compat;
\r
838 for (i = 0; cp[i].in != 0; ++i)
\r
840 if ((cp[i].flag & COMPAT_IN) && cp[i].out == wc)
\r
842 ucs4_to_utf16(cp[i].in, wbuf, &wsize);
\r
848 if (cd->to.compat != NULL)
\r
850 wc = utf16_to_ucs4(wbuf);
\r
851 cp = cd->to.compat;
\r
852 for (i = 0; cp[i].in != 0; ++i)
\r
854 if ((cp[i].flag & COMPAT_OUT) && cp[i].in == wc)
\r
856 ucs4_to_utf16(cp[i].out, wbuf, &wsize);
\r
862 outsize = cd->to.wctomb(&cd->to, wbuf, wsize, (uchar *)*outbuf, *outbytesleft);
\r
865 cd->from.mode = mode;
\r
866 return (size_t)(-1);
\r
870 *outbuf += outsize;
\r
871 *inbytesleft -= insize;
\r
872 *outbytesleft -= outsize;
\r
879 make_csconv(const char *_name)
\r
883 int use_compat = TRUE;
\r
888 xstrlcpy(name, _name, sizeof(name));
\r
890 /* check for option "enc_name//opt1//opt2" */
\r
891 while ((p = strrstr(name, "//")) != NULL)
\r
893 if (_stricmp(p + 2, "nocompat") == 0)
\r
894 use_compat = FALSE;
\r
895 else if (_stricmp(p + 2, "translit") == 0)
\r
896 flag |= FLAG_TRANSLIT;
\r
897 else if (_stricmp(p + 2, "ignore") == 0)
\r
898 flag |= FLAG_IGNORE;
\r
907 cv.codepage = name_to_codepage(name);
\r
908 if (cv.codepage == 1200 || cv.codepage == 1201)
\r
910 cv.mbtowc = utf16_mbtowc;
\r
911 cv.wctomb = utf16_wctomb;
\r
912 if (_stricmp(name, "UTF-16") == 0 ||
\r
913 _stricmp(name, "UTF16") == 0 ||
\r
914 _stricmp(name, "UCS-2") == 0)
\r
915 cv.flags |= FLAG_USE_BOM_ENDIAN;
\r
917 else if (cv.codepage == 12000 || cv.codepage == 12001)
\r
919 cv.mbtowc = utf32_mbtowc;
\r
920 cv.wctomb = utf32_wctomb;
\r
921 if (_stricmp(name, "UTF-32") == 0 || _stricmp(name, "UTF32") == 0)
\r
922 cv.flags |= FLAG_USE_BOM_ENDIAN;
\r
924 else if (cv.codepage == 65001)
\r
926 cv.mbtowc = kernel_mbtowc;
\r
927 cv.wctomb = kernel_wctomb;
\r
928 cv.mblen = utf8_mblen;
\r
930 else if ((cv.codepage == 50220 || cv.codepage == 50221 || cv.codepage == 50222) && load_mlang())
\r
932 cv.mbtowc = iso2022jp_mbtowc;
\r
933 cv.wctomb = iso2022jp_wctomb;
\r
934 cv.flush = iso2022jp_flush;
\r
936 else if (cv.codepage == 51932 && load_mlang())
\r
938 cv.mbtowc = mlang_mbtowc;
\r
939 cv.wctomb = mlang_wctomb;
\r
940 cv.mblen = eucjp_mblen;
\r
942 else if (IsValidCodePage(cv.codepage)
\r
943 && GetCPInfoEx(cv.codepage, 0, &cpinfoex) != 0)
\r
945 cv.mbtowc = kernel_mbtowc;
\r
946 cv.wctomb = kernel_wctomb;
\r
947 if (cpinfoex.MaxCharSize == 1)
\r
948 cv.mblen = sbcs_mblen;
\r
949 else if (cpinfoex.MaxCharSize == 2)
\r
950 cv.mblen = dbcs_mblen;
\r
952 cv.mblen = mbcs_mblen;
\r
956 /* not supported */
\r
961 switch (cv.codepage)
\r
963 case 932: cv.compat = cp932_compat; break;
\r
964 case 20932: cv.compat = cp20932_compat; break;
\r
965 case 51932: cv.compat = cp51932_compat; break;
\r
966 case 50220: case 50221: case 50222: cv.compat = cp5022x_compat; break;
\r
973 name_to_codepage(const char *name)
\r
977 if (*name == '\0' ||
\r
978 strcmp(name, "char") == 0)
\r
980 else if (strcmp(name, "wchar_t") == 0)
\r
982 else if (_strnicmp(name, "cp", 2) == 0)
\r
983 return atoi(name + 2); /* CP123 */
\r
984 else if ('0' <= name[0] && name[0] <= '9')
\r
985 return atoi(name); /* 123 */
\r
986 else if (_strnicmp(name, "xx", 2) == 0)
\r
987 return atoi(name + 2); /* XX123 for debug */
\r
989 for (i = 0; codepage_alias[i].name != NULL; ++i)
\r
990 if (_stricmp(name, codepage_alias[i].name) == 0)
\r
991 return codepage_alias[i].codepage;
\r
996 * http://www.faqs.org/rfcs/rfc2781.html
\r
999 utf16_to_ucs4(const ushort *wbuf)
\r
1001 uint wc = wbuf[0];
\r
1002 if (0xD800 <= wbuf[0] && wbuf[0] <= 0xDBFF)
\r
1003 wc = ((wbuf[0] & 0x3FF) << 10) + (wbuf[1] & 0x3FF) + 0x10000;
\r
1008 ucs4_to_utf16(uint wc, ushort *wbuf, int *wbufsize)
\r
1018 wbuf[0] = 0xD800 | ((wc >> 10) & 0x3FF);
\r
1019 wbuf[1] = 0xDC00 | (wc & 0x3FF);
\r
1025 is_unicode(int codepage)
\r
1027 return (codepage == 1200 || codepage == 1201 ||
\r
1028 codepage == 12000 || codepage == 12001 ||
\r
1029 codepage == 65000 || codepage == 65001);
\r
1033 * Check if codepage is one of those for which the dwFlags parameter
\r
1034 * to MultiByteToWideChar() must be zero. Return zero or
\r
1035 * MB_ERR_INVALID_CHARS. The docs in Platform SDK for for Windows
\r
1036 * Server 2003 R2 claims that also codepage 65001 is one of these, but
\r
1037 * that doesn't seem to be the case. The MSDN docs for MSVS2008 leave
\r
1038 * out 65001 (UTF-8), and that indeed seems to be the case on XP, it
\r
1039 * works fine to pass MB_ERR_INVALID_CHARS in dwFlags when converting
\r
1043 mbtowc_flags(int codepage)
\r
1045 return (codepage == 50220 || codepage == 50221 ||
\r
1046 codepage == 50222 || codepage == 50225 ||
\r
1047 codepage == 50227 || codepage == 50229 ||
\r
1048 codepage == 52936 || codepage == 54936 ||
\r
1049 (codepage >= 57002 && codepage <= 57011) ||
\r
1050 codepage == 65000 || codepage == 42) ? 0 : MB_ERR_INVALID_CHARS;
\r
1054 * Check if codepage is one those for which the lpUsedDefaultChar
\r
1055 * parameter to WideCharToMultiByte() must be NULL. The docs in
\r
1056 * Platform SDK for for Windows Server 2003 R2 claims that this is the
\r
1057 * list below, while the MSDN docs for MSVS2008 claim that it is only
\r
1058 * for 65000 (UTF-7) and 65001 (UTF-8). This time the earlier Platform
\r
1059 * SDK seems to be correct, at least for XP.
\r
1062 must_use_null_useddefaultchar(int codepage)
\r
1064 return (codepage == 65000 || codepage == 65001 ||
\r
1065 codepage == 50220 || codepage == 50221 ||
\r
1066 codepage == 50222 || codepage == 50225 ||
\r
1067 codepage == 50227 || codepage == 50229 ||
\r
1068 codepage == 52936 || codepage == 54936 ||
\r
1069 (codepage >= 57002 && codepage <= 57011) ||
\r
1074 check_utf_bom(rec_iconv_t *cd, ushort *wbuf, int *wbufsize)
\r
1076 /* If we have a BOM, trust it, despite what the caller said */
\r
1077 if (wbuf[0] == 0xFFFE && (cd->from.flags & FLAG_USE_BOM_ENDIAN))
\r
1079 /* swap endian: 1200 <-> 1201 or 12000 <-> 12001 */
\r
1080 cd->from.codepage ^= 1;
\r
1081 cd->from.mode |= UNICODE_MODE_SWAPPED;
\r
1087 * Don't do this if "to" is Unicode,
\r
1088 * except if "to" is UTF-8.
\r
1090 if (wbuf[0] == 0xFEFF && (!is_unicode(cd->to.codepage) || cd->to.codepage == 65001))
\r
1095 strrstr(const char *str, const char *token)
\r
1097 int len = strlen(token);
\r
1098 const char *p = str + strlen(str);
\r
1100 while (str <= --p)
\r
1101 if (p[0] == token[0] && strncmp(p, token, len) == 0)
\r
1106 #if defined(USE_LIBICONV_DLL)
\r
1108 libiconv_iconv_open(rec_iconv_t *cd, const char *fromcode, const char *tocode)
\r
1110 HMODULE hlibiconv = NULL;
\r
1111 HMODULE hmsvcrt = NULL;
\r
1112 char dllname[_MAX_PATH];
\r
1115 f_iconv_open _iconv_open;
\r
1118 * always try to load dll, so that we can switch dll in runtime.
\r
1121 /* XXX: getenv() can't get variable set by SetEnvironmentVariable() */
\r
1122 p = getenv("WINICONV_LIBICONV_DLL");
\r
1124 p = DEFAULT_LIBICONV_DLL;
\r
1125 /* parse comma separated value */
\r
1126 for ( ; *p != 0; p = (*e == ',') ? e + 1 : e)
\r
1128 e = strchr(p, ',');
\r
1131 else if (e == NULL)
\r
1132 e = p + strlen(p);
\r
1133 xstrlcpyn(dllname, p, e - p, sizeof(dllname));
\r
1134 hlibiconv = LoadLibrary(dllname);
\r
1135 if (hlibiconv != NULL)
\r
1137 if (hlibiconv == hwiniconv)
\r
1139 FreeLibrary(hlibiconv);
\r
1147 if (hlastdll != NULL)
\r
1149 /* decrement reference count */
\r
1150 FreeLibrary(hlastdll);
\r
1154 if (hlibiconv == NULL)
\r
1157 hmsvcrt = find_imported_module_by_funcname(hlibiconv, "_errno");
\r
1158 if (hmsvcrt == NULL)
\r
1161 _iconv_open = (f_iconv_open)GetProcAddress(hlibiconv, "libiconv_open");
\r
1162 if (_iconv_open == NULL)
\r
1163 _iconv_open = (f_iconv_open)GetProcAddress(hlibiconv, "iconv_open");
\r
1164 cd->iconv_close = (f_iconv_close)GetProcAddress(hlibiconv, "libiconv_close");
\r
1165 if (cd->iconv_close == NULL)
\r
1166 cd->iconv_close = (f_iconv_close)GetProcAddress(hlibiconv, "iconv_close");
\r
1167 cd->iconv = (f_iconv)GetProcAddress(hlibiconv, "libiconv");
\r
1168 if (cd->iconv == NULL)
\r
1169 cd->iconv = (f_iconv)GetProcAddress(hlibiconv, "iconv");
\r
1170 cd->_errno = (f_errno)GetProcAddress(hmsvcrt, "_errno");
\r
1171 if (_iconv_open == NULL || cd->iconv_close == NULL
\r
1172 || cd->iconv == NULL || cd->_errno == NULL)
\r
1175 /* increment reference count */
\r
1176 hlastdll = LoadLibrary(dllname);
\r
1178 cd->cd = _iconv_open(tocode, fromcode);
\r
1179 if (cd->cd == (iconv_t)(-1))
\r
1182 cd->hlibiconv = hlibiconv;
\r
1186 if (hlibiconv != NULL)
\r
1187 FreeLibrary(hlibiconv);
\r
1188 /* do not free hmsvcrt which is obtained by GetModuleHandle() */
\r
1194 * http://forums.belution.com/ja/vc/000/234/78s.shtml
\r
1195 * http://nienie.com/~masapico/api_ImageDirectoryEntryToData.html
\r
1197 * The formal way is
\r
1198 * imagehlp.h or dbghelp.h
\r
1199 * imagehlp.lib or dbghelp.lib
\r
1200 * ImageDirectoryEntryToData()
\r
1202 #define TO_DOS_HEADER(base) ((PIMAGE_DOS_HEADER)(base))
\r
1203 #define TO_NT_HEADERS(base) ((PIMAGE_NT_HEADERS)((LPBYTE)(base) + TO_DOS_HEADER(base)->e_lfanew))
\r
1205 MyImageDirectoryEntryToData(LPVOID Base, BOOLEAN MappedAsImage, USHORT DirectoryEntry, PULONG Size)
\r
1207 /* TODO: MappedAsImage? */
\r
1208 PIMAGE_DATA_DIRECTORY p;
\r
1209 p = TO_NT_HEADERS(Base)->OptionalHeader.DataDirectory + DirectoryEntry;
\r
1210 if (p->VirtualAddress == 0) {
\r
1215 return (PVOID)((LPBYTE)Base + p->VirtualAddress);
\r
1219 find_imported_module_by_funcname(HMODULE hModule, const char *funcname)
\r
1223 PIMAGE_IMPORT_DESCRIPTOR Imp;
\r
1224 PIMAGE_THUNK_DATA Name; /* Import Name Table */
\r
1225 PIMAGE_IMPORT_BY_NAME ImpName;
\r
1227 Base = (DWORD)hModule;
\r
1228 Imp = MyImageDirectoryEntryToData(
\r
1231 IMAGE_DIRECTORY_ENTRY_IMPORT,
\r
1235 for ( ; Imp->OriginalFirstThunk != 0; ++Imp)
\r
1237 Name = (PIMAGE_THUNK_DATA)(Base + Imp->OriginalFirstThunk);
\r
1238 for ( ; Name->u1.Ordinal != 0; ++Name)
\r
1240 if (!IMAGE_SNAP_BY_ORDINAL(Name->u1.Ordinal))
\r
1242 ImpName = (PIMAGE_IMPORT_BY_NAME)
\r
1243 (Base + (DWORD)Name->u1.AddressOfData);
\r
1244 if (strcmp((char *)ImpName->Name, funcname) == 0)
\r
1245 return GetModuleHandle((char *)(Base + Imp->Name));
\r
1254 sbcs_mblen(csconv_t *cv, const uchar *buf, int bufsize)
\r
1260 dbcs_mblen(csconv_t *cv, const uchar *buf, int bufsize)
\r
1262 int len = IsDBCSLeadByteEx(cv->codepage, buf[0]) ? 2 : 1;
\r
1263 if (bufsize < len)
\r
1264 return_error(EINVAL);
\r
1269 mbcs_mblen(csconv_t *cv, const uchar *buf, int bufsize)
\r
1273 if (cv->codepage == 54936) {
\r
1274 if (buf[0] <= 0x7F) len = 1;
\r
1275 else if (buf[0] >= 0x81 && buf[0] <= 0xFE &&
\r
1277 ((buf[1] >= 0x40 && buf[1] <= 0x7E) ||
\r
1278 (buf[1] >= 0x80 && buf[1] <= 0xFE))) len = 2;
\r
1279 else if (buf[0] >= 0x81 && buf[0] <= 0xFE &&
\r
1281 buf[1] >= 0x30 && buf[1] <= 0x39) len = 4;
\r
1283 return_error(EINVAL);
\r
1287 return_error(EINVAL);
\r
1291 utf8_mblen(csconv_t *cv, const uchar *buf, int bufsize)
\r
1295 if (buf[0] < 0x80) len = 1;
\r
1296 else if ((buf[0] & 0xE0) == 0xC0) len = 2;
\r
1297 else if ((buf[0] & 0xF0) == 0xE0) len = 3;
\r
1298 else if ((buf[0] & 0xF8) == 0xF0) len = 4;
\r
1299 else if ((buf[0] & 0xFC) == 0xF8) len = 5;
\r
1300 else if ((buf[0] & 0xFE) == 0xFC) len = 6;
\r
1303 return_error(EILSEQ);
\r
1304 else if (bufsize < len)
\r
1305 return_error(EINVAL);
\r
1310 eucjp_mblen(csconv_t *cv, const uchar *buf, int bufsize)
\r
1312 if (buf[0] < 0x80) /* ASCII */
\r
1314 else if (buf[0] == 0x8E) /* JIS X 0201 */
\r
1317 return_error(EINVAL);
\r
1318 else if (!(0xA1 <= buf[1] && buf[1] <= 0xDF))
\r
1319 return_error(EILSEQ);
\r
1322 else if (buf[0] == 0x8F) /* JIS X 0212 */
\r
1325 return_error(EINVAL);
\r
1326 else if (!(0xA1 <= buf[1] && buf[1] <= 0xFE)
\r
1327 || !(0xA1 <= buf[2] && buf[2] <= 0xFE))
\r
1328 return_error(EILSEQ);
\r
1331 else /* JIS X 0208 */
\r
1334 return_error(EINVAL);
\r
1335 else if (!(0xA1 <= buf[0] && buf[0] <= 0xFE)
\r
1336 || !(0xA1 <= buf[1] && buf[1] <= 0xFE))
\r
1337 return_error(EILSEQ);
\r
1343 kernel_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize)
\r
1347 len = cv->mblen(cv, buf, bufsize);
\r
1350 *wbufsize = MultiByteToWideChar(cv->codepage, mbtowc_flags (cv->codepage),
\r
1351 (const char *)buf, len, (wchar_t *)wbuf, *wbufsize);
\r
1352 if (*wbufsize == 0)
\r
1353 return_error(EILSEQ);
\r
1358 kernel_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize)
\r
1360 BOOL usedDefaultChar = 0;
\r
1366 return_error(E2BIG);
\r
1367 if (!must_use_null_useddefaultchar(cv->codepage))
\r
1369 p = &usedDefaultChar;
\r
1370 #ifdef WC_NO_BEST_FIT_CHARS
\r
1371 if (!(cv->flags & FLAG_TRANSLIT))
\r
1372 flags |= WC_NO_BEST_FIT_CHARS;
\r
1375 len = WideCharToMultiByte(cv->codepage, flags,
\r
1376 (const wchar_t *)wbuf, wbufsize, (char *)buf, bufsize, NULL, p);
\r
1379 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
\r
1380 return_error(E2BIG);
\r
1381 return_error(EILSEQ);
\r
1383 else if (usedDefaultChar)
\r
1384 return_error(EILSEQ);
\r
1385 else if (cv->mblen(cv, buf, len) != len) /* validate result */
\r
1386 return_error(EILSEQ);
\r
1391 * It seems that the mode (cv->mode) is fixnum.
\r
1392 * For example, when converting iso-2022-jp(cp50221) to unicode:
\r
1393 * in ascii sequence: mode=0xC42C0000
\r
1394 * in jisx0208 sequence: mode=0xC42C0001
\r
1395 * "C42C" is same for each convert session.
\r
1396 * It should be: ((codepage-1)<<16)|state
\r
1399 mlang_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize)
\r
1405 len = cv->mblen(cv, buf, bufsize);
\r
1409 hr = ConvertINetMultiByteToUnicode(&cv->mode, cv->codepage,
\r
1410 (const char *)buf, &insize, (wchar_t *)wbuf, wbufsize);
\r
1411 if (hr != S_OK || insize != len)
\r
1412 return_error(EILSEQ);
\r
1417 mlang_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize)
\r
1419 char tmpbuf[MB_CHAR_MAX]; /* enough room for one character */
\r
1420 int tmpsize = MB_CHAR_MAX;
\r
1421 int insize = wbufsize;
\r
1424 hr = ConvertINetUnicodeToMultiByte(&cv->mode, cv->codepage,
\r
1425 (const wchar_t *)wbuf, &wbufsize, tmpbuf, &tmpsize);
\r
1426 if (hr != S_OK || insize != wbufsize)
\r
1427 return_error(EILSEQ);
\r
1428 else if (bufsize < tmpsize)
\r
1429 return_error(E2BIG);
\r
1430 else if (cv->mblen(cv, (uchar *)tmpbuf, tmpsize) != tmpsize)
\r
1431 return_error(EILSEQ);
\r
1432 memcpy(buf, tmpbuf, tmpsize);
\r
1437 utf16_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize)
\r
1440 return_error(EINVAL);
\r
1441 if (cv->codepage == 1200) /* little endian */
\r
1442 wbuf[0] = (buf[1] << 8) | buf[0];
\r
1443 else if (cv->codepage == 1201) /* big endian */
\r
1444 wbuf[0] = (buf[0] << 8) | buf[1];
\r
1445 if (0xDC00 <= wbuf[0] && wbuf[0] <= 0xDFFF)
\r
1446 return_error(EILSEQ);
\r
1447 if (0xD800 <= wbuf[0] && wbuf[0] <= 0xDBFF)
\r
1450 return_error(EINVAL);
\r
1451 if (cv->codepage == 1200) /* little endian */
\r
1452 wbuf[1] = (buf[3] << 8) | buf[2];
\r
1453 else if (cv->codepage == 1201) /* big endian */
\r
1454 wbuf[1] = (buf[2] << 8) | buf[3];
\r
1455 if (!(0xDC00 <= wbuf[1] && wbuf[1] <= 0xDFFF))
\r
1456 return_error(EILSEQ);
\r
1465 utf16_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize)
\r
1468 return_error(E2BIG);
\r
1469 if (cv->codepage == 1200) /* little endian */
\r
1471 buf[0] = (wbuf[0] & 0x00FF);
\r
1472 buf[1] = (wbuf[0] & 0xFF00) >> 8;
\r
1474 else if (cv->codepage == 1201) /* big endian */
\r
1476 buf[0] = (wbuf[0] & 0xFF00) >> 8;
\r
1477 buf[1] = (wbuf[0] & 0x00FF);
\r
1479 if (0xD800 <= wbuf[0] && wbuf[0] <= 0xDBFF)
\r
1482 return_error(E2BIG);
\r
1483 if (cv->codepage == 1200) /* little endian */
\r
1485 buf[2] = (wbuf[1] & 0x00FF);
\r
1486 buf[3] = (wbuf[1] & 0xFF00) >> 8;
\r
1488 else if (cv->codepage == 1201) /* big endian */
\r
1490 buf[2] = (wbuf[1] & 0xFF00) >> 8;
\r
1491 buf[3] = (wbuf[1] & 0x00FF);
\r
1499 utf32_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize)
\r
1504 return_error(EINVAL);
\r
1505 if (cv->codepage == 12000) /* little endian */
\r
1506 wc = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
\r
1507 else if (cv->codepage == 12001) /* big endian */
\r
1508 wc = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
\r
1509 if ((0xD800 <= wc && wc <= 0xDFFF) || 0x10FFFF < wc)
\r
1510 return_error(EILSEQ);
\r
1511 ucs4_to_utf16(wc, wbuf, wbufsize);
\r
1516 utf32_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize)
\r
1521 return_error(E2BIG);
\r
1522 wc = utf16_to_ucs4(wbuf);
\r
1523 if (cv->codepage == 12000) /* little endian */
\r
1525 buf[0] = wc & 0x000000FF;
\r
1526 buf[1] = (wc & 0x0000FF00) >> 8;
\r
1527 buf[2] = (wc & 0x00FF0000) >> 16;
\r
1528 buf[3] = (wc & 0xFF000000) >> 24;
\r
1530 else if (cv->codepage == 12001) /* big endian */
\r
1532 buf[0] = (wc & 0xFF000000) >> 24;
\r
1533 buf[1] = (wc & 0x00FF0000) >> 16;
\r
1534 buf[2] = (wc & 0x0000FF00) >> 8;
\r
1535 buf[3] = wc & 0x000000FF;
\r
1541 * 50220: ISO 2022 Japanese with no halfwidth Katakana; Japanese (JIS)
\r
1542 * 50221: ISO 2022 Japanese with halfwidth Katakana; Japanese (JIS-Allow
\r
1544 * 50222: ISO 2022 Japanese JIS X 0201-1989; Japanese (JIS-Allow 1 byte
\r
1547 * MultiByteToWideChar() and WideCharToMultiByte() behave differently
\r
1548 * depending on Windows version. On XP, WideCharToMultiByte() doesn't
\r
1549 * terminate result sequence with ascii escape. But Vista does.
\r
1550 * Use MLang instead.
\r
1553 #define ISO2022_MODE(cs, shift) (((cs) << 8) | (shift))
\r
1554 #define ISO2022_MODE_CS(mode) (((mode) >> 8) & 0xFF)
\r
1555 #define ISO2022_MODE_SHIFT(mode) ((mode) & 0xFF)
\r
1557 #define ISO2022_SI 0
\r
1558 #define ISO2022_SO 1
\r
1561 static const char iso2022_SI_seq[] = "\x0F";
\r
1563 static const char iso2022_SO_seq[] = "\x0E";
\r
1565 typedef struct iso2022_esc_t iso2022_esc_t;
\r
1566 struct iso2022_esc_t {
\r
1573 #define ISO2022JP_CS_ASCII 0
\r
1574 #define ISO2022JP_CS_JISX0201_ROMAN 1
\r
1575 #define ISO2022JP_CS_JISX0201_KANA 2
\r
1576 #define ISO2022JP_CS_JISX0208_1978 3
\r
1577 #define ISO2022JP_CS_JISX0208_1983 4
\r
1578 #define ISO2022JP_CS_JISX0212 5
\r
1580 static iso2022_esc_t iso2022jp_esc[] = {
\r
1581 {"\x1B\x28\x42", 3, 1, ISO2022JP_CS_ASCII},
\r
1582 {"\x1B\x28\x4A", 3, 1, ISO2022JP_CS_JISX0201_ROMAN},
\r
1583 {"\x1B\x28\x49", 3, 1, ISO2022JP_CS_JISX0201_KANA},
\r
1584 {"\x1B\x24\x40", 3, 2, ISO2022JP_CS_JISX0208_1983}, /* unify 1978 with 1983 */
\r
1585 {"\x1B\x24\x42", 3, 2, ISO2022JP_CS_JISX0208_1983},
\r
1586 {"\x1B\x24\x28\x44", 4, 2, ISO2022JP_CS_JISX0212},
\r
1591 iso2022jp_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize)
\r
1593 iso2022_esc_t *iesc = iso2022jp_esc;
\r
1594 char tmp[MB_CHAR_MAX];
\r
1604 if (buf[0] == 0x1B)
\r
1606 for (i = 0; iesc[i].esc != NULL; ++i)
\r
1608 esc_len = iesc[i].esc_len;
\r
1609 if (bufsize < esc_len)
\r
1611 if (strncmp((char *)buf, iesc[i].esc, bufsize) == 0)
\r
1612 return_error(EINVAL);
\r
1616 if (strncmp((char *)buf, iesc[i].esc, esc_len) == 0)
\r
1618 cv->mode = ISO2022_MODE(iesc[i].cs, ISO2022_SI);
\r
1624 /* not supported escape sequence */
\r
1625 return_error(EILSEQ);
\r
1627 else if (buf[0] == iso2022_SO_seq[0])
\r
1629 cv->mode = ISO2022_MODE(ISO2022_MODE_CS(cv->mode), ISO2022_SO);
\r
1633 else if (buf[0] == iso2022_SI_seq[0])
\r
1635 cv->mode = ISO2022_MODE(ISO2022_MODE_CS(cv->mode), ISO2022_SI);
\r
1640 cs = ISO2022_MODE_CS(cv->mode);
\r
1641 shift = ISO2022_MODE_SHIFT(cv->mode);
\r
1643 /* reset the mode for informal sequence */
\r
1644 if (buf[0] < 0x20)
\r
1646 cs = ISO2022JP_CS_ASCII;
\r
1647 shift = ISO2022_SI;
\r
1650 len = iesc[cs].len;
\r
1651 if (bufsize < len)
\r
1652 return_error(EINVAL);
\r
1653 for (i = 0; i < len; ++i)
\r
1654 if (!(buf[i] < 0x80))
\r
1655 return_error(EILSEQ);
\r
1656 esc_len = iesc[cs].esc_len;
\r
1657 memcpy(tmp, iesc[cs].esc, esc_len);
\r
1658 if (shift == ISO2022_SO)
\r
1660 memcpy(tmp + esc_len, iso2022_SO_seq, 1);
\r
1663 memcpy(tmp + esc_len, buf, len);
\r
1665 if ((cv->codepage == 50220 || cv->codepage == 50221
\r
1666 || cv->codepage == 50222) && shift == ISO2022_SO)
\r
1668 /* XXX: shift-out cannot be used for mbtowc (both kernel and
\r
1670 esc_len = iesc[ISO2022JP_CS_JISX0201_KANA].esc_len;
\r
1671 memcpy(tmp, iesc[ISO2022JP_CS_JISX0201_KANA].esc, esc_len);
\r
1672 memcpy(tmp + esc_len, buf, len);
\r
1675 insize = len + esc_len;
\r
1676 hr = ConvertINetMultiByteToUnicode(&dummy, cv->codepage,
\r
1677 (const char *)tmp, &insize, (wchar_t *)wbuf, wbufsize);
\r
1678 if (hr != S_OK || insize != len + esc_len)
\r
1679 return_error(EILSEQ);
\r
1681 /* Check for conversion error. Assuming defaultChar is 0x3F. */
\r
1682 /* ascii should be converted from ascii */
\r
1683 if (wbuf[0] == buf[0]
\r
1684 && cv->mode != ISO2022_MODE(ISO2022JP_CS_ASCII, ISO2022_SI))
\r
1685 return_error(EILSEQ);
\r
1687 /* reset the mode for informal sequence */
\r
1688 if (cv->mode != ISO2022_MODE(cs, shift))
\r
1689 cv->mode = ISO2022_MODE(cs, shift);
\r
1695 iso2022jp_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize)
\r
1697 iso2022_esc_t *iesc = iso2022jp_esc;
\r
1698 char tmp[MB_CHAR_MAX];
\r
1699 int tmpsize = MB_CHAR_MAX;
\r
1700 int insize = wbufsize;
\r
1710 * MultiByte = [escape sequence] + character + [escape sequence]
\r
1712 * Whether trailing escape sequence is added depends on which API is
\r
1713 * used (kernel or MLang, and its version).
\r
1715 hr = ConvertINetUnicodeToMultiByte(&dummy, cv->codepage,
\r
1716 (const wchar_t *)wbuf, &wbufsize, tmp, &tmpsize);
\r
1717 if (hr != S_OK || insize != wbufsize)
\r
1718 return_error(EILSEQ);
\r
1719 else if (bufsize < tmpsize)
\r
1720 return_error(E2BIG);
\r
1724 cs = ISO2022JP_CS_ASCII;
\r
1729 for (i = 1; iesc[i].esc != NULL; ++i)
\r
1731 esc_len = iesc[i].esc_len;
\r
1732 if (strncmp(tmp, iesc[i].esc, esc_len) == 0)
\r
1738 if (iesc[i].esc == NULL)
\r
1739 /* not supported escape sequence */
\r
1740 return_error(EILSEQ);
\r
1743 shift = ISO2022_SI;
\r
1744 if (tmp[esc_len] == iso2022_SO_seq[0])
\r
1746 shift = ISO2022_SO;
\r
1750 len = iesc[cs].len;
\r
1752 /* Check for converting error. Assuming defaultChar is 0x3F. */
\r
1753 /* ascii should be converted from ascii */
\r
1754 if (cs == ISO2022JP_CS_ASCII && !(wbuf[0] < 0x80))
\r
1755 return_error(EILSEQ);
\r
1756 else if (tmpsize < esc_len + len)
\r
1757 return_error(EILSEQ);
\r
1759 if (cv->mode == ISO2022_MODE(cs, shift))
\r
1761 /* remove escape sequence */
\r
1763 memmove(tmp, tmp + esc_len, len);
\r
1768 if (cs == ISO2022JP_CS_ASCII)
\r
1770 esc_len = iesc[ISO2022JP_CS_ASCII].esc_len;
\r
1771 memmove(tmp + esc_len, tmp, len);
\r
1772 memcpy(tmp, iesc[ISO2022JP_CS_ASCII].esc, esc_len);
\r
1774 if (ISO2022_MODE_SHIFT(cv->mode) == ISO2022_SO)
\r
1776 /* shift-in before changing to other mode */
\r
1777 memmove(tmp + 1, tmp, len + esc_len);
\r
1778 memcpy(tmp, iso2022_SI_seq, 1);
\r
1783 if (bufsize < len + esc_len)
\r
1784 return_error(E2BIG);
\r
1785 memcpy(buf, tmp, len + esc_len);
\r
1786 cv->mode = ISO2022_MODE(cs, shift);
\r
1787 return len + esc_len;
\r
1791 iso2022jp_flush(csconv_t *cv, uchar *buf, int bufsize)
\r
1793 iso2022_esc_t *iesc = iso2022jp_esc;
\r
1796 if (cv->mode != ISO2022_MODE(ISO2022JP_CS_ASCII, ISO2022_SI))
\r
1799 if (ISO2022_MODE_SHIFT(cv->mode) != ISO2022_SI)
\r
1801 if (ISO2022_MODE_CS(cv->mode) != ISO2022JP_CS_ASCII)
\r
1802 esc_len += iesc[ISO2022JP_CS_ASCII].esc_len;
\r
1803 if (bufsize < esc_len)
\r
1804 return_error(E2BIG);
\r
1807 if (ISO2022_MODE_SHIFT(cv->mode) != ISO2022_SI)
\r
1809 memcpy(buf, iso2022_SI_seq, 1);
\r
1812 if (ISO2022_MODE_CS(cv->mode) != ISO2022JP_CS_ASCII)
\r
1814 memcpy(buf + esc_len, iesc[ISO2022JP_CS_ASCII].esc,
\r
1815 iesc[ISO2022JP_CS_ASCII].esc_len);
\r
1816 esc_len += iesc[ISO2022JP_CS_ASCII].esc_len;
\r
1823 #if defined(MAKE_DLL) && defined(USE_LIBICONV_DLL)
\r
1825 DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved)
\r
1827 switch( fdwReason )
\r
1829 case DLL_PROCESS_ATTACH:
\r
1830 hwiniconv = (HMODULE)hinstDLL;
\r
1832 case DLL_THREAD_ATTACH:
\r
1833 case DLL_THREAD_DETACH:
\r
1834 case DLL_PROCESS_DETACH:
\r
1841 #if defined(MAKE_EXE)
\r
1842 #include <stdio.h>
\r
1843 #include <fcntl.h>
\r
1846 main(int argc, char **argv)
\r
1848 char *fromcode = NULL;
\r
1849 char *tocode = NULL;
\r
1851 char inbuf[BUFSIZ];
\r
1852 char outbuf[BUFSIZ];
\r
1855 size_t inbytesleft;
\r
1856 size_t outbytesleft;
\r
1862 _setmode(_fileno(stdin), _O_BINARY);
\r
1863 _setmode(_fileno(stdout), _O_BINARY);
\r
1865 for (i = 1; i < argc; ++i)
\r
1867 if (strcmp(argv[i], "-l") == 0)
\r
1869 for (i = 0; codepage_alias[i].name != NULL; ++i)
\r
1870 printf("%s\n", codepage_alias[i].name);
\r
1874 if (strcmp(argv[i], "-f") == 0)
\r
1875 fromcode = argv[++i];
\r
1876 else if (strcmp(argv[i], "-t") == 0)
\r
1877 tocode = argv[++i];
\r
1880 in = fopen(argv[i], "rb");
\r
1883 fprintf(stderr, "cannot open %s\n", argv[i]);
\r
1890 if (fromcode == NULL || tocode == NULL)
\r
1892 printf("usage: %s -f from-enc -t to-enc [file]\n", argv[0]);
\r
1896 cd = iconv_open(tocode, fromcode);
\r
1897 if (cd == (iconv_t)(-1))
\r
1899 perror("iconv_open error");
\r
1903 while ((inbytesleft = fread(inbuf + rest, 1, sizeof(inbuf) - rest, in)) != 0
\r
1906 inbytesleft += rest;
\r
1909 outbytesleft = sizeof(outbuf);
\r
1910 r = iconv(cd, &pin, &inbytesleft, &pout, &outbytesleft);
\r
1911 fwrite(outbuf, 1, sizeof(outbuf) - outbytesleft, stdout);
\r
1912 if (r == (size_t)(-1) && errno != EINVAL && errno != E2BIG)
\r
1914 perror("conversion error");
\r
1917 memmove(inbuf, pin, inbytesleft);
\r
1918 rest = inbytesleft;
\r
1921 outbytesleft = sizeof(outbuf);
\r
1922 r = iconv(cd, NULL, NULL, &pout, &outbytesleft);
\r
1923 fwrite(outbuf, 1, sizeof(outbuf) - outbytesleft, stdout);
\r
1924 if (r == (size_t)(-1))
\r
1926 perror("conversion error");
\r