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 #include <windows.h>
\r
30 # define USE_LIBICONV_DLL
\r
33 #if !defined(DEFAULT_LIBICONV_DLL)
\r
34 # define DEFAULT_LIBICONV_DLL ""
\r
37 #define MB_CHAR_MAX 16
\r
39 #define UNICODE_MODE_BOM_DONE 1
\r
40 #define UNICODE_MODE_SWAPPED 2
\r
42 #define UNICODE_FLAG_USE_BOM_ENDIAN 1
\r
44 #define return_error(code) \
\r
50 #define xstrlcpy(dst, src, size) \
\r
52 strncpy(dst, src, size); \
\r
53 dst[size - 1] = 0; \
\r
56 #define xstrlcpyn(dst, src, srclen, size) \
\r
57 xstrlcpy(dst, src, xmin((srclen) + 1, size))
\r
59 #define xmin(a, b) ((a) < (b) ? (a) : (b))
\r
60 #define xmax(a, b) ((a) > (b) ? (a) : (b))
\r
62 #define STATIC_STRLEN(arr) (sizeof(arr) - 1)
\r
64 typedef unsigned char uchar;
\r
65 typedef unsigned short ushort;
\r
66 typedef unsigned int uint;
\r
68 typedef void* iconv_t;
\r
70 iconv_t iconv_open(const char *tocode, const char *fromcode);
\r
71 int iconv_close(iconv_t cd);
\r
72 size_t iconv(iconv_t cd, const char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);
\r
74 /* libiconv interface for vim */
\r
75 #if defined(MAKE_DLL)
\r
77 iconvctl (iconv_t cd, int request, void* argument)
\r
84 typedef struct compat_t compat_t;
\r
85 typedef struct csconv_t csconv_t;
\r
86 typedef struct rec_iconv_t rec_iconv_t;
\r
88 typedef iconv_t (*f_iconv_open)(const char *tocode, const char *fromcode);
\r
89 typedef int (*f_iconv_close)(iconv_t cd);
\r
90 typedef size_t (*f_iconv)(iconv_t cd, const char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);
\r
91 typedef int* (*f_errno)(void);
\r
92 typedef int (*f_mbtowc)(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
\r
93 typedef int (*f_wctomb)(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
\r
94 typedef int (*f_mblen)(csconv_t *cv, const uchar *buf, int bufsize);
\r
95 typedef int (*f_flush)(csconv_t *cv, uchar *buf, int bufsize);
\r
98 #define COMPAT_OUT 2
\r
100 /* unicode mapping for compatibility with other conversion table. */
\r
118 struct rec_iconv_t {
\r
120 f_iconv_close iconv_close;
\r
125 #if defined(USE_LIBICONV_DLL)
\r
130 static int win_iconv_open(rec_iconv_t *cd, const char *tocode, const char *fromcode);
\r
131 static int win_iconv_close(iconv_t cd);
\r
132 static size_t win_iconv(iconv_t cd, const char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);
\r
134 static int load_mlang();
\r
135 static csconv_t make_csconv(const char *name);
\r
136 static int name_to_codepage(const char *name);
\r
137 static uint utf16_to_ucs4(const ushort *wbuf);
\r
138 static void ucs4_to_utf16(uint wc, ushort *wbuf, int *wbufsize);
\r
139 static int is_unicode(int codepage);
\r
140 static int must_use_null_useddefaultchar(int codepage);
\r
141 static void check_utf_bom(rec_iconv_t *cd, ushort *wbuf, int *wbufsize);
\r
142 static char *strrstr(const char *str, const char *token);
\r
144 #if defined(USE_LIBICONV_DLL)
\r
145 static int libiconv_iconv_open(rec_iconv_t *cd, const char *tocode, const char *fromcode);
\r
146 static PVOID MyImageDirectoryEntryToData(LPVOID Base, BOOLEAN MappedAsImage, USHORT DirectoryEntry, PULONG Size);
\r
147 static HMODULE find_imported_module_by_funcname(HMODULE hModule, const char *funcname);
\r
149 static HMODULE hwiniconv;
\r
150 static HMODULE hlastdll; /* keep dll loaded for efficiency (unnecessary?) */
\r
153 static int sbcs_mblen(csconv_t *cv, const uchar *buf, int bufsize);
\r
154 static int dbcs_mblen(csconv_t *cv, const uchar *buf, int bufsize);
\r
155 static int utf8_mblen(csconv_t *cv, const uchar *buf, int bufsize);
\r
156 static int eucjp_mblen(csconv_t *cv, const uchar *buf, int bufsize);
\r
158 static int kernel_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
\r
159 static int kernel_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
\r
160 static int mlang_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
\r
161 static int mlang_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
\r
162 static int utf16_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
\r
163 static int utf16_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
\r
164 static int utf32_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
\r
165 static int utf32_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
\r
166 static int iso2022jp_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
\r
167 static int iso2022jp_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
\r
168 static int iso2022jp_flush(csconv_t *cv, uchar *buf, int bufsize);
\r
173 } codepage_alias[] = {
\r
174 {65001, "CP65001"},
\r
180 {1200, "UTF-16LE"},
\r
184 {1201, "UTF-16BE"},
\r
185 {1201, "unicodeFFFE"},
\r
187 {12000, "CP12000"},
\r
188 {12000, "UTF32LE"},
\r
189 {12000, "UTF-32LE"},
\r
191 {12001, "CP12001"},
\r
192 {12001, "UTF32BE"},
\r
193 {12001, "UTF-32BE"},
\r
195 #ifndef GLIB_COMPILATION
\r
197 * Default is big endian.
\r
198 * See rfc2781 4.3 Interpreting text labelled as UTF-16.
\r
205 /* Default is little endian, because the platform is */
\r
212 /* copy from libiconv `iconv -l` */
\r
213 /* !IsValidCodePage(367) */
\r
214 {20127, "ANSI_X3.4-1968"},
\r
215 {20127, "ANSI_X3.4-1986"},
\r
219 {20127, "ISO-IR-6"},
\r
220 {20127, "ISO646-US"},
\r
221 {20127, "ISO_646.IRV:1991"},
\r
223 {20127, "US-ASCII"},
\r
224 {20127, "CSASCII"},
\r
226 /* !IsValidCodePage(819) */
\r
229 {28591, "ISO-8859-1"},
\r
230 {28591, "ISO-IR-100"},
\r
231 {28591, "ISO8859-1"},
\r
232 {28591, "ISO_8859-1"},
\r
233 {28591, "ISO_8859-1:1987"},
\r
236 {28591, "CSISOLATIN1"},
\r
240 {1250, "WINDOWS-1250"},
\r
244 {1251, "WINDOWS-1251"},
\r
248 {1252, "WINDOWS-1252"},
\r
251 {1253, "MS-GREEK"},
\r
252 {1253, "WINDOWS-1253"},
\r
256 {1254, "WINDOWS-1254"},
\r
260 {1255, "WINDOWS-1255"},
\r
264 {1256, "WINDOWS-1256"},
\r
267 {1257, "WINBALTRIM"},
\r
268 {1257, "WINDOWS-1257"},
\r
271 {1258, "WINDOWS-1258"},
\r
276 {850, "CSPC850MULTILINGUAL"},
\r
278 /* !IsValidCodePage(862) */
\r
282 {862, "CSPC862LATINHEBREW"},
\r
289 /* !IsValidCodePage(154) */
\r
291 {154, "CYRILLIC-ASIAN"},
\r
294 {154, "CSPTCP154"},
\r
296 /* !IsValidCodePage(1133) */
\r
298 {1133, "IBM-CP1133"},
\r
301 {874, "WINDOWS-874"},
\r
303 /* !IsValidCodePage(51932) */
\r
304 {51932, "CP51932"},
\r
305 {51932, "MS51932"},
\r
306 {51932, "WINDOWS-51932"},
\r
311 {932, "SHIFFT_JIS"},
\r
312 {932, "SHIFFT_JIS-MS"},
\r
315 {932, "SJIS-OPEN"},
\r
317 {932, "WINDOWS-31J"},
\r
318 {932, "WINDOWS-932"},
\r
319 {932, "CSWINDOWS31J"},
\r
321 {50221, "CP50221"},
\r
322 {50221, "ISO-2022-JP"},
\r
323 {50221, "ISO-2022-JP-MS"},
\r
324 {50221, "ISO2022-JP"},
\r
325 {50221, "ISO2022-JP-MS"},
\r
326 {50221, "MS50221"},
\r
327 {50221, "WINDOWS-50221"},
\r
332 {936, "WINDOWS-936"},
\r
347 {437, "CSPC8CODEPAGE437"},
\r
353 {775, "CSPC775BALTIC"},
\r
360 /* !IsValidCodePage(853) */
\r
373 /* !IsValidCodePage(858) */
\r
407 /* !IsValidCodePage(1152) */
\r
411 * Code Page Identifiers
\r
412 * http://msdn2.microsoft.com/en-us/library/ms776446.aspx
\r
414 {37, "IBM037"}, /* IBM EBCDIC US-Canada */
\r
415 {437, "IBM437"}, /* OEM United States */
\r
416 {500, "IBM500"}, /* IBM EBCDIC International */
\r
417 {708, "ASMO-708"}, /* Arabic (ASMO 708) */
\r
418 /* 709 Arabic (ASMO-449+, BCON V4) */
\r
419 /* 710 Arabic - Transparent Arabic */
\r
420 {720, "DOS-720"}, /* Arabic (Transparent ASMO); Arabic (DOS) */
\r
421 {737, "ibm737"}, /* OEM Greek (formerly 437G); Greek (DOS) */
\r
422 {775, "ibm775"}, /* OEM Baltic; Baltic (DOS) */
\r
423 {850, "ibm850"}, /* OEM Multilingual Latin 1; Western European (DOS) */
\r
424 {852, "ibm852"}, /* OEM Latin 2; Central European (DOS) */
\r
425 {855, "IBM855"}, /* OEM Cyrillic (primarily Russian) */
\r
426 {857, "ibm857"}, /* OEM Turkish; Turkish (DOS) */
\r
427 {858, "IBM00858"}, /* OEM Multilingual Latin 1 + Euro symbol */
\r
428 {860, "IBM860"}, /* OEM Portuguese; Portuguese (DOS) */
\r
429 {861, "ibm861"}, /* OEM Icelandic; Icelandic (DOS) */
\r
430 {862, "DOS-862"}, /* OEM Hebrew; Hebrew (DOS) */
\r
431 {863, "IBM863"}, /* OEM French Canadian; French Canadian (DOS) */
\r
432 {864, "IBM864"}, /* OEM Arabic; Arabic (864) */
\r
433 {865, "IBM865"}, /* OEM Nordic; Nordic (DOS) */
\r
434 {866, "cp866"}, /* OEM Russian; Cyrillic (DOS) */
\r
435 {869, "ibm869"}, /* OEM Modern Greek; Greek, Modern (DOS) */
\r
436 {870, "IBM870"}, /* IBM EBCDIC Multilingual/ROECE (Latin 2); IBM EBCDIC Multilingual Latin 2 */
\r
437 {874, "windows-874"}, /* ANSI/OEM Thai (same as 28605, ISO 8859-15); Thai (Windows) */
\r
438 {875, "cp875"}, /* IBM EBCDIC Greek Modern */
\r
439 {932, "shift_jis"}, /* ANSI/OEM Japanese; Japanese (Shift-JIS) */
\r
440 {936, "gb2312"}, /* ANSI/OEM Simplified Chinese (PRC, Singapore); Chinese Simplified (GB2312) */
\r
441 {949, "ks_c_5601-1987"}, /* ANSI/OEM Korean (Unified Hangul Code) */
\r
442 {950, "big5"}, /* ANSI/OEM Traditional Chinese (Taiwan; Hong Kong SAR, PRC); Chinese Traditional (Big5) */
\r
443 {1026, "IBM1026"}, /* IBM EBCDIC Turkish (Latin 5) */
\r
444 {1047, "IBM01047"}, /* IBM EBCDIC Latin 1/Open System */
\r
445 {1140, "IBM01140"}, /* IBM EBCDIC US-Canada (037 + Euro symbol); IBM EBCDIC (US-Canada-Euro) */
\r
446 {1141, "IBM01141"}, /* IBM EBCDIC Germany (20273 + Euro symbol); IBM EBCDIC (Germany-Euro) */
\r
447 {1142, "IBM01142"}, /* IBM EBCDIC Denmark-Norway (20277 + Euro symbol); IBM EBCDIC (Denmark-Norway-Euro) */
\r
448 {1143, "IBM01143"}, /* IBM EBCDIC Finland-Sweden (20278 + Euro symbol); IBM EBCDIC (Finland-Sweden-Euro) */
\r
449 {1144, "IBM01144"}, /* IBM EBCDIC Italy (20280 + Euro symbol); IBM EBCDIC (Italy-Euro) */
\r
450 {1145, "IBM01145"}, /* IBM EBCDIC Latin America-Spain (20284 + Euro symbol); IBM EBCDIC (Spain-Euro) */
\r
451 {1146, "IBM01146"}, /* IBM EBCDIC United Kingdom (20285 + Euro symbol); IBM EBCDIC (UK-Euro) */
\r
452 {1147, "IBM01147"}, /* IBM EBCDIC France (20297 + Euro symbol); IBM EBCDIC (France-Euro) */
\r
453 {1148, "IBM01148"}, /* IBM EBCDIC International (500 + Euro symbol); IBM EBCDIC (International-Euro) */
\r
454 {1149, "IBM01149"}, /* IBM EBCDIC Icelandic (20871 + Euro symbol); IBM EBCDIC (Icelandic-Euro) */
\r
455 {1250, "windows-1250"}, /* ANSI Central European; Central European (Windows) */
\r
456 {1251, "windows-1251"}, /* ANSI Cyrillic; Cyrillic (Windows) */
\r
457 {1252, "windows-1252"}, /* ANSI Latin 1; Western European (Windows) */
\r
458 {1253, "windows-1253"}, /* ANSI Greek; Greek (Windows) */
\r
459 {1254, "windows-1254"}, /* ANSI Turkish; Turkish (Windows) */
\r
460 {1255, "windows-1255"}, /* ANSI Hebrew; Hebrew (Windows) */
\r
461 {1256, "windows-1256"}, /* ANSI Arabic; Arabic (Windows) */
\r
462 {1257, "windows-1257"}, /* ANSI Baltic; Baltic (Windows) */
\r
463 {1258, "windows-1258"}, /* ANSI/OEM Vietnamese; Vietnamese (Windows) */
\r
464 {1361, "Johab"}, /* Korean (Johab) */
\r
465 {10000, "macintosh"}, /* MAC Roman; Western European (Mac) */
\r
466 {10001, "x-mac-japanese"}, /* Japanese (Mac) */
\r
467 {10002, "x-mac-chinesetrad"}, /* MAC Traditional Chinese (Big5); Chinese Traditional (Mac) */
\r
468 {10003, "x-mac-korean"}, /* Korean (Mac) */
\r
469 {10004, "x-mac-arabic"}, /* Arabic (Mac) */
\r
470 {10005, "x-mac-hebrew"}, /* Hebrew (Mac) */
\r
471 {10006, "x-mac-greek"}, /* Greek (Mac) */
\r
472 {10007, "x-mac-cyrillic"}, /* Cyrillic (Mac) */
\r
473 {10008, "x-mac-chinesesimp"}, /* MAC Simplified Chinese (GB 2312); Chinese Simplified (Mac) */
\r
474 {10010, "x-mac-romanian"}, /* Romanian (Mac) */
\r
475 {10017, "x-mac-ukrainian"}, /* Ukrainian (Mac) */
\r
476 {10021, "x-mac-thai"}, /* Thai (Mac) */
\r
477 {10029, "x-mac-ce"}, /* MAC Latin 2; Central European (Mac) */
\r
478 {10079, "x-mac-icelandic"}, /* Icelandic (Mac) */
\r
479 {10081, "x-mac-turkish"}, /* Turkish (Mac) */
\r
480 {10082, "x-mac-croatian"}, /* Croatian (Mac) */
\r
481 {20000, "x-Chinese_CNS"}, /* CNS Taiwan; Chinese Traditional (CNS) */
\r
482 {20001, "x-cp20001"}, /* TCA Taiwan */
\r
483 {20002, "x_Chinese-Eten"}, /* Eten Taiwan; Chinese Traditional (Eten) */
\r
484 {20003, "x-cp20003"}, /* IBM5550 Taiwan */
\r
485 {20004, "x-cp20004"}, /* TeleText Taiwan */
\r
486 {20005, "x-cp20005"}, /* Wang Taiwan */
\r
487 {20105, "x-IA5"}, /* IA5 (IRV International Alphabet No. 5, 7-bit); Western European (IA5) */
\r
488 {20106, "x-IA5-German"}, /* IA5 German (7-bit) */
\r
489 {20107, "x-IA5-Swedish"}, /* IA5 Swedish (7-bit) */
\r
490 {20108, "x-IA5-Norwegian"}, /* IA5 Norwegian (7-bit) */
\r
491 {20127, "us-ascii"}, /* US-ASCII (7-bit) */
\r
492 {20261, "x-cp20261"}, /* T.61 */
\r
493 {20269, "x-cp20269"}, /* ISO 6937 Non-Spacing Accent */
\r
494 {20273, "IBM273"}, /* IBM EBCDIC Germany */
\r
495 {20277, "IBM277"}, /* IBM EBCDIC Denmark-Norway */
\r
496 {20278, "IBM278"}, /* IBM EBCDIC Finland-Sweden */
\r
497 {20280, "IBM280"}, /* IBM EBCDIC Italy */
\r
498 {20284, "IBM284"}, /* IBM EBCDIC Latin America-Spain */
\r
499 {20285, "IBM285"}, /* IBM EBCDIC United Kingdom */
\r
500 {20290, "IBM290"}, /* IBM EBCDIC Japanese Katakana Extended */
\r
501 {20297, "IBM297"}, /* IBM EBCDIC France */
\r
502 {20420, "IBM420"}, /* IBM EBCDIC Arabic */
\r
503 {20423, "IBM423"}, /* IBM EBCDIC Greek */
\r
504 {20424, "IBM424"}, /* IBM EBCDIC Hebrew */
\r
505 {20833, "x-EBCDIC-KoreanExtended"}, /* IBM EBCDIC Korean Extended */
\r
506 {20838, "IBM-Thai"}, /* IBM EBCDIC Thai */
\r
507 {20866, "koi8-r"}, /* Russian (KOI8-R); Cyrillic (KOI8-R) */
\r
508 {20871, "IBM871"}, /* IBM EBCDIC Icelandic */
\r
509 {20880, "IBM880"}, /* IBM EBCDIC Cyrillic Russian */
\r
510 {20905, "IBM905"}, /* IBM EBCDIC Turkish */
\r
511 {20924, "IBM00924"}, /* IBM EBCDIC Latin 1/Open System (1047 + Euro symbol) */
\r
512 {20932, "EUC-JP"}, /* Japanese (JIS 0208-1990 and 0121-1990) */
\r
513 {20936, "x-cp20936"}, /* Simplified Chinese (GB2312); Chinese Simplified (GB2312-80) */
\r
514 {20949, "x-cp20949"}, /* Korean Wansung */
\r
515 {21025, "cp1025"}, /* IBM EBCDIC Cyrillic Serbian-Bulgarian */
\r
516 /* 21027 (deprecated) */
\r
517 {21866, "koi8-u"}, /* Ukrainian (KOI8-U); Cyrillic (KOI8-U) */
\r
518 {28591, "iso-8859-1"}, /* ISO 8859-1 Latin 1; Western European (ISO) */
\r
519 {28591, "iso8859-1"}, /* ISO 8859-1 Latin 1; Western European (ISO) */
\r
520 {28592, "iso-8859-2"}, /* ISO 8859-2 Central European; Central European (ISO) */
\r
521 {28592, "iso8859-2"}, /* ISO 8859-2 Central European; Central European (ISO) */
\r
522 {28593, "iso-8859-3"}, /* ISO 8859-3 Latin 3 */
\r
523 {28593, "iso8859-3"}, /* ISO 8859-3 Latin 3 */
\r
524 {28594, "iso-8859-4"}, /* ISO 8859-4 Baltic */
\r
525 {28594, "iso8859-4"}, /* ISO 8859-4 Baltic */
\r
526 {28595, "iso-8859-5"}, /* ISO 8859-5 Cyrillic */
\r
527 {28595, "iso8859-5"}, /* ISO 8859-5 Cyrillic */
\r
528 {28596, "iso-8859-6"}, /* ISO 8859-6 Arabic */
\r
529 {28596, "iso8859-6"}, /* ISO 8859-6 Arabic */
\r
530 {28597, "iso-8859-7"}, /* ISO 8859-7 Greek */
\r
531 {28597, "iso8859-7"}, /* ISO 8859-7 Greek */
\r
532 {28598, "iso-8859-8"}, /* ISO 8859-8 Hebrew; Hebrew (ISO-Visual) */
\r
533 {28598, "iso8859-8"}, /* ISO 8859-8 Hebrew; Hebrew (ISO-Visual) */
\r
534 {28599, "iso-8859-9"}, /* ISO 8859-9 Turkish */
\r
535 {28599, "iso8859-9"}, /* ISO 8859-9 Turkish */
\r
536 {28603, "iso-8859-13"}, /* ISO 8859-13 Estonian */
\r
537 {28603, "iso8859-13"}, /* ISO 8859-13 Estonian */
\r
538 {28605, "iso-8859-15"}, /* ISO 8859-15 Latin 9 */
\r
539 {28605, "iso8859-15"}, /* ISO 8859-15 Latin 9 */
\r
540 {29001, "x-Europa"}, /* Europa 3 */
\r
541 {38598, "iso-8859-8-i"}, /* ISO 8859-8 Hebrew; Hebrew (ISO-Logical) */
\r
542 {38598, "iso8859-8-i"}, /* ISO 8859-8 Hebrew; Hebrew (ISO-Logical) */
\r
543 {50220, "iso-2022-jp"}, /* ISO 2022 Japanese with no halfwidth Katakana; Japanese (JIS) */
\r
544 {50221, "csISO2022JP"}, /* ISO 2022 Japanese with halfwidth Katakana; Japanese (JIS-Allow 1 byte Kana) */
\r
545 {50222, "iso-2022-jp"}, /* ISO 2022 Japanese JIS X 0201-1989; Japanese (JIS-Allow 1 byte Kana - SO/SI) */
\r
546 {50225, "iso-2022-kr"}, /* ISO 2022 Korean */
\r
547 {50225, "iso2022-kr"}, /* ISO 2022 Korean */
\r
548 {50227, "x-cp50227"}, /* ISO 2022 Simplified Chinese; Chinese Simplified (ISO 2022) */
\r
549 /* 50229 ISO 2022 Traditional Chinese */
\r
550 /* 50930 EBCDIC Japanese (Katakana) Extended */
\r
551 /* 50931 EBCDIC US-Canada and Japanese */
\r
552 /* 50933 EBCDIC Korean Extended and Korean */
\r
553 /* 50935 EBCDIC Simplified Chinese Extended and Simplified Chinese */
\r
554 /* 50936 EBCDIC Simplified Chinese */
\r
555 /* 50937 EBCDIC US-Canada and Traditional Chinese */
\r
556 /* 50939 EBCDIC Japanese (Latin) Extended and Japanese */
\r
557 {51932, "euc-jp"}, /* EUC Japanese */
\r
558 {51936, "EUC-CN"}, /* EUC Simplified Chinese; Chinese Simplified (EUC) */
\r
559 {51949, "euc-kr"}, /* EUC Korean */
\r
560 /* 51950 EUC Traditional Chinese */
\r
561 {52936, "hz-gb-2312"}, /* HZ-GB2312 Simplified Chinese; Chinese Simplified (HZ) */
\r
562 {54936, "GB18030"}, /* Windows XP and later: GB18030 Simplified Chinese (4 byte); Chinese Simplified (GB18030) */
\r
563 {57002, "x-iscii-de"}, /* ISCII Devanagari */
\r
564 {57003, "x-iscii-be"}, /* ISCII Bengali */
\r
565 {57004, "x-iscii-ta"}, /* ISCII Tamil */
\r
566 {57005, "x-iscii-te"}, /* ISCII Telugu */
\r
567 {57006, "x-iscii-as"}, /* ISCII Assamese */
\r
568 {57007, "x-iscii-or"}, /* ISCII Oriya */
\r
569 {57008, "x-iscii-ka"}, /* ISCII Kannada */
\r
570 {57009, "x-iscii-ma"}, /* ISCII Malayalam */
\r
571 {57010, "x-iscii-gu"}, /* ISCII Gujarati */
\r
572 {57011, "x-iscii-pa"}, /* ISCII Punjabi */
\r
578 * SJIS SHIFTJIS table CP932 table
\r
579 * ---- --------------------------- --------------------------------
\r
580 * 5C U+00A5 YEN SIGN U+005C REVERSE SOLIDUS
\r
581 * 7E U+203E OVERLINE U+007E TILDE
\r
582 * 815C U+2014 EM DASH U+2015 HORIZONTAL BAR
\r
583 * 815F U+005C REVERSE SOLIDUS U+FF3C FULLWIDTH REVERSE SOLIDUS
\r
584 * 8160 U+301C WAVE DASH U+FF5E FULLWIDTH TILDE
\r
585 * 8161 U+2016 DOUBLE VERTICAL LINE U+2225 PARALLEL TO
\r
586 * 817C U+2212 MINUS SIGN U+FF0D FULLWIDTH HYPHEN-MINUS
\r
587 * 8191 U+00A2 CENT SIGN U+FFE0 FULLWIDTH CENT SIGN
\r
588 * 8192 U+00A3 POUND SIGN U+FFE1 FULLWIDTH POUND SIGN
\r
589 * 81CA U+00AC NOT SIGN U+FFE2 FULLWIDTH NOT SIGN
\r
591 * EUC-JP and ISO-2022-JP should be compatible with CP932.
\r
593 * Kernel and MLang have different Unicode mapping table. Make sure
\r
594 * which API is used.
\r
596 static compat_t cp932_compat[] = {
\r
597 {0x00A5, 0x005C, COMPAT_OUT},
\r
598 {0x203E, 0x007E, COMPAT_OUT},
\r
599 {0x2014, 0x2015, COMPAT_OUT},
\r
600 {0x301C, 0xFF5E, COMPAT_OUT},
\r
601 {0x2016, 0x2225, COMPAT_OUT},
\r
602 {0x2212, 0xFF0D, COMPAT_OUT},
\r
603 {0x00A2, 0xFFE0, COMPAT_OUT},
\r
604 {0x00A3, 0xFFE1, COMPAT_OUT},
\r
605 {0x00AC, 0xFFE2, COMPAT_OUT},
\r
609 static compat_t cp20932_compat[] = {
\r
610 {0x00A5, 0x005C, COMPAT_OUT},
\r
611 {0x203E, 0x007E, COMPAT_OUT},
\r
612 {0x2014, 0x2015, COMPAT_OUT},
\r
613 {0xFF5E, 0x301C, COMPAT_OUT|COMPAT_IN},
\r
614 {0x2225, 0x2016, COMPAT_OUT|COMPAT_IN},
\r
615 {0xFF0D, 0x2212, COMPAT_OUT|COMPAT_IN},
\r
616 {0xFFE0, 0x00A2, COMPAT_OUT|COMPAT_IN},
\r
617 {0xFFE1, 0x00A3, COMPAT_OUT|COMPAT_IN},
\r
618 {0xFFE2, 0x00AC, COMPAT_OUT|COMPAT_IN},
\r
622 static compat_t *cp51932_compat = cp932_compat;
\r
624 /* cp20932_compat for kernel. cp932_compat for mlang. */
\r
625 static compat_t *cp5022x_compat = cp932_compat;
\r
627 typedef HRESULT (WINAPI *CONVERTINETSTRING)(
\r
629 DWORD dwSrcEncoding,
\r
630 DWORD dwDstEncoding,
\r
636 typedef HRESULT (WINAPI *CONVERTINETMULTIBYTETOUNICODE)(
\r
638 DWORD dwSrcEncoding,
\r
640 LPINT lpnMultiCharCount,
\r
642 LPINT lpnWideCharCount
\r
644 typedef HRESULT (WINAPI *CONVERTINETUNICODETOMULTIBYTE)(
\r
648 LPINT lpnWideCharCount,
\r
650 LPINT lpnMultiCharCount
\r
652 typedef HRESULT (WINAPI *ISCONVERTINETSTRINGAVAILABLE)(
\r
653 DWORD dwSrcEncoding,
\r
654 DWORD dwDstEncoding
\r
656 typedef HRESULT (WINAPI *LCIDTORFC1766A)(
\r
661 typedef HRESULT (WINAPI *LCIDTORFC1766W)(
\r
666 typedef HRESULT (WINAPI *RFC1766TOLCIDA)(
\r
670 typedef HRESULT (WINAPI *RFC1766TOLCIDW)(
\r
674 static CONVERTINETSTRING ConvertINetString;
\r
675 static CONVERTINETMULTIBYTETOUNICODE ConvertINetMultiByteToUnicode;
\r
676 static CONVERTINETUNICODETOMULTIBYTE ConvertINetUnicodeToMultiByte;
\r
677 static ISCONVERTINETSTRINGAVAILABLE IsConvertINetStringAvailable;
\r
678 static LCIDTORFC1766A LcidToRfc1766A;
\r
679 static RFC1766TOLCIDA Rfc1766ToLcidA;
\r
685 if (ConvertINetString != NULL)
\r
687 h = LoadLibrary("mlang.dll");
\r
690 ConvertINetString = (CONVERTINETSTRING)GetProcAddress(h, "ConvertINetString");
\r
691 ConvertINetMultiByteToUnicode = (CONVERTINETMULTIBYTETOUNICODE)GetProcAddress(h, "ConvertINetMultiByteToUnicode");
\r
692 ConvertINetUnicodeToMultiByte = (CONVERTINETUNICODETOMULTIBYTE)GetProcAddress(h, "ConvertINetUnicodeToMultiByte");
\r
693 IsConvertINetStringAvailable = (ISCONVERTINETSTRINGAVAILABLE)GetProcAddress(h, "IsConvertINetStringAvailable");
\r
694 LcidToRfc1766A = (LCIDTORFC1766A)GetProcAddress(h, "LcidToRfc1766A");
\r
695 Rfc1766ToLcidA = (RFC1766TOLCIDA)GetProcAddress(h, "Rfc1766ToLcidA");
\r
700 iconv_open(const char *tocode, const char *fromcode)
\r
704 cd = (rec_iconv_t *)calloc(1, sizeof(rec_iconv_t));
\r
708 return (iconv_t)(-1);
\r
711 #if defined(USE_LIBICONV_DLL)
\r
712 if (libiconv_iconv_open(cd, tocode, fromcode))
\r
713 return (iconv_t)cd;
\r
716 if (win_iconv_open(cd, tocode, fromcode))
\r
717 return (iconv_t)cd;
\r
721 return (iconv_t)(-1);
\r
725 iconv_close(iconv_t _cd)
\r
727 rec_iconv_t *cd = (rec_iconv_t *)_cd;
\r
728 int r = cd->iconv_close(cd->cd);
\r
729 int e = *(cd->_errno());
\r
730 #if defined(USE_LIBICONV_DLL)
\r
731 if (cd->hlibiconv != NULL)
\r
732 FreeLibrary(cd->hlibiconv);
\r
740 iconv(iconv_t _cd, const char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft)
\r
742 rec_iconv_t *cd = (rec_iconv_t *)_cd;
\r
743 size_t r = cd->iconv(cd->cd, inbuf, inbytesleft, outbuf, outbytesleft);
\r
744 errno = *(cd->_errno());
\r
749 win_iconv_open(rec_iconv_t *cd, const char *tocode, const char *fromcode)
\r
751 cd->from = make_csconv(fromcode);
\r
752 cd->to = make_csconv(tocode);
\r
753 if (cd->from.codepage == -1 || cd->to.codepage == -1)
\r
755 cd->iconv_close = win_iconv_close;
\r
756 cd->iconv = win_iconv;
\r
757 cd->_errno = _errno;
\r
758 cd->cd = (iconv_t)cd;
\r
763 win_iconv_close(iconv_t cd)
\r
769 win_iconv(iconv_t _cd, const char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft)
\r
771 rec_iconv_t *cd = (rec_iconv_t *)_cd;
\r
772 ushort wbuf[MB_CHAR_MAX]; /* enough room for one character */
\r
781 if (inbuf == NULL || *inbuf == NULL)
\r
783 if (outbuf != NULL && *outbuf != NULL && cd->to.flush != NULL)
\r
785 outsize = cd->to.flush(&cd->to, (uchar *)*outbuf, *outbytesleft);
\r
787 return (size_t)(-1);
\r
788 *outbuf += outsize;
\r
789 *outbytesleft -= outsize;
\r
791 if (is_unicode(cd->from.codepage) && (cd->from.mode & UNICODE_MODE_SWAPPED))
\r
792 cd->from.codepage ^= 1;
\r
798 while (*inbytesleft != 0)
\r
800 mode = cd->from.mode;
\r
801 wsize = MB_CHAR_MAX;
\r
803 insize = cd->from.mbtowc(&cd->from, (const uchar *)*inbuf, *inbytesleft, wbuf, &wsize);
\r
805 return (size_t)(-1);
\r
807 if (is_unicode(cd->from.codepage) && !(cd->from.mode & UNICODE_MODE_BOM_DONE))
\r
809 check_utf_bom(cd, wbuf, &wsize);
\r
810 cd->from.mode |= UNICODE_MODE_BOM_DONE;
\r
816 *inbytesleft -= insize;
\r
820 if (cd->from.compat != NULL)
\r
822 wc = utf16_to_ucs4(wbuf);
\r
823 cp = cd->from.compat;
\r
824 for (i = 0; cp[i].in != 0; ++i)
\r
826 if ((cp[i].flag & COMPAT_IN) && cp[i].out == wc)
\r
828 ucs4_to_utf16(cp[i].in, wbuf, &wsize);
\r
834 if (cd->to.compat != NULL)
\r
836 wc = utf16_to_ucs4(wbuf);
\r
837 cp = cd->to.compat;
\r
838 for (i = 0; cp[i].in != 0; ++i)
\r
840 if ((cp[i].flag & COMPAT_OUT) && cp[i].in == wc)
\r
842 ucs4_to_utf16(cp[i].out, wbuf, &wsize);
\r
848 outsize = cd->to.wctomb(&cd->to, wbuf, wsize, (uchar *)*outbuf, *outbytesleft);
\r
851 cd->from.mode = mode;
\r
852 return (size_t)(-1);
\r
856 *outbuf += outsize;
\r
857 *inbytesleft -= insize;
\r
858 *outbytesleft -= outsize;
\r
865 make_csconv(const char *_name)
\r
869 int use_compat = TRUE;
\r
873 xstrlcpy(name, _name, sizeof(name));
\r
875 /* check for option "enc_name//opt1//opt2" */
\r
876 while ((p = strrstr(name, "//")) != NULL)
\r
878 if (_stricmp(p + 2, "nocompat") == 0)
\r
879 use_compat = FALSE;
\r
888 cv.codepage = name_to_codepage(name);
\r
889 if (cv.codepage == 1200 || cv.codepage == 1201)
\r
891 cv.mbtowc = utf16_mbtowc;
\r
892 cv.wctomb = utf16_wctomb;
\r
893 if (_stricmp(name, "UTF-16") == 0 || _stricmp(name, "UTF16") == 0)
\r
894 cv.flags |= UNICODE_FLAG_USE_BOM_ENDIAN;
\r
896 else if (cv.codepage == 12000 || cv.codepage == 12001)
\r
898 cv.mbtowc = utf32_mbtowc;
\r
899 cv.wctomb = utf32_wctomb;
\r
900 if (_stricmp(name, "UTF-32") == 0 || _stricmp(name, "UTF32") == 0)
\r
901 cv.flags |= UNICODE_FLAG_USE_BOM_ENDIAN;
\r
903 else if (cv.codepage == 65001)
\r
905 cv.mbtowc = kernel_mbtowc;
\r
906 cv.wctomb = kernel_wctomb;
\r
907 cv.mblen = utf8_mblen;
\r
909 else if ((cv.codepage == 50220 || cv.codepage == 50221 || cv.codepage == 50222) && load_mlang())
\r
911 cv.mbtowc = iso2022jp_mbtowc;
\r
912 cv.wctomb = iso2022jp_wctomb;
\r
913 cv.flush = iso2022jp_flush;
\r
915 else if (cv.codepage == 51932 && load_mlang())
\r
917 cv.mbtowc = mlang_mbtowc;
\r
918 cv.wctomb = mlang_wctomb;
\r
919 cv.mblen = eucjp_mblen;
\r
921 else if (IsValidCodePage(cv.codepage)
\r
922 && GetCPInfoEx(cv.codepage, 0, &cpinfoex) != 0
\r
923 && (cpinfoex.MaxCharSize == 1 || cpinfoex.MaxCharSize == 2))
\r
925 cv.mbtowc = kernel_mbtowc;
\r
926 cv.wctomb = kernel_wctomb;
\r
927 if (cpinfoex.MaxCharSize == 1)
\r
928 cv.mblen = sbcs_mblen;
\r
930 cv.mblen = dbcs_mblen;
\r
934 /* not supported */
\r
939 switch (cv.codepage)
\r
941 case 932: cv.compat = cp932_compat; break;
\r
942 case 20932: cv.compat = cp20932_compat; break;
\r
943 case 51932: cv.compat = cp51932_compat; break;
\r
944 case 50220: case 50221: case 50222: cv.compat = cp5022x_compat; break;
\r
951 name_to_codepage(const char *name)
\r
955 if (_strnicmp(name, "cp", 2) == 0)
\r
956 return atoi(name + 2); /* CP123 */
\r
957 else if ('0' <= name[0] && name[0] <= '9')
\r
958 return atoi(name); /* 123 */
\r
959 else if (_strnicmp(name, "xx", 2) == 0)
\r
960 return atoi(name + 2); /* XX123 for debug */
\r
962 for (i = 0; codepage_alias[i].name != NULL; ++i)
\r
963 if (_stricmp(name, codepage_alias[i].name) == 0)
\r
964 return codepage_alias[i].codepage;
\r
969 * http://www.faqs.org/rfcs/rfc2781.html
\r
972 utf16_to_ucs4(const ushort *wbuf)
\r
975 if (0xD800 <= wbuf[0] && wbuf[0] <= 0xDBFF)
\r
976 wc = ((wbuf[0] & 0x3FF) << 10) + (wbuf[1] & 0x3FF) + 0x10000;
\r
981 ucs4_to_utf16(uint wc, ushort *wbuf, int *wbufsize)
\r
991 wbuf[0] = 0xD800 | ((wc >> 10) & 0x3FF);
\r
992 wbuf[1] = 0xDC00 | (wc & 0x3FF);
\r
998 is_unicode(int codepage)
\r
1000 return (codepage == 1200 || codepage == 1201 ||
\r
1001 codepage == 12000 || codepage == 12001 ||
\r
1002 codepage == 65000 || codepage == 65001);
\r
1006 must_use_null_useddefaultchar(int codepage)
\r
1008 return (codepage == 65000 || codepage == 65001 ||
\r
1009 codepage == 50220 || codepage == 50221 ||
\r
1010 codepage == 50222 || codepage == 50225 ||
\r
1011 codepage == 50227 || codepage == 50229 ||
\r
1012 codepage == 52936 || codepage == 54936 ||
\r
1013 (codepage >= 57002 && codepage <= 57011) ||
\r
1018 check_utf_bom(rec_iconv_t *cd, ushort *wbuf, int *wbufsize)
\r
1020 /* If we have a BOM, trust it, despite what the caller said */
\r
1021 if (wbuf[0] == 0xFFFE && (cd->from.flags & UNICODE_FLAG_USE_BOM_ENDIAN))
\r
1023 /* swap endian: 1200 <-> 1201 or 12000 <-> 12001 */
\r
1024 cd->from.codepage ^= 1;
\r
1025 cd->from.mode |= UNICODE_MODE_SWAPPED;
\r
1031 * Don't do this if "to" is Unicode,
\r
1032 * except if "to" is UTF-8.
\r
1034 if (wbuf[0] == 0xFEFF && (!is_unicode(cd->to.codepage) || cd->to.codepage == 65001))
\r
1039 strrstr(const char *str, const char *token)
\r
1041 int len = strlen(token);
\r
1042 const char *p = str + strlen(str);
\r
1044 while (str <= --p)
\r
1045 if (p[0] == token[0] && strncmp(p, token, len) == 0)
\r
1050 #if defined(USE_LIBICONV_DLL)
\r
1052 libiconv_iconv_open(rec_iconv_t *cd, const char *fromcode, const char *tocode)
\r
1054 HMODULE hlibiconv = NULL;
\r
1055 HMODULE hmsvcrt = NULL;
\r
1056 char dllname[_MAX_PATH];
\r
1059 f_iconv_open _iconv_open;
\r
1062 * always try to load dll, so that we can switch dll in runtime.
\r
1065 /* XXX: getenv() can't get variable set by SetEnvironmentVariable() */
\r
1066 p = getenv("WINICONV_LIBICONV_DLL");
\r
1068 p = DEFAULT_LIBICONV_DLL;
\r
1069 /* parse comma separated value */
\r
1070 for ( ; *p != 0; p = (*e == ',') ? e + 1 : e)
\r
1072 e = strchr(p, ',');
\r
1075 else if (e == NULL)
\r
1076 e = p + strlen(p);
\r
1077 xstrlcpyn(dllname, p, e - p, sizeof(dllname));
\r
1078 hlibiconv = LoadLibrary(dllname);
\r
1079 if (hlibiconv != NULL)
\r
1081 if (hlibiconv == hwiniconv)
\r
1083 FreeLibrary(hlibiconv);
\r
1091 if (hlastdll != NULL)
\r
1093 /* decrement reference count */
\r
1094 FreeLibrary(hlastdll);
\r
1098 if (hlibiconv == NULL)
\r
1101 hmsvcrt = find_imported_module_by_funcname(hlibiconv, "_errno");
\r
1102 if (hmsvcrt == NULL)
\r
1105 _iconv_open = (f_iconv_open)GetProcAddress(hlibiconv, "libiconv_open");
\r
1106 if (_iconv_open == NULL)
\r
1107 _iconv_open = (f_iconv_open)GetProcAddress(hlibiconv, "iconv_open");
\r
1108 cd->iconv_close = (f_iconv_close)GetProcAddress(hlibiconv, "libiconv_close");
\r
1109 if (cd->iconv_close == NULL)
\r
1110 cd->iconv_close = (f_iconv_close)GetProcAddress(hlibiconv, "iconv_close");
\r
1111 cd->iconv = (f_iconv)GetProcAddress(hlibiconv, "libiconv");
\r
1112 if (cd->iconv == NULL)
\r
1113 cd->iconv = (f_iconv)GetProcAddress(hlibiconv, "iconv");
\r
1114 cd->_errno = (f_errno)GetProcAddress(hmsvcrt, "_errno");
\r
1115 if (_iconv_open == NULL || cd->iconv_close == NULL
\r
1116 || cd->iconv == NULL || cd->_errno == NULL)
\r
1119 /* increment reference count */
\r
1120 hlastdll = LoadLibrary(dllname);
\r
1122 cd->cd = _iconv_open(tocode, fromcode);
\r
1123 if (cd->cd == (iconv_t)(-1))
\r
1126 cd->hlibiconv = hlibiconv;
\r
1130 if (hlibiconv != NULL)
\r
1131 FreeLibrary(hlibiconv);
\r
1132 /* do not free hmsvcrt which is obtained by GetModuleHandle() */
\r
1138 * http://forums.belution.com/ja/vc/000/234/78s.shtml
\r
1139 * http://nienie.com/~masapico/api_ImageDirectoryEntryToData.html
\r
1141 * The formal way is
\r
1142 * imagehlp.h or dbghelp.h
\r
1143 * imagehlp.lib or dbghelp.lib
\r
1144 * ImageDirectoryEntryToData()
\r
1146 #define TO_DOS_HEADER(base) ((PIMAGE_DOS_HEADER)(base))
\r
1147 #define TO_NT_HEADERS(base) ((PIMAGE_NT_HEADERS)((LPBYTE)(base) + TO_DOS_HEADER(base)->e_lfanew))
\r
1149 MyImageDirectoryEntryToData(LPVOID Base, BOOLEAN MappedAsImage, USHORT DirectoryEntry, PULONG Size)
\r
1151 /* TODO: MappedAsImage? */
\r
1152 PIMAGE_DATA_DIRECTORY p;
\r
1153 p = TO_NT_HEADERS(Base)->OptionalHeader.DataDirectory + DirectoryEntry;
\r
1154 if (p->VirtualAddress == 0) {
\r
1159 return (PVOID)((LPBYTE)Base + p->VirtualAddress);
\r
1163 find_imported_module_by_funcname(HMODULE hModule, const char *funcname)
\r
1167 PIMAGE_IMPORT_DESCRIPTOR Imp;
\r
1168 PIMAGE_THUNK_DATA Name; /* Import Name Table */
\r
1169 PIMAGE_IMPORT_BY_NAME ImpName;
\r
1171 Base = (DWORD)hModule;
\r
1172 Imp = MyImageDirectoryEntryToData(
\r
1175 IMAGE_DIRECTORY_ENTRY_IMPORT,
\r
1179 for ( ; Imp->OriginalFirstThunk != 0; ++Imp)
\r
1181 Name = (PIMAGE_THUNK_DATA)(Base + Imp->OriginalFirstThunk);
\r
1182 for ( ; Name->u1.Ordinal != 0; ++Name)
\r
1184 if (!IMAGE_SNAP_BY_ORDINAL(Name->u1.Ordinal))
\r
1186 ImpName = (PIMAGE_IMPORT_BY_NAME)
\r
1187 (Base + (DWORD)Name->u1.AddressOfData);
\r
1188 if (strcmp((char *)ImpName->Name, funcname) == 0)
\r
1189 return GetModuleHandle((char *)(Base + Imp->Name));
\r
1198 sbcs_mblen(csconv_t *cv, const uchar *buf, int bufsize)
\r
1204 dbcs_mblen(csconv_t *cv, const uchar *buf, int bufsize)
\r
1206 int len = IsDBCSLeadByteEx(cv->codepage, buf[0]) ? 2 : 1;
\r
1207 if (bufsize < len)
\r
1208 return_error(EINVAL);
\r
1213 utf8_mblen(csconv_t *cv, const uchar *buf, int bufsize)
\r
1217 if (buf[0] < 0x80) len = 1;
\r
1218 else if ((buf[0] & 0xE0) == 0xC0) len = 2;
\r
1219 else if ((buf[0] & 0xF0) == 0xE0) len = 3;
\r
1220 else if ((buf[0] & 0xF8) == 0xF0) len = 4;
\r
1221 else if ((buf[0] & 0xFC) == 0xF8) len = 5;
\r
1222 else if ((buf[0] & 0xFE) == 0xFC) len = 6;
\r
1225 return_error(EILSEQ);
\r
1226 else if (bufsize < len)
\r
1227 return_error(EINVAL);
\r
1232 eucjp_mblen(csconv_t *cv, const uchar *buf, int bufsize)
\r
1234 if (buf[0] < 0x80) /* ASCII */
\r
1236 else if (buf[0] == 0x8E) /* JIS X 0201 */
\r
1239 return_error(EINVAL);
\r
1240 else if (!(0xA1 <= buf[1] && buf[1] <= 0xDF))
\r
1241 return_error(EILSEQ);
\r
1244 else if (buf[0] == 0x8F) /* JIS X 0212 */
\r
1247 return_error(EINVAL);
\r
1248 else if (!(0xA1 <= buf[1] && buf[1] <= 0xFE)
\r
1249 || !(0xA1 <= buf[2] && buf[2] <= 0xFE))
\r
1250 return_error(EILSEQ);
\r
1253 else /* JIS X 0208 */
\r
1256 return_error(EINVAL);
\r
1257 else if (!(0xA1 <= buf[0] && buf[0] <= 0xFE)
\r
1258 || !(0xA1 <= buf[1] && buf[1] <= 0xFE))
\r
1259 return_error(EILSEQ);
\r
1265 kernel_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize)
\r
1269 len = cv->mblen(cv, buf, bufsize);
\r
1272 *wbufsize = MultiByteToWideChar(cv->codepage, MB_ERR_INVALID_CHARS,
\r
1273 (const char *)buf, len, (wchar_t *)wbuf, *wbufsize);
\r
1274 if (*wbufsize == 0)
\r
1275 return_error(EILSEQ);
\r
1280 kernel_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize)
\r
1282 BOOL usedDefaultChar = 0;
\r
1286 return_error(E2BIG);
\r
1287 len = WideCharToMultiByte(cv->codepage, 0,
\r
1288 (const wchar_t *)wbuf, wbufsize, (char *)buf, bufsize, NULL,
\r
1289 must_use_null_useddefaultchar(cv->codepage) ? NULL : &usedDefaultChar);
\r
1292 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
\r
1293 return_error(E2BIG);
\r
1294 return_error(EILSEQ);
\r
1296 else if (usedDefaultChar)
\r
1297 return_error(EILSEQ);
\r
1298 else if (cv->mblen(cv, buf, len) != len) /* validate result */
\r
1299 return_error(EILSEQ);
\r
1304 * It seems that the mode (cv->mode) is fixnum.
\r
1305 * For example, when converting iso-2022-jp(cp50221) to unicode:
\r
1306 * in ascii sequence: mode=0xC42C0000
\r
1307 * in jisx0208 sequence: mode=0xC42C0001
\r
1308 * "C42C" is same for each convert session.
\r
1309 * It should be: ((codepage-1)<<16)|state
\r
1312 mlang_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize)
\r
1318 len = cv->mblen(cv, buf, bufsize);
\r
1322 hr = ConvertINetMultiByteToUnicode(&cv->mode, cv->codepage,
\r
1323 (const char *)buf, &insize, (wchar_t *)wbuf, wbufsize);
\r
1324 if (hr != S_OK || insize != len)
\r
1325 return_error(EILSEQ);
\r
1330 mlang_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize)
\r
1332 char tmpbuf[MB_CHAR_MAX]; /* enough room for one character */
\r
1333 int tmpsize = MB_CHAR_MAX;
\r
1334 int insize = wbufsize;
\r
1337 hr = ConvertINetUnicodeToMultiByte(&cv->mode, cv->codepage,
\r
1338 (const wchar_t *)wbuf, &wbufsize, tmpbuf, &tmpsize);
\r
1339 if (hr != S_OK || insize != wbufsize)
\r
1340 return_error(EILSEQ);
\r
1341 else if (bufsize < tmpsize)
\r
1342 return_error(E2BIG);
\r
1343 else if (cv->mblen(cv, (uchar *)tmpbuf, tmpsize) != tmpsize)
\r
1344 return_error(EILSEQ);
\r
1345 memcpy(buf, tmpbuf, tmpsize);
\r
1350 utf16_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize)
\r
1353 return_error(EINVAL);
\r
1354 if (cv->codepage == 1200) /* little endian */
\r
1355 wbuf[0] = (buf[1] << 8) | buf[0];
\r
1356 else if (cv->codepage == 1201) /* big endian */
\r
1357 wbuf[0] = (buf[0] << 8) | buf[1];
\r
1358 if (0xDC00 <= wbuf[0] && wbuf[0] <= 0xDFFF)
\r
1359 return_error(EILSEQ);
\r
1360 if (0xD800 <= wbuf[0] && wbuf[0] <= 0xDBFF)
\r
1363 return_error(EINVAL);
\r
1364 if (cv->codepage == 1200) /* little endian */
\r
1365 wbuf[1] = (buf[3] << 8) | buf[2];
\r
1366 else if (cv->codepage == 1201) /* big endian */
\r
1367 wbuf[1] = (buf[2] << 8) | buf[3];
\r
1368 if (!(0xDC00 <= wbuf[1] && wbuf[1] <= 0xDFFF))
\r
1369 return_error(EILSEQ);
\r
1378 utf16_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize)
\r
1381 return_error(E2BIG);
\r
1382 if (cv->codepage == 1200) /* little endian */
\r
1384 buf[0] = (wbuf[0] & 0x00FF);
\r
1385 buf[1] = (wbuf[0] & 0xFF00) >> 8;
\r
1387 else if (cv->codepage == 1201) /* big endian */
\r
1389 buf[0] = (wbuf[0] & 0xFF00) >> 8;
\r
1390 buf[1] = (wbuf[0] & 0x00FF);
\r
1392 if (0xD800 <= wbuf[0] && wbuf[0] <= 0xDBFF)
\r
1395 return_error(E2BIG);
\r
1396 if (cv->codepage == 1200) /* little endian */
\r
1398 buf[2] = (wbuf[1] & 0x00FF);
\r
1399 buf[3] = (wbuf[1] & 0xFF00) >> 8;
\r
1401 else if (cv->codepage == 1201) /* big endian */
\r
1403 buf[2] = (wbuf[1] & 0xFF00) >> 8;
\r
1404 buf[3] = (wbuf[1] & 0x00FF);
\r
1412 utf32_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize)
\r
1417 return_error(EINVAL);
\r
1418 if (cv->codepage == 12000) /* little endian */
\r
1419 wc = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
\r
1420 else if (cv->codepage == 12001) /* big endian */
\r
1421 wc = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
\r
1422 if ((0xD800 <= wc && wc <= 0xDFFF) || 0x10FFFF < wc)
\r
1423 return_error(EILSEQ);
\r
1424 ucs4_to_utf16(wc, wbuf, wbufsize);
\r
1429 utf32_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize)
\r
1434 return_error(E2BIG);
\r
1435 wc = utf16_to_ucs4(wbuf);
\r
1436 if (cv->codepage == 12000) /* little endian */
\r
1438 buf[0] = wc & 0x000000FF;
\r
1439 buf[1] = (wc & 0x0000FF00) >> 8;
\r
1440 buf[2] = (wc & 0x00FF0000) >> 16;
\r
1441 buf[3] = (wc & 0xFF000000) >> 24;
\r
1443 else if (cv->codepage == 12001) /* big endian */
\r
1445 buf[0] = (wc & 0xFF000000) >> 24;
\r
1446 buf[1] = (wc & 0x00FF0000) >> 16;
\r
1447 buf[2] = (wc & 0x0000FF00) >> 8;
\r
1448 buf[3] = wc & 0x000000FF;
\r
1454 * 50220: ISO 2022 Japanese with no halfwidth Katakana; Japanese (JIS)
\r
1455 * 50221: ISO 2022 Japanese with halfwidth Katakana; Japanese (JIS-Allow
\r
1457 * 50222: ISO 2022 Japanese JIS X 0201-1989; Japanese (JIS-Allow 1 byte
\r
1460 * MultiByteToWideChar() and WideCharToMultiByte() behave differently
\r
1461 * depending on Windows version. On XP, WideCharToMultiByte() doesn't
\r
1462 * terminate result sequence with ascii escape. But Vista does.
\r
1463 * Use MLang instead.
\r
1466 #define ISO2022_MODE(cs, shift) (((cs) << 8) | (shift))
\r
1467 #define ISO2022_MODE_CS(mode) (((mode) >> 8) & 0xFF)
\r
1468 #define ISO2022_MODE_SHIFT(mode) ((mode) & 0xFF)
\r
1470 #define ISO2022_SI 0
\r
1471 #define ISO2022_SO 1
\r
1474 static const char iso2022_SI_seq[] = "\x0F";
\r
1476 static const char iso2022_SO_seq[] = "\x0E";
\r
1478 typedef struct iso2022_esc_t iso2022_esc_t;
\r
1479 struct iso2022_esc_t {
\r
1486 #define ISO2022JP_CS_ASCII 0
\r
1487 #define ISO2022JP_CS_JISX0201_ROMAN 1
\r
1488 #define ISO2022JP_CS_JISX0201_KANA 2
\r
1489 #define ISO2022JP_CS_JISX0208_1978 3
\r
1490 #define ISO2022JP_CS_JISX0208_1983 4
\r
1491 #define ISO2022JP_CS_JISX0212 5
\r
1493 static iso2022_esc_t iso2022jp_esc[] = {
\r
1494 {"\x1B\x28\x42", 3, 1, ISO2022JP_CS_ASCII},
\r
1495 {"\x1B\x28\x4A", 3, 1, ISO2022JP_CS_JISX0201_ROMAN},
\r
1496 {"\x1B\x28\x49", 3, 1, ISO2022JP_CS_JISX0201_KANA},
\r
1497 {"\x1B\x24\x40", 3, 2, ISO2022JP_CS_JISX0208_1983}, /* unify 1978 with 1983 */
\r
1498 {"\x1B\x24\x42", 3, 2, ISO2022JP_CS_JISX0208_1983},
\r
1499 {"\x1B\x24\x28\x44", 4, 2, ISO2022JP_CS_JISX0212},
\r
1504 iso2022jp_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize)
\r
1506 iso2022_esc_t *iesc = iso2022jp_esc;
\r
1507 char tmp[MB_CHAR_MAX];
\r
1517 if (buf[0] == 0x1B)
\r
1519 for (i = 0; iesc[i].esc != NULL; ++i)
\r
1521 esc_len = iesc[i].esc_len;
\r
1522 if (bufsize < esc_len)
\r
1524 if (strncmp((char *)buf, iesc[i].esc, bufsize) == 0)
\r
1525 return_error(EINVAL);
\r
1529 if (strncmp((char *)buf, iesc[i].esc, esc_len) == 0)
\r
1531 cv->mode = ISO2022_MODE(iesc[i].cs, ISO2022_SI);
\r
1537 /* not supported escape sequence */
\r
1538 return_error(EILSEQ);
\r
1540 else if (buf[0] == iso2022_SO_seq[0])
\r
1542 cv->mode = ISO2022_MODE(ISO2022_MODE_CS(cv->mode), ISO2022_SO);
\r
1546 else if (buf[0] == iso2022_SI_seq[0])
\r
1548 cv->mode = ISO2022_MODE(ISO2022_MODE_CS(cv->mode), ISO2022_SI);
\r
1553 cs = ISO2022_MODE_CS(cv->mode);
\r
1554 shift = ISO2022_MODE_SHIFT(cv->mode);
\r
1556 /* reset the mode for informal sequence */
\r
1557 if (buf[0] < 0x20)
\r
1559 cs = ISO2022JP_CS_ASCII;
\r
1560 shift = ISO2022_SI;
\r
1563 len = iesc[cs].len;
\r
1564 if (bufsize < len)
\r
1565 return_error(EINVAL);
\r
1566 for (i = 0; i < len; ++i)
\r
1567 if (!(buf[i] < 0x80))
\r
1568 return_error(EILSEQ);
\r
1569 esc_len = iesc[cs].esc_len;
\r
1570 memcpy(tmp, iesc[cs].esc, esc_len);
\r
1571 if (shift == ISO2022_SO)
\r
1573 memcpy(tmp + esc_len, iso2022_SO_seq, 1);
\r
1576 memcpy(tmp + esc_len, buf, len);
\r
1578 if ((cv->codepage == 50220 || cv->codepage == 50221
\r
1579 || cv->codepage == 50222) && shift == ISO2022_SO)
\r
1581 /* XXX: shift-out cannot be used for mbtowc (both kernel and
\r
1583 esc_len = iesc[ISO2022JP_CS_JISX0201_KANA].esc_len;
\r
1584 memcpy(tmp, iesc[ISO2022JP_CS_JISX0201_KANA].esc, esc_len);
\r
1585 memcpy(tmp + esc_len, buf, len);
\r
1588 insize = len + esc_len;
\r
1589 hr = ConvertINetMultiByteToUnicode(&dummy, cv->codepage,
\r
1590 (const char *)tmp, &insize, (wchar_t *)wbuf, wbufsize);
\r
1591 if (hr != S_OK || insize != len + esc_len)
\r
1592 return_error(EILSEQ);
\r
1594 /* Check for conversion error. Assuming defaultChar is 0x3F. */
\r
1595 /* ascii should be converted from ascii */
\r
1596 if (wbuf[0] == buf[0]
\r
1597 && cv->mode != ISO2022_MODE(ISO2022JP_CS_ASCII, ISO2022_SI))
\r
1598 return_error(EILSEQ);
\r
1600 /* reset the mode for informal sequence */
\r
1601 if (cv->mode != ISO2022_MODE(cs, shift))
\r
1602 cv->mode = ISO2022_MODE(cs, shift);
\r
1608 iso2022jp_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize)
\r
1610 iso2022_esc_t *iesc = iso2022jp_esc;
\r
1611 char tmp[MB_CHAR_MAX];
\r
1612 int tmpsize = MB_CHAR_MAX;
\r
1613 int insize = wbufsize;
\r
1623 * MultiByte = [escape sequence] + character + [escape sequence]
\r
1625 * Whether trailing escape sequence is added depends on which API is
\r
1626 * used (kernel or MLang, and its version).
\r
1628 hr = ConvertINetUnicodeToMultiByte(&dummy, cv->codepage,
\r
1629 (const wchar_t *)wbuf, &wbufsize, tmp, &tmpsize);
\r
1630 if (hr != S_OK || insize != wbufsize)
\r
1631 return_error(EILSEQ);
\r
1632 else if (bufsize < tmpsize)
\r
1633 return_error(E2BIG);
\r
1637 cs = ISO2022JP_CS_ASCII;
\r
1642 for (i = 1; iesc[i].esc != NULL; ++i)
\r
1644 esc_len = iesc[i].esc_len;
\r
1645 if (strncmp(tmp, iesc[i].esc, esc_len) == 0)
\r
1651 if (iesc[i].esc == NULL)
\r
1652 /* not supported escape sequence */
\r
1653 return_error(EILSEQ);
\r
1656 shift = ISO2022_SI;
\r
1657 if (tmp[esc_len] == iso2022_SO_seq[0])
\r
1659 shift = ISO2022_SO;
\r
1663 len = iesc[cs].len;
\r
1665 /* Check for converting error. Assuming defaultChar is 0x3F. */
\r
1666 /* ascii should be converted from ascii */
\r
1667 if (cs == ISO2022JP_CS_ASCII && !(wbuf[0] < 0x80))
\r
1668 return_error(EILSEQ);
\r
1669 else if (tmpsize < esc_len + len)
\r
1670 return_error(EILSEQ);
\r
1672 if (cv->mode == ISO2022_MODE(cs, shift))
\r
1674 /* remove escape sequence */
\r
1676 memmove(tmp, tmp + esc_len, len);
\r
1681 if (cs == ISO2022JP_CS_ASCII)
\r
1683 esc_len = iesc[ISO2022JP_CS_ASCII].esc_len;
\r
1684 memmove(tmp + esc_len, tmp, len);
\r
1685 memcpy(tmp, iesc[ISO2022JP_CS_ASCII].esc, esc_len);
\r
1687 if (ISO2022_MODE_SHIFT(cv->mode) == ISO2022_SO)
\r
1689 /* shift-in before changing to other mode */
\r
1690 memmove(tmp + 1, tmp, len + esc_len);
\r
1691 memcpy(tmp, iso2022_SI_seq, 1);
\r
1696 if (bufsize < len + esc_len)
\r
1697 return_error(E2BIG);
\r
1698 memcpy(buf, tmp, len + esc_len);
\r
1699 cv->mode = ISO2022_MODE(cs, shift);
\r
1700 return len + esc_len;
\r
1704 iso2022jp_flush(csconv_t *cv, uchar *buf, int bufsize)
\r
1706 iso2022_esc_t *iesc = iso2022jp_esc;
\r
1709 if (cv->mode != ISO2022_MODE(ISO2022JP_CS_ASCII, ISO2022_SI))
\r
1712 if (ISO2022_MODE_SHIFT(cv->mode) != ISO2022_SI)
\r
1714 if (ISO2022_MODE_CS(cv->mode) != ISO2022JP_CS_ASCII)
\r
1715 esc_len += iesc[ISO2022JP_CS_ASCII].esc_len;
\r
1716 if (bufsize < esc_len)
\r
1717 return_error(E2BIG);
\r
1720 if (ISO2022_MODE_SHIFT(cv->mode) != ISO2022_SI)
\r
1722 memcpy(buf, iso2022_SI_seq, 1);
\r
1725 if (ISO2022_MODE_CS(cv->mode) != ISO2022JP_CS_ASCII)
\r
1727 memcpy(buf + esc_len, iesc[ISO2022JP_CS_ASCII].esc,
\r
1728 iesc[ISO2022JP_CS_ASCII].esc_len);
\r
1729 esc_len += iesc[ISO2022JP_CS_ASCII].esc_len;
\r
1736 #if defined(MAKE_DLL) && defined(USE_LIBICONV_DLL)
\r
1738 DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved)
\r
1740 switch( fdwReason )
\r
1742 case DLL_PROCESS_ATTACH:
\r
1743 hwiniconv = (HMODULE)hinstDLL;
\r
1745 case DLL_THREAD_ATTACH:
\r
1746 case DLL_THREAD_DETACH:
\r
1747 case DLL_PROCESS_DETACH:
\r
1754 #if defined(MAKE_EXE)
\r
1755 #include <stdio.h>
\r
1756 #include <fcntl.h>
\r
1759 main(int argc, char **argv)
\r
1761 char *fromcode = NULL;
\r
1762 char *tocode = NULL;
\r
1764 char inbuf[BUFSIZ];
\r
1765 char outbuf[BUFSIZ];
\r
1768 size_t inbytesleft;
\r
1769 size_t outbytesleft;
\r
1775 _setmode(_fileno(stdin), _O_BINARY);
\r
1776 _setmode(_fileno(stdout), _O_BINARY);
\r
1778 for (i = 1; i < argc; ++i)
\r
1780 if (strcmp(argv[i], "-l") == 0)
\r
1782 for (i = 0; codepage_alias[i].name != NULL; ++i)
\r
1783 printf("%s\n", codepage_alias[i].name);
\r
1787 if (strcmp(argv[i], "-f") == 0)
\r
1788 fromcode = argv[++i];
\r
1789 else if (strcmp(argv[i], "-t") == 0)
\r
1790 tocode = argv[++i];
\r
1793 in = fopen(argv[i], "rb");
\r
1796 fprintf(stderr, "cannot open %s\n", argv[i]);
\r
1803 if (fromcode == NULL || tocode == NULL)
\r
1805 printf("usage: %s -f from-enc -t to-enc [file]\n", argv[0]);
\r
1809 cd = iconv_open(tocode, fromcode);
\r
1810 if (cd == (iconv_t)(-1))
\r
1812 perror("iconv_open error");
\r
1816 while ((inbytesleft = fread(inbuf + rest, 1, sizeof(inbuf) - rest, in)) != 0
\r
1819 inbytesleft += rest;
\r
1822 outbytesleft = sizeof(outbuf);
\r
1823 r = iconv(cd, &pin, &inbytesleft, &pout, &outbytesleft);
\r
1824 fwrite(outbuf, 1, sizeof(outbuf) - outbytesleft, stdout);
\r
1825 if (r == (size_t)(-1) && errno != EINVAL && errno != E2BIG)
\r
1827 perror("conversion error");
\r
1830 memmove(inbuf, pin, inbytesleft);
\r
1831 rest = inbytesleft;
\r
1834 outbytesleft = sizeof(outbuf);
\r
1835 r = iconv(cd, NULL, NULL, &pout, &outbytesleft);
\r
1836 fwrite(outbuf, 1, sizeof(outbuf) - outbytesleft, stdout);
\r
1837 if (r == (size_t)(-1))
\r
1839 perror("conversion error");
\r