�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Flibmariadb%2F'>libmariadb</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Flibmariadb%2Fwin-iconv%2F'>win-iconv</a>/</p><hr><h3>✏️ Editing: win_iconv.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*
 * iconv implementation using Win32 API to convert.
 *
 * This file is placed in the public domain.
 */

/* for WC_NO_BEST_FIT_CHARS */
#ifndef WINVER
# define WINVER 0x0500
#endif

#define STRICT
#include &lt;windows.h&gt;
#include &lt;errno.h&gt;
#include &lt;string.h&gt;
#include &lt;stdlib.h&gt;

#ifdef __GNUC__
#define UNUSED __attribute__((unused))
#else
#define UNUSED
#endif

/* WORKAROUND: */
#ifndef UNDER_CE
#define GetProcAddressA GetProcAddress
#endif

#if 0
# define MAKE_EXE
# define MAKE_DLL
# define USE_LIBICONV_DLL
#endif

#if !defined(DEFAULT_LIBICONV_DLL)
# define DEFAULT_LIBICONV_DLL &quot;&quot;
#endif

#define MB_CHAR_MAX 16

#define UNICODE_MODE_BOM_DONE   1
#define UNICODE_MODE_SWAPPED    2

#define FLAG_USE_BOM            1
#define FLAG_TRANSLIT           2 /* //TRANSLIT */
#define FLAG_IGNORE             4 /* //IGNORE */

typedef unsigned char uchar;
typedef unsigned short ushort;
typedef unsigned int uint;

typedef void* iconv_t;

iconv_t iconv_open(const char *tocode, const char *fromcode);
int iconv_close(iconv_t cd);
size_t iconv(iconv_t cd, const char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);

/* libiconv interface for vim */
#if defined(MAKE_DLL)
int
iconvctl (iconv_t cd, int request, void* argument)
{
    /* not supported */
    return 0;
}
#endif

typedef struct compat_t compat_t;
typedef struct csconv_t csconv_t;
typedef struct rec_iconv_t rec_iconv_t;

typedef iconv_t (*f_iconv_open)(const char *tocode, const char *fromcode);
typedef int (*f_iconv_close)(iconv_t cd);
typedef size_t (*f_iconv)(iconv_t cd, const char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);
typedef int* (*f_errno)(void);
typedef int (*f_mbtowc)(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
typedef int (*f_wctomb)(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
typedef int (*f_mblen)(csconv_t *cv, const uchar *buf, int bufsize);
typedef int (*f_flush)(csconv_t *cv, uchar *buf, int bufsize);

#define COMPAT_IN   1
#define COMPAT_OUT  2

/* unicode mapping for compatibility with other conversion table. */
struct compat_t {
    uint in;
    uint out;
    uint flag;
};

struct csconv_t {
    int codepage;
    int flags;
    f_mbtowc mbtowc;
    f_wctomb wctomb;
    f_mblen mblen;
    f_flush flush;
    DWORD mode;
    compat_t *compat;
};

struct rec_iconv_t {
    iconv_t cd;
    f_iconv_close iconv_close;
    f_iconv iconv;
    f_errno _errno;
    csconv_t from;
    csconv_t to;
#if defined(USE_LIBICONV_DLL)
    HMODULE hlibiconv;
#endif
};

static int win_iconv_open(rec_iconv_t *cd, const char *tocode, const char *fromcode);
static int win_iconv_close(iconv_t cd);
static size_t win_iconv(iconv_t cd, const char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);

static int load_mlang(void);
static int make_csconv(const char *name, csconv_t *cv);
static int name_to_codepage(const char *name);
static uint utf16_to_ucs4(const ushort *wbuf);
static void ucs4_to_utf16(uint wc, ushort *wbuf, int *wbufsize);
static int mbtowc_flags(int codepage);
static int must_use_null_useddefaultchar(int codepage);
static char *strrstr(const char *str, const char *token);
static char *xstrndup(const char *s, size_t n);
static int seterror(int err);

#if defined(USE_LIBICONV_DLL)
static int libiconv_iconv_open(rec_iconv_t *cd, const char *tocode, const char *fromcode);
static PVOID MyImageDirectoryEntryToData(LPVOID Base, BOOLEAN MappedAsImage, USHORT DirectoryEntry, PULONG Size);
static HMODULE find_imported_module_by_funcname(HMODULE hModule, const char *funcname);

static HMODULE hwiniconv;
#endif

static int sbcs_mblen(csconv_t *cv, const uchar *buf, int bufsize);
static int dbcs_mblen(csconv_t *cv, const uchar *buf, int bufsize);
static int mbcs_mblen(csconv_t *cv, const uchar *buf, int bufsize);
static int utf8_mblen(csconv_t *cv, const uchar *buf, int bufsize);
static int eucjp_mblen(csconv_t *cv, const uchar *buf, int bufsize);

static int kernel_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
static int kernel_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
static int mlang_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
static int mlang_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
static int utf16_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
static int utf16_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
static int utf32_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
static int utf32_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
static int iso2022jp_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
static int iso2022jp_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
static int iso2022jp_flush(csconv_t *cv, uchar *buf, int bufsize);

static struct {
    int codepage;
    const char *name;
} codepage_alias[] = {
    {65001, &quot;CP65001&quot;},
    {65001, &quot;UTF8&quot;},
    {65001, &quot;UTF-8&quot;},

    {1200, &quot;CP1200&quot;},
    {1200, &quot;UTF16LE&quot;},
    {1200, &quot;UTF-16LE&quot;},
    {1200, &quot;UCS2LE&quot;},
    {1200, &quot;UCS-2LE&quot;},

    {1201, &quot;CP1201&quot;},
    {1201, &quot;UTF16BE&quot;},
    {1201, &quot;UTF-16BE&quot;},
    {1201, &quot;UCS2BE&quot;},
    {1201, &quot;UCS-2BE&quot;},
    {1201, &quot;unicodeFFFE&quot;},

    {12000, &quot;CP12000&quot;},
    {12000, &quot;UTF32LE&quot;},
    {12000, &quot;UTF-32LE&quot;},
    {12000, &quot;UCS4LE&quot;},
    {12000, &quot;UCS-4LE&quot;},

    {12001, &quot;CP12001&quot;},
    {12001, &quot;UTF32BE&quot;},
    {12001, &quot;UTF-32BE&quot;},
    {12001, &quot;UCS4BE&quot;},
    {12001, &quot;UCS-4BE&quot;},

#ifndef GLIB_COMPILATION
    /*
     * Default is big endian.
     * See rfc2781 4.3 Interpreting text labelled as UTF-16.
     */
    {1201, &quot;UTF16&quot;},
    {1201, &quot;UTF-16&quot;},
    {1201, &quot;UCS2&quot;},
    {1201, &quot;UCS-2&quot;},
    {12001, &quot;UTF32&quot;},
    {12001, &quot;UTF-32&quot;},
    {12001, &quot;UCS-4&quot;},
    {12001, &quot;UCS4&quot;},
#else
    /* Default is little endian, because the platform is */
    {1200, &quot;UTF16&quot;},
    {1200, &quot;UTF-16&quot;},
    {1200, &quot;UCS2&quot;},
    {1200, &quot;UCS-2&quot;},
    {12000, &quot;UTF32&quot;},
    {12000, &quot;UTF-32&quot;},
    {12000, &quot;UCS4&quot;},
    {12000, &quot;UCS-4&quot;},
#endif

    /* copy from libiconv `iconv -l` */
    /* !IsValidCodePage(367) */
    {20127, &quot;ANSI_X3.4-1968&quot;},
    {20127, &quot;ANSI_X3.4-1986&quot;},
    {20127, &quot;ASCII&quot;},
    {20127, &quot;CP367&quot;},
    {20127, &quot;IBM367&quot;},
    {20127, &quot;ISO-IR-6&quot;},
    {20127, &quot;ISO646-US&quot;},
    {20127, &quot;ISO_646.IRV:1991&quot;},
    {20127, &quot;US&quot;},
    {20127, &quot;US-ASCII&quot;},
    {20127, &quot;CSASCII&quot;},

    /* !IsValidCodePage(819) */
    {1252, &quot;CP819&quot;},
    {1252, &quot;IBM819&quot;},
    {28591, &quot;ISO-8859-1&quot;},
    {28591, &quot;ISO-IR-100&quot;},
    {28591, &quot;ISO8859-1&quot;},
    {28591, &quot;ISO_8859-1&quot;},
    {28591, &quot;ISO_8859-1:1987&quot;},
    {28591, &quot;L1&quot;},
    {28591, &quot;LATIN1&quot;},
    {28591, &quot;CSISOLATIN1&quot;},

    {1250, &quot;CP1250&quot;},
    {1250, &quot;MS-EE&quot;},
    {1250, &quot;WINDOWS-1250&quot;},

    {1251, &quot;CP1251&quot;},
    {1251, &quot;MS-CYRL&quot;},
    {1251, &quot;WINDOWS-1251&quot;},

    {1252, &quot;CP1252&quot;},
    {1252, &quot;MS-ANSI&quot;},
    {1252, &quot;WINDOWS-1252&quot;},

    {1253, &quot;CP1253&quot;},
    {1253, &quot;MS-GREEK&quot;},
    {1253, &quot;WINDOWS-1253&quot;},

    {1254, &quot;CP1254&quot;},
    {1254, &quot;MS-TURK&quot;},
    {1254, &quot;WINDOWS-1254&quot;},

    {1255, &quot;CP1255&quot;},
    {1255, &quot;MS-HEBR&quot;},
    {1255, &quot;WINDOWS-1255&quot;},

    {1256, &quot;CP1256&quot;},
    {1256, &quot;MS-ARAB&quot;},
    {1256, &quot;WINDOWS-1256&quot;},

    {1257, &quot;CP1257&quot;},
    {1257, &quot;WINBALTRIM&quot;},
    {1257, &quot;WINDOWS-1257&quot;},

    {1258, &quot;CP1258&quot;},
    {1258, &quot;WINDOWS-1258&quot;},

    {850, &quot;850&quot;},
    {850, &quot;CP850&quot;},
    {850, &quot;IBM850&quot;},
    {850, &quot;CSPC850MULTILINGUAL&quot;},

    /* !IsValidCodePage(862) */
    {862, &quot;862&quot;},
    {862, &quot;CP862&quot;},
    {862, &quot;IBM862&quot;},
    {862, &quot;CSPC862LATINHEBREW&quot;},

    {866, &quot;866&quot;},
    {866, &quot;CP866&quot;},
    {866, &quot;IBM866&quot;},
    {866, &quot;CSIBM866&quot;},

    /* !IsValidCodePage(154) */
    {154, &quot;CP154&quot;},
    {154, &quot;CYRILLIC-ASIAN&quot;},
    {154, &quot;PT154&quot;},
    {154, &quot;PTCP154&quot;},
    {154, &quot;CSPTCP154&quot;},

    /* !IsValidCodePage(1133) */
    {1133, &quot;CP1133&quot;},
    {1133, &quot;IBM-CP1133&quot;},

    {874, &quot;CP874&quot;},
    {874, &quot;WINDOWS-874&quot;},

    /* !IsValidCodePage(51932) */
    {51932, &quot;CP51932&quot;},
    {51932, &quot;MS51932&quot;},
    {51932, &quot;WINDOWS-51932&quot;},
    {51932, &quot;EUC-JP&quot;},

    {932, &quot;CP932&quot;},
    {932, &quot;MS932&quot;},
    {932, &quot;SHIFFT_JIS&quot;},
    {932, &quot;SHIFFT_JIS-MS&quot;},
    {932, &quot;SJIS&quot;},
    {932, &quot;SJIS-MS&quot;},
    {932, &quot;SJIS-OPEN&quot;},
    {932, &quot;SJIS-WIN&quot;},
    {932, &quot;WINDOWS-31J&quot;},
    {932, &quot;WINDOWS-932&quot;},
    {932, &quot;CSWINDOWS31J&quot;},

    {50221, &quot;CP50221&quot;},
    {50221, &quot;ISO-2022-JP&quot;},
    {50221, &quot;ISO-2022-JP-MS&quot;},
    {50221, &quot;ISO2022-JP&quot;},
    {50221, &quot;ISO2022-JP-MS&quot;},
    {50221, &quot;MS50221&quot;},
    {50221, &quot;WINDOWS-50221&quot;},

    {936, &quot;CP936&quot;},
    {936, &quot;GBK&quot;},
    {936, &quot;MS936&quot;},
    {936, &quot;WINDOWS-936&quot;},

    {950, &quot;CP950&quot;},
    {950, &quot;BIG5&quot;},
    {950, &quot;BIG5HKSCS&quot;},
    {950, &quot;BIG5-HKSCS&quot;},

    {949, &quot;CP949&quot;},
    {949, &quot;UHC&quot;},
    {949, &quot;EUC-KR&quot;},

    {1361, &quot;CP1361&quot;},
    {1361, &quot;JOHAB&quot;},

    {437, &quot;437&quot;},
    {437, &quot;CP437&quot;},
    {437, &quot;IBM437&quot;},
    {437, &quot;CSPC8CODEPAGE437&quot;},

    {737, &quot;CP737&quot;},

    {775, &quot;CP775&quot;},
    {775, &quot;IBM775&quot;},
    {775, &quot;CSPC775BALTIC&quot;},

    {852, &quot;852&quot;},
    {852, &quot;CP852&quot;},
    {852, &quot;IBM852&quot;},
    {852, &quot;CSPCP852&quot;},

    /* !IsValidCodePage(853) */
    {853, &quot;CP853&quot;},

    {855, &quot;855&quot;},
    {855, &quot;CP855&quot;},
    {855, &quot;IBM855&quot;},
    {855, &quot;CSIBM855&quot;},

    {857, &quot;857&quot;},
    {857, &quot;CP857&quot;},
    {857, &quot;IBM857&quot;},
    {857, &quot;CSIBM857&quot;},

    /* !IsValidCodePage(858) */
    {858, &quot;CP858&quot;},

    {860, &quot;860&quot;},
    {860, &quot;CP860&quot;},
    {860, &quot;IBM860&quot;},
    {860, &quot;CSIBM860&quot;},

    {861, &quot;861&quot;},
    {861, &quot;CP-IS&quot;},
    {861, &quot;CP861&quot;},
    {861, &quot;IBM861&quot;},
    {861, &quot;CSIBM861&quot;},

    {863, &quot;863&quot;},
    {863, &quot;CP863&quot;},
    {863, &quot;IBM863&quot;},
    {863, &quot;CSIBM863&quot;},

    {864, &quot;CP864&quot;},
    {864, &quot;IBM864&quot;},
    {864, &quot;CSIBM864&quot;},

    {865, &quot;865&quot;},
    {865, &quot;CP865&quot;},
    {865, &quot;IBM865&quot;},
    {865, &quot;CSIBM865&quot;},

    {869, &quot;869&quot;},
    {869, &quot;CP-GR&quot;},
    {869, &quot;CP869&quot;},
    {869, &quot;IBM869&quot;},
    {869, &quot;CSIBM869&quot;},

    /* !IsValidCodePage(1152) */
    {1125, &quot;CP1125&quot;},

    /*
     * Code Page Identifiers
     * http://msdn2.microsoft.com/en-us/library/ms776446.aspx
     */
    {37, &quot;IBM037&quot;}, /* IBM EBCDIC US-Canada */
    {437, &quot;IBM437&quot;}, /* OEM United States */
    {500, &quot;IBM500&quot;}, /* IBM EBCDIC International */
    {708, &quot;ASMO-708&quot;}, /* Arabic (ASMO 708) */
    /* 709 		Arabic (ASMO-449+, BCON V4) */
    /* 710 		Arabic - Transparent Arabic */
    {720, &quot;DOS-720&quot;}, /* Arabic (Transparent ASMO); Arabic (DOS) */
    {737, &quot;ibm737&quot;}, /* OEM Greek (formerly 437G); Greek (DOS) */
    {775, &quot;ibm775&quot;}, /* OEM Baltic; Baltic (DOS) */
    {850, &quot;ibm850&quot;}, /* OEM Multilingual Latin 1; Western European (DOS) */
    {852, &quot;ibm852&quot;}, /* OEM Latin 2; Central European (DOS) */
    {855, &quot;IBM855&quot;}, /* OEM Cyrillic (primarily Russian) */
    {857, &quot;ibm857&quot;}, /* OEM Turkish; Turkish (DOS) */
    {858, &quot;IBM00858&quot;}, /* OEM Multilingual Latin 1 + Euro symbol */
    {860, &quot;IBM860&quot;}, /* OEM Portuguese; Portuguese (DOS) */
    {861, &quot;ibm861&quot;}, /* OEM Icelandic; Icelandic (DOS) */
    {862, &quot;DOS-862&quot;}, /* OEM Hebrew; Hebrew (DOS) */
    {863, &quot;IBM863&quot;}, /* OEM French Canadian; French Canadian (DOS) */
    {864, &quot;IBM864&quot;}, /* OEM Arabic; Arabic (864) */
    {865, &quot;IBM865&quot;}, /* OEM Nordic; Nordic (DOS) */
    {866, &quot;cp866&quot;}, /* OEM Russian; Cyrillic (DOS) */
    {869, &quot;ibm869&quot;}, /* OEM Modern Greek; Greek, Modern (DOS) */
    {870, &quot;IBM870&quot;}, /* IBM EBCDIC Multilingual/ROECE (Latin 2); IBM EBCDIC Multilingual Latin 2 */
    {874, &quot;windows-874&quot;}, /* ANSI/OEM Thai (same as 28605, ISO 8859-15); Thai (Windows) */
    {875, &quot;cp875&quot;}, /* IBM EBCDIC Greek Modern */
    {932, &quot;shift_jis&quot;}, /* ANSI/OEM Japanese; Japanese (Shift-JIS) */
    {932, &quot;shift-jis&quot;}, /* alternative name for it */
    {936, &quot;gb2312&quot;}, /* ANSI/OEM Simplified Chinese (PRC, Singapore); Chinese Simplified (GB2312) */
    {949, &quot;ks_c_5601-1987&quot;}, /* ANSI/OEM Korean (Unified Hangul Code) */
    {950, &quot;big5&quot;}, /* ANSI/OEM Traditional Chinese (Taiwan; Hong Kong SAR, PRC); Chinese Traditional (Big5) */
    {950, &quot;big5hkscs&quot;}, /* ANSI/OEM Traditional Chinese (Hong Kong SAR); Chinese Traditional (Big5-HKSCS) */
    {950, &quot;big5-hkscs&quot;}, /* alternative name for it */
    {1026, &quot;IBM1026&quot;}, /* IBM EBCDIC Turkish (Latin 5) */
    {1047, &quot;IBM01047&quot;}, /* IBM EBCDIC Latin 1/Open System */
    {1140, &quot;IBM01140&quot;}, /* IBM EBCDIC US-Canada (037 + Euro symbol); IBM EBCDIC (US-Canada-Euro) */
    {1141, &quot;IBM01141&quot;}, /* IBM EBCDIC Germany (20273 + Euro symbol); IBM EBCDIC (Germany-Euro) */
    {1142, &quot;IBM01142&quot;}, /* IBM EBCDIC Denmark-Norway (20277 + Euro symbol); IBM EBCDIC (Denmark-Norway-Euro) */
    {1143, &quot;IBM01143&quot;}, /* IBM EBCDIC Finland-Sweden (20278 + Euro symbol); IBM EBCDIC (Finland-Sweden-Euro) */
    {1144, &quot;IBM01144&quot;}, /* IBM EBCDIC Italy (20280 + Euro symbol); IBM EBCDIC (Italy-Euro) */
    {1145, &quot;IBM01145&quot;}, /* IBM EBCDIC Latin America-Spain (20284 + Euro symbol); IBM EBCDIC (Spain-Euro) */
    {1146, &quot;IBM01146&quot;}, /* IBM EBCDIC United Kingdom (20285 + Euro symbol); IBM EBCDIC (UK-Euro) */
    {1147, &quot;IBM01147&quot;}, /* IBM EBCDIC France (20297 + Euro symbol); IBM EBCDIC (France-Euro) */
    {1148, &quot;IBM01148&quot;}, /* IBM EBCDIC International (500 + Euro symbol); IBM EBCDIC (International-Euro) */
    {1149, &quot;IBM01149&quot;}, /* IBM EBCDIC Icelandic (20871 + Euro symbol); IBM EBCDIC (Icelandic-Euro) */
    {1250, &quot;windows-1250&quot;}, /* ANSI Central European; Central European (Windows) */
    {1251, &quot;windows-1251&quot;}, /* ANSI Cyrillic; Cyrillic (Windows) */
    {1252, &quot;windows-1252&quot;}, /* ANSI Latin 1; Western European (Windows) */
    {1253, &quot;windows-1253&quot;}, /* ANSI Greek; Greek (Windows) */
    {1254, &quot;windows-1254&quot;}, /* ANSI Turkish; Turkish (Windows) */
    {1255, &quot;windows-1255&quot;}, /* ANSI Hebrew; Hebrew (Windows) */
    {1256, &quot;windows-1256&quot;}, /* ANSI Arabic; Arabic (Windows) */
    {1257, &quot;windows-1257&quot;}, /* ANSI Baltic; Baltic (Windows) */
    {1258, &quot;windows-1258&quot;}, /* ANSI/OEM Vietnamese; Vietnamese (Windows) */
    {1361, &quot;Johab&quot;}, /* Korean (Johab) */
    {10000, &quot;macintosh&quot;}, /* MAC Roman; Western European (Mac) */
    {10001, &quot;x-mac-japanese&quot;}, /* Japanese (Mac) */
    {10002, &quot;x-mac-chinesetrad&quot;}, /* MAC Traditional Chinese (Big5); Chinese Traditional (Mac) */
    {10003, &quot;x-mac-korean&quot;}, /* Korean (Mac) */
    {10004, &quot;x-mac-arabic&quot;}, /* Arabic (Mac) */
    {10005, &quot;x-mac-hebrew&quot;}, /* Hebrew (Mac) */
    {10006, &quot;x-mac-greek&quot;}, /* Greek (Mac) */
    {10007, &quot;x-mac-cyrillic&quot;}, /* Cyrillic (Mac) */
    {10008, &quot;x-mac-chinesesimp&quot;}, /* MAC Simplified Chinese (GB 2312); Chinese Simplified (Mac) */
    {10010, &quot;x-mac-romanian&quot;}, /* Romanian (Mac) */
    {10017, &quot;x-mac-ukrainian&quot;}, /* Ukrainian (Mac) */
    {10021, &quot;x-mac-thai&quot;}, /* Thai (Mac) */
    {10029, &quot;x-mac-ce&quot;}, /* MAC Latin 2; Central European (Mac) */
    {10079, &quot;x-mac-icelandic&quot;}, /* Icelandic (Mac) */
    {10081, &quot;x-mac-turkish&quot;}, /* Turkish (Mac) */
    {10082, &quot;x-mac-croatian&quot;}, /* Croatian (Mac) */
    {20000, &quot;x-Chinese_CNS&quot;}, /* CNS Taiwan; Chinese Traditional (CNS) */
    {20001, &quot;x-cp20001&quot;}, /* TCA Taiwan */
    {20002, &quot;x_Chinese-Eten&quot;}, /* Eten Taiwan; Chinese Traditional (Eten) */
    {20003, &quot;x-cp20003&quot;}, /* IBM5550 Taiwan */
    {20004, &quot;x-cp20004&quot;}, /* TeleText Taiwan */
    {20005, &quot;x-cp20005&quot;}, /* Wang Taiwan */
    {20105, &quot;x-IA5&quot;}, /* IA5 (IRV International Alphabet No. 5, 7-bit); Western European (IA5) */
    {20106, &quot;x-IA5-German&quot;}, /* IA5 German (7-bit) */
    {20107, &quot;x-IA5-Swedish&quot;}, /* IA5 Swedish (7-bit) */
    {20108, &quot;x-IA5-Norwegian&quot;}, /* IA5 Norwegian (7-bit) */
    {20127, &quot;us-ascii&quot;}, /* US-ASCII (7-bit) */
    {20261, &quot;x-cp20261&quot;}, /* T.61 */
    {20269, &quot;x-cp20269&quot;}, /* ISO 6937 Non-Spacing Accent */
    {20273, &quot;IBM273&quot;}, /* IBM EBCDIC Germany */
    {20277, &quot;IBM277&quot;}, /* IBM EBCDIC Denmark-Norway */
    {20278, &quot;IBM278&quot;}, /* IBM EBCDIC Finland-Sweden */
    {20280, &quot;IBM280&quot;}, /* IBM EBCDIC Italy */
    {20284, &quot;IBM284&quot;}, /* IBM EBCDIC Latin America-Spain */
    {20285, &quot;IBM285&quot;}, /* IBM EBCDIC United Kingdom */
    {20290, &quot;IBM290&quot;}, /* IBM EBCDIC Japanese Katakana Extended */
    {20297, &quot;IBM297&quot;}, /* IBM EBCDIC France */
    {20420, &quot;IBM420&quot;}, /* IBM EBCDIC Arabic */
    {20423, &quot;IBM423&quot;}, /* IBM EBCDIC Greek */
    {20424, &quot;IBM424&quot;}, /* IBM EBCDIC Hebrew */
    {20833, &quot;x-EBCDIC-KoreanExtended&quot;}, /* IBM EBCDIC Korean Extended */
    {20838, &quot;IBM-Thai&quot;}, /* IBM EBCDIC Thai */
    {20866, &quot;koi8-r&quot;}, /* Russian (KOI8-R); Cyrillic (KOI8-R) */
    {20871, &quot;IBM871&quot;}, /* IBM EBCDIC Icelandic */
    {20880, &quot;IBM880&quot;}, /* IBM EBCDIC Cyrillic Russian */
    {20905, &quot;IBM905&quot;}, /* IBM EBCDIC Turkish */
    {20924, &quot;IBM00924&quot;}, /* IBM EBCDIC Latin 1/Open System (1047 + Euro symbol) */
    {20932, &quot;EUC-JP&quot;}, /* Japanese (JIS 0208-1990 and 0121-1990) */
    {20936, &quot;x-cp20936&quot;}, /* Simplified Chinese (GB2312); Chinese Simplified (GB2312-80) */
    {20949, &quot;x-cp20949&quot;}, /* Korean Wansung */
    {21025, &quot;cp1025&quot;}, /* IBM EBCDIC Cyrillic Serbian-Bulgarian */
    /* 21027 		(deprecated) */
    {21866, &quot;koi8-u&quot;}, /* Ukrainian (KOI8-U); Cyrillic (KOI8-U) */
    {28591, &quot;iso-8859-1&quot;}, /* ISO 8859-1 Latin 1; Western European (ISO) */
    {28591, &quot;iso8859-1&quot;}, /* ISO 8859-1 Latin 1; Western European (ISO) */
    {28592, &quot;iso-8859-2&quot;}, /* ISO 8859-2 Central European; Central European (ISO) */
    {28592, &quot;iso8859-2&quot;}, /* ISO 8859-2 Central European; Central European (ISO) */
    {28593, &quot;iso-8859-3&quot;}, /* ISO 8859-3 Latin 3 */
    {28593, &quot;iso8859-3&quot;}, /* ISO 8859-3 Latin 3 */
    {28594, &quot;iso-8859-4&quot;}, /* ISO 8859-4 Baltic */
    {28594, &quot;iso8859-4&quot;}, /* ISO 8859-4 Baltic */
    {28595, &quot;iso-8859-5&quot;}, /* ISO 8859-5 Cyrillic */
    {28595, &quot;iso8859-5&quot;}, /* ISO 8859-5 Cyrillic */
    {28596, &quot;iso-8859-6&quot;}, /* ISO 8859-6 Arabic */
    {28596, &quot;iso8859-6&quot;}, /* ISO 8859-6 Arabic */
    {28597, &quot;iso-8859-7&quot;}, /* ISO 8859-7 Greek */
    {28597, &quot;iso8859-7&quot;}, /* ISO 8859-7 Greek */
    {28598, &quot;iso-8859-8&quot;}, /* ISO 8859-8 Hebrew; Hebrew (ISO-Visual) */
    {28598, &quot;iso8859-8&quot;}, /* ISO 8859-8 Hebrew; Hebrew (ISO-Visual) */
    {28599, &quot;iso-8859-9&quot;}, /* ISO 8859-9 Turkish */
    {28599, &quot;iso8859-9&quot;}, /* ISO 8859-9 Turkish */
    {28603, &quot;iso-8859-13&quot;}, /* ISO 8859-13 Estonian */
    {28603, &quot;iso8859-13&quot;}, /* ISO 8859-13 Estonian */
    {28605, &quot;iso-8859-15&quot;}, /* ISO 8859-15 Latin 9 */
    {28605, &quot;iso8859-15&quot;}, /* ISO 8859-15 Latin 9 */
    {29001, &quot;x-Europa&quot;}, /* Europa 3 */
    {38598, &quot;iso-8859-8-i&quot;}, /* ISO 8859-8 Hebrew; Hebrew (ISO-Logical) */
    {38598, &quot;iso8859-8-i&quot;}, /* ISO 8859-8 Hebrew; Hebrew (ISO-Logical) */
    {50220, &quot;iso-2022-jp&quot;}, /* ISO 2022 Japanese with no halfwidth Katakana; Japanese (JIS) */
    {50221, &quot;csISO2022JP&quot;}, /* ISO 2022 Japanese with halfwidth Katakana; Japanese (JIS-Allow 1 byte Kana) */
    {50222, &quot;iso-2022-jp&quot;}, /* ISO 2022 Japanese JIS X 0201-1989; Japanese (JIS-Allow 1 byte Kana - SO/SI) */
    {50225, &quot;iso-2022-kr&quot;}, /* ISO 2022 Korean */
    {50225, &quot;iso2022-kr&quot;}, /* ISO 2022 Korean */
    {50227, &quot;x-cp50227&quot;}, /* ISO 2022 Simplified Chinese; Chinese Simplified (ISO 2022) */
    /* 50229 		ISO 2022 Traditional Chinese */
    /* 50930 		EBCDIC Japanese (Katakana) Extended */
    /* 50931 		EBCDIC US-Canada and Japanese */
    /* 50933 		EBCDIC Korean Extended and Korean */
    /* 50935 		EBCDIC Simplified Chinese Extended and Simplified Chinese */
    /* 50936 		EBCDIC Simplified Chinese */
    /* 50937 		EBCDIC US-Canada and Traditional Chinese */
    /* 50939 		EBCDIC Japanese (Latin) Extended and Japanese */
    {51932, &quot;euc-jp&quot;}, /* EUC Japanese */
    {51936, &quot;EUC-CN&quot;}, /* EUC Simplified Chinese; Chinese Simplified (EUC) */
    {51949, &quot;euc-kr&quot;}, /* EUC Korean */
    /* 51950 		EUC Traditional Chinese */
    {52936, &quot;hz-gb-2312&quot;}, /* HZ-GB2312 Simplified Chinese; Chinese Simplified (HZ) */
    {54936, &quot;GB18030&quot;}, /* Windows XP and later: GB18030 Simplified Chinese (4 byte); Chinese Simplified (GB18030) */
    {57002, &quot;x-iscii-de&quot;}, /* ISCII Devanagari */
    {57003, &quot;x-iscii-be&quot;}, /* ISCII Bengali */
    {57004, &quot;x-iscii-ta&quot;}, /* ISCII Tamil */
    {57005, &quot;x-iscii-te&quot;}, /* ISCII Telugu */
    {57006, &quot;x-iscii-as&quot;}, /* ISCII Assamese */
    {57007, &quot;x-iscii-or&quot;}, /* ISCII Oriya */
    {57008, &quot;x-iscii-ka&quot;}, /* ISCII Kannada */
    {57009, &quot;x-iscii-ma&quot;}, /* ISCII Malayalam */
    {57010, &quot;x-iscii-gu&quot;}, /* ISCII Gujarati */
    {57011, &quot;x-iscii-pa&quot;}, /* ISCII Punjabi */

    {0, NULL}
};

/*
 * SJIS SHIFTJIS table              CP932 table
 * ---- --------------------------- --------------------------------
 *   5C U+00A5 YEN SIGN             U+005C REVERSE SOLIDUS
 *   7E U+203E OVERLINE             U+007E TILDE
 * 815C U+2014 EM DASH              U+2015 HORIZONTAL BAR
 * 815F U+005C REVERSE SOLIDUS      U+FF3C FULLWIDTH REVERSE SOLIDUS
 * 8160 U+301C WAVE DASH            U+FF5E FULLWIDTH TILDE
 * 8161 U+2016 DOUBLE VERTICAL LINE U+2225 PARALLEL TO
 * 817C U+2212 MINUS SIGN           U+FF0D FULLWIDTH HYPHEN-MINUS
 * 8191 U+00A2 CENT SIGN            U+FFE0 FULLWIDTH CENT SIGN
 * 8192 U+00A3 POUND SIGN           U+FFE1 FULLWIDTH POUND SIGN
 * 81CA U+00AC NOT SIGN             U+FFE2 FULLWIDTH NOT SIGN
 *
 * EUC-JP and ISO-2022-JP should be compatible with CP932.
 *
 * Kernel and MLang have different Unicode mapping table.  Make sure
 * which API is used.
 */
static compat_t cp932_compat[] = {
    {0x00A5, 0x005C, COMPAT_OUT},
    {0x203E, 0x007E, COMPAT_OUT},
    {0x2014, 0x2015, COMPAT_OUT},
    {0x301C, 0xFF5E, COMPAT_OUT},
    {0x2016, 0x2225, COMPAT_OUT},
    {0x2212, 0xFF0D, COMPAT_OUT},
    {0x00A2, 0xFFE0, COMPAT_OUT},
    {0x00A3, 0xFFE1, COMPAT_OUT},
    {0x00AC, 0xFFE2, COMPAT_OUT},
    {0, 0, 0}
};

static compat_t cp20932_compat[] = {
    {0x00A5, 0x005C, COMPAT_OUT},
    {0x203E, 0x007E, COMPAT_OUT},
    {0x2014, 0x2015, COMPAT_OUT},
    {0xFF5E, 0x301C, COMPAT_OUT|COMPAT_IN},
    {0x2225, 0x2016, COMPAT_OUT|COMPAT_IN},
    {0xFF0D, 0x2212, COMPAT_OUT|COMPAT_IN},
    {0xFFE0, 0x00A2, COMPAT_OUT|COMPAT_IN},
    {0xFFE1, 0x00A3, COMPAT_OUT|COMPAT_IN},
    {0xFFE2, 0x00AC, COMPAT_OUT|COMPAT_IN},
    {0, 0, 0}
};

static compat_t *cp51932_compat = cp932_compat;

/* cp20932_compat for kernel.  cp932_compat for mlang. */
static compat_t *cp5022x_compat = cp932_compat;

typedef HRESULT (WINAPI *CONVERTINETSTRING)(
    LPDWORD lpdwMode,
    DWORD dwSrcEncoding,
    DWORD dwDstEncoding,
    LPCSTR lpSrcStr,
    LPINT lpnSrcSize,
    LPBYTE lpDstStr,
    LPINT lpnDstSize
);
typedef HRESULT (WINAPI *CONVERTINETMULTIBYTETOUNICODE)(
    LPDWORD lpdwMode,
    DWORD dwSrcEncoding,
    LPCSTR lpSrcStr,
    LPINT lpnMultiCharCount,
    LPWSTR lpDstStr,
    LPINT lpnWideCharCount
);
typedef HRESULT (WINAPI *CONVERTINETUNICODETOMULTIBYTE)(
    LPDWORD lpdwMode,
    DWORD dwEncoding,
    LPCWSTR lpSrcStr,
    LPINT lpnWideCharCount,
    LPSTR lpDstStr,
    LPINT lpnMultiCharCount
);
typedef HRESULT (WINAPI *ISCONVERTINETSTRINGAVAILABLE)(
    DWORD dwSrcEncoding,
    DWORD dwDstEncoding
);
typedef HRESULT (WINAPI *LCIDTORFC1766A)(
    LCID Locale,
    LPSTR pszRfc1766,
    int nChar
);
typedef HRESULT (WINAPI *LCIDTORFC1766W)(
    LCID Locale,
    LPWSTR pszRfc1766,
    int nChar
);
typedef HRESULT (WINAPI *RFC1766TOLCIDA)(
    LCID *pLocale,
    LPSTR pszRfc1766
);
typedef HRESULT (WINAPI *RFC1766TOLCIDW)(
    LCID *pLocale,
    LPWSTR pszRfc1766
);
static CONVERTINETSTRING ConvertINetString;
static CONVERTINETMULTIBYTETOUNICODE ConvertINetMultiByteToUnicode;
static CONVERTINETUNICODETOMULTIBYTE ConvertINetUnicodeToMultiByte;
static ISCONVERTINETSTRINGAVAILABLE IsConvertINetStringAvailable;
static LCIDTORFC1766A LcidToRfc1766A;
static RFC1766TOLCIDA Rfc1766ToLcidA;

static int
load_mlang(void)
{
    HMODULE h;
    if (ConvertINetString != NULL)
        return TRUE;
    h = LoadLibrary(TEXT(&quot;mlang.dll&quot;));
    if (!h)
        return FALSE;
    ConvertINetString = (CONVERTINETSTRING)GetProcAddressA(h, &quot;ConvertINetString&quot;);
    ConvertINetMultiByteToUnicode = (CONVERTINETMULTIBYTETOUNICODE)GetProcAddressA(h, &quot;ConvertINetMultiByteToUnicode&quot;);
    ConvertINetUnicodeToMultiByte = (CONVERTINETUNICODETOMULTIBYTE)GetProcAddressA(h, &quot;ConvertINetUnicodeToMultiByte&quot;);
    IsConvertINetStringAvailable = (ISCONVERTINETSTRINGAVAILABLE)GetProcAddressA(h, &quot;IsConvertINetStringAvailable&quot;);
    LcidToRfc1766A = (LCIDTORFC1766A)GetProcAddressA(h, &quot;LcidToRfc1766A&quot;);
    Rfc1766ToLcidA = (RFC1766TOLCIDA)GetProcAddressA(h, &quot;Rfc1766ToLcidA&quot;);
    return TRUE;
}

iconv_t
iconv_open(const char *tocode, const char *fromcode)
{
    rec_iconv_t *cd;

    cd = (rec_iconv_t *)calloc(1, sizeof(rec_iconv_t));
    if (cd == NULL)
        return (iconv_t)(-1);

#if defined(USE_LIBICONV_DLL)
    errno = 0;
    if (libiconv_iconv_open(cd, tocode, fromcode))
        return (iconv_t)cd;
#endif

    /* reset the errno to prevent reporting wrong error code.
     * 0 for unsorted error. */
    errno = 0;
    if (win_iconv_open(cd, tocode, fromcode))
        return (iconv_t)cd;

    free(cd);

    return (iconv_t)(-1);
}

int
iconv_close(iconv_t _cd)
{
    rec_iconv_t *cd = (rec_iconv_t *)_cd;
    int r = cd-&gt;iconv_close(cd-&gt;cd);
    int e = *(cd-&gt;_errno());
#if defined(USE_LIBICONV_DLL)
    if (cd-&gt;hlibiconv != NULL)
        FreeLibrary(cd-&gt;hlibiconv);
#endif
    free(cd);
    errno = e;
    return r;
}

size_t
iconv(iconv_t _cd, const char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft)
{
    rec_iconv_t *cd = (rec_iconv_t *)_cd;
    size_t r = cd-&gt;iconv(cd-&gt;cd, inbuf, inbytesleft, outbuf, outbytesleft);
    errno = *(cd-&gt;_errno());
    return r;
}

static int
win_iconv_open(rec_iconv_t *cd, const char *tocode, const char *fromcode)
{
    if (!make_csconv(fromcode, &amp;cd-&gt;from) || !make_csconv(tocode, &amp;cd-&gt;to))
        return FALSE;
    cd-&gt;iconv_close = win_iconv_close;
    cd-&gt;iconv = win_iconv;
    cd-&gt;_errno = _errno;
    cd-&gt;cd = (iconv_t)cd;
    return TRUE;
}

static int
win_iconv_close(iconv_t cd UNUSED)
{
    return 0;
}

static size_t
win_iconv(iconv_t _cd, const char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft)
{
    rec_iconv_t *cd = (rec_iconv_t *)_cd;
    ushort wbuf[MB_CHAR_MAX]; /* enough room for one character */
    int insize;
    int outsize;
    int wsize;
    DWORD frommode;
    DWORD tomode;
    uint wc;
    compat_t *cp;
    int i;

    if (inbuf == NULL || *inbuf == NULL)
    {
        if (outbuf != NULL &amp;&amp; *outbuf != NULL &amp;&amp; cd-&gt;to.flush != NULL)
        {
            tomode = cd-&gt;to.mode;
            outsize = cd-&gt;to.flush(&amp;cd-&gt;to, (uchar *)*outbuf, (int)*outbytesleft);
            if (outsize == -1)
            {
                if ((cd-&gt;to.flags &amp; FLAG_IGNORE) &amp;&amp; errno != E2BIG)
                {
                    outsize = 0;
                }
                else
                {
                    cd-&gt;to.mode = tomode;
                    return (size_t)(-1);
                }
            }
            *outbuf += outsize;
            *outbytesleft -= outsize;
        }
        cd-&gt;from.mode = 0;
        cd-&gt;to.mode = 0;
        return 0;
    }

    while (*inbytesleft != 0)
    {
        frommode = cd-&gt;from.mode;
        tomode = cd-&gt;to.mode;
        wsize = MB_CHAR_MAX;

        insize = cd-&gt;from.mbtowc(&amp;cd-&gt;from, (const uchar *)*inbuf, (int)*inbytesleft, wbuf, &amp;wsize);
        if (insize == -1)
        {
            if (cd-&gt;to.flags &amp; FLAG_IGNORE)
            {
                cd-&gt;from.mode = frommode;
                insize = 1;
                wsize = 0;
            }
            else
            {
                cd-&gt;from.mode = frommode;
                return (size_t)(-1);
            }
        }

        if (wsize == 0)
        {
            *inbuf += insize;
            *inbytesleft -= insize;
            continue;
        }

        if (cd-&gt;from.compat != NULL)
        {
            wc = utf16_to_ucs4(wbuf);
            cp = cd-&gt;from.compat;
            for (i = 0; cp[i].in != 0; ++i)
            {
                if ((cp[i].flag &amp; COMPAT_IN) &amp;&amp; cp[i].out == wc)
                {
                    ucs4_to_utf16(cp[i].in, wbuf, &amp;wsize);
                    break;
                }
            }
        }

        if (cd-&gt;to.compat != NULL)
        {
            wc = utf16_to_ucs4(wbuf);
            cp = cd-&gt;to.compat;
            for (i = 0; cp[i].in != 0; ++i)
            {
                if ((cp[i].flag &amp; COMPAT_OUT) &amp;&amp; cp[i].in == wc)
                {
                    ucs4_to_utf16(cp[i].out, wbuf, &amp;wsize);
                    break;
                }
            }
        }

        outsize = cd-&gt;to.wctomb(&amp;cd-&gt;to, wbuf, wsize, (uchar *)*outbuf, (int)*outbytesleft);
        if (outsize == -1)
        {
            if ((cd-&gt;to.flags &amp; FLAG_IGNORE) &amp;&amp; errno != E2BIG)
            {
                cd-&gt;to.mode = tomode;
                outsize = 0;
            }
            else
            {
                cd-&gt;from.mode = frommode;
                cd-&gt;to.mode = tomode;
                return (size_t)(-1);
            }
        }

        *inbuf += insize;
        *outbuf += outsize;
        *inbytesleft -= insize;
        *outbytesleft -= outsize;
    }

    return 0;
}

static int
make_csconv(const char *_name, csconv_t *cv)
{
    CPINFO cpinfo;
    int use_compat = TRUE;
    int flag = 0;
    char *name;
    char *p;

    name = xstrndup(_name, strlen(_name));
    if (name == NULL)
        return FALSE;

    /* check for option &quot;enc_name//opt1//opt2&quot; */
    while ((p = strrstr(name, &quot;//&quot;)) != NULL)
    {
        if (_stricmp(p + 2, &quot;nocompat&quot;) == 0)
            use_compat = FALSE;
        else if (_stricmp(p + 2, &quot;translit&quot;) == 0)
            flag |= FLAG_TRANSLIT;
        else if (_stricmp(p + 2, &quot;ignore&quot;) == 0)
            flag |= FLAG_IGNORE;
        *p = 0;
    }

    cv-&gt;mode = 0;
    cv-&gt;flags = flag;
    cv-&gt;mblen = NULL;
    cv-&gt;flush = NULL;
    cv-&gt;compat = NULL;
    cv-&gt;codepage = name_to_codepage(name);
    if (cv-&gt;codepage == 1200 || cv-&gt;codepage == 1201)
    {
        cv-&gt;mbtowc = utf16_mbtowc;
        cv-&gt;wctomb = utf16_wctomb;
        if (_stricmp(name, &quot;UTF-16&quot;) == 0 || _stricmp(name, &quot;UTF16&quot;) == 0 ||
          _stricmp(name, &quot;UCS-2&quot;) == 0 || _stricmp(name, &quot;UCS2&quot;) == 0)
            cv-&gt;flags |= FLAG_USE_BOM;
    }
    else if (cv-&gt;codepage == 12000 || cv-&gt;codepage == 12001)
    {
        cv-&gt;mbtowc = utf32_mbtowc;
        cv-&gt;wctomb = utf32_wctomb;
        if (_stricmp(name, &quot;UTF-32&quot;) == 0 || _stricmp(name, &quot;UTF32&quot;) == 0 ||
          _stricmp(name, &quot;UCS-4&quot;) == 0 || _stricmp(name, &quot;UCS4&quot;) == 0)
            cv-&gt;flags |= FLAG_USE_BOM;
    }
    else if (cv-&gt;codepage == 65001)
    {
        cv-&gt;mbtowc = kernel_mbtowc;
        cv-&gt;wctomb = kernel_wctomb;
        cv-&gt;mblen = utf8_mblen;
    }
    else if ((cv-&gt;codepage == 50220 || cv-&gt;codepage == 50221 || cv-&gt;codepage == 50222) &amp;&amp; load_mlang())
    {
        cv-&gt;mbtowc = iso2022jp_mbtowc;
        cv-&gt;wctomb = iso2022jp_wctomb;
        cv-&gt;flush = iso2022jp_flush;
    }
    else if (cv-&gt;codepage == 51932 &amp;&amp; load_mlang())
    {
        cv-&gt;mbtowc = mlang_mbtowc;
        cv-&gt;wctomb = mlang_wctomb;
        cv-&gt;mblen = eucjp_mblen;
    }
    else if (IsValidCodePage(cv-&gt;codepage)
	     &amp;&amp; GetCPInfo(cv-&gt;codepage, &amp;cpinfo) != 0)
    {
        cv-&gt;mbtowc = kernel_mbtowc;
        cv-&gt;wctomb = kernel_wctomb;
        if (cpinfo.MaxCharSize == 1)
            cv-&gt;mblen = sbcs_mblen;
        else if (cpinfo.MaxCharSize == 2)
            cv-&gt;mblen = dbcs_mblen;
        else
	    cv-&gt;mblen = mbcs_mblen;
    }
    else
    {
        /* not supported */
        free(name);
        errno = EINVAL;
        return FALSE;
    }

    if (use_compat)
    {
        switch (cv-&gt;codepage)
        {
        case 932: cv-&gt;compat = cp932_compat; break;
        case 20932: cv-&gt;compat = cp20932_compat; break;
        case 51932: cv-&gt;compat = cp51932_compat; break;
        case 50220: case 50221: case 50222: cv-&gt;compat = cp5022x_compat; break;
        }
    }

    free(name);

    return TRUE;
}

static int
name_to_codepage(const char *name)
{
    int i;

    if (*name == &#039;\0&#039; ||
	strcmp(name, &quot;char&quot;) == 0)
        return GetACP();
    else if (strcmp(name, &quot;wchar_t&quot;) == 0)
        return 1200;
    else if (_strnicmp(name, &quot;cp&quot;, 2) == 0)
        return atoi(name + 2); /* CP123 */
    else if (&#039;0&#039; &lt;= name[0] &amp;&amp; name[0] &lt;= &#039;9&#039;)
        return atoi(name);     /* 123 */
    else if (_strnicmp(name, &quot;xx&quot;, 2) == 0)
        return atoi(name + 2); /* XX123 for debug */

    for (i = 0; codepage_alias[i].name != NULL; ++i)
        if (_stricmp(name, codepage_alias[i].name) == 0)
            return codepage_alias[i].codepage;
    return -1;
}

/*
 * http://www.faqs.org/rfcs/rfc2781.html
 */
static uint
utf16_to_ucs4(const ushort *wbuf)
{
    uint wc = wbuf[0];
    if (0xD800 &lt;= wbuf[0] &amp;&amp; wbuf[0] &lt;= 0xDBFF)
        wc = ((wbuf[0] &amp; 0x3FF) &lt;&lt; 10) + (wbuf[1] &amp; 0x3FF) + 0x10000;
    return wc;
}

static void
ucs4_to_utf16(uint wc, ushort *wbuf, int *wbufsize)
{
    if (wc &lt; 0x10000)
    {
        wbuf[0] = wc;
        *wbufsize = 1;
    }
    else
    {
        wc -= 0x10000;
        wbuf[0] = 0xD800 | ((wc &gt;&gt; 10) &amp; 0x3FF);
        wbuf[1] = 0xDC00 | (wc &amp; 0x3FF);
        *wbufsize = 2;
    }
}

/*
 * Check if codepage is one of those for which the dwFlags parameter
 * to MultiByteToWideChar() must be zero. Return zero or
 * MB_ERR_INVALID_CHARS.  The docs in Platform SDK for for Windows
 * Server 2003 R2 claims that also codepage 65001 is one of these, but
 * that doesn&#039;t seem to be the case. The MSDN docs for MSVS2008 leave
 * out 65001 (UTF-8), and that indeed seems to be the case on XP, it
 * works fine to pass MB_ERR_INVALID_CHARS in dwFlags when converting
 * from UTF-8.
 */
static int
mbtowc_flags(int codepage)
{
    return (codepage == 50220 || codepage == 50221 ||
	    codepage == 50222 || codepage == 50225 ||
	    codepage == 50227 || codepage == 50229 ||
	    codepage == 52936 || codepage == 54936 ||
	    (codepage &gt;= 57002 &amp;&amp; codepage &lt;= 57011) ||
	    codepage == 65000 || codepage == 42) ? 0 : MB_ERR_INVALID_CHARS;
}

/*
 * Check if codepage is one those for which the lpUsedDefaultChar
 * parameter to WideCharToMultiByte() must be NULL.  The docs in
 * Platform SDK for for Windows Server 2003 R2 claims that this is the
 * list below, while the MSDN docs for MSVS2008 claim that it is only
 * for 65000 (UTF-7) and 65001 (UTF-8). This time the earlier Platform
 * SDK seems to be correct, at least for XP.
 */
static int
must_use_null_useddefaultchar(int codepage)
{
    return (codepage == 65000 || codepage == 65001 ||
            codepage == 50220 || codepage == 50221 ||
            codepage == 50222 || codepage == 50225 ||
            codepage == 50227 || codepage == 50229 ||
            codepage == 52936 || codepage == 54936 ||
            (codepage &gt;= 57002 &amp;&amp; codepage &lt;= 57011) ||
            codepage == 42);
}

static char *
strrstr(const char *str, const char *token)
{
    size_t len = strlen(token);
    const char *p = str + strlen(str);

    while (str &lt;= --p)
        if (p[0] == token[0] &amp;&amp; strncmp(p, token, len) == 0)
            return (char *)p;
    return NULL;
}

static char *
xstrndup(const char *s, size_t n)
{
    char *p;

    p = (char *)malloc(n + 1);
    if (p == NULL)
        return NULL;
    memcpy(p, s, n);
    p[n] = &#039;\0&#039;;
    return p;
}

static int
seterror(int err)
{
    errno = err;
    return -1;
}

#if defined(USE_LIBICONV_DLL)
static int
libiconv_iconv_open(rec_iconv_t *cd, const char *tocode, const char *fromcode)
{
    HMODULE hlibiconv = NULL;
    HMODULE hmsvcrt = NULL;
    char *dllname;
    const char *p;
    const char *e;
    f_iconv_open _iconv_open;

    /*
     * always try to load dll, so that we can switch dll in runtime.
     */

    /* XXX: getenv() can&#039;t get variable set by SetEnvironmentVariable() */
    p = getenv(&quot;WINICONV_LIBICONV_DLL&quot;);
    if (p == NULL)
        p = DEFAULT_LIBICONV_DLL;
    /* parse comma separated value */
    for ( ; *p != 0; p = (*e == &#039;,&#039;) ? e + 1 : e)
    {
        e = strchr(p, &#039;,&#039;);
        if (p == e)
            continue;
        else if (e == NULL)
            e = p + strlen(p);
        dllname = xstrndup(p, e - p);
        if (dllname == NULL)
            return FALSE;
        hlibiconv = LoadLibraryA(dllname);
        free(dllname);
        if (hlibiconv != NULL)
        {
            if (hlibiconv == hwiniconv)
            {
                FreeLibrary(hlibiconv);
                hlibiconv = NULL;
                continue;
            }
            break;
        }
    }

    if (hlibiconv == NULL)
        goto failed;

    hmsvcrt = find_imported_module_by_funcname(hlibiconv, &quot;_errno&quot;);
    if (hmsvcrt == NULL)
        goto failed;

    _iconv_open = (f_iconv_open)GetProcAddressA(hlibiconv, &quot;libiconv_open&quot;);
    if (_iconv_open == NULL)
        _iconv_open = (f_iconv_open)GetProcAddressA(hlibiconv, &quot;iconv_open&quot;);
    cd-&gt;iconv_close = (f_iconv_close)GetProcAddressA(hlibiconv, &quot;libiconv_close&quot;);
    if (cd-&gt;iconv_close == NULL)
        cd-&gt;iconv_close = (f_iconv_close)GetProcAddressA(hlibiconv, &quot;iconv_close&quot;);
    cd-&gt;iconv = (f_iconv)GetProcAddressA(hlibiconv, &quot;libiconv&quot;);
    if (cd-&gt;iconv == NULL)
        cd-&gt;iconv = (f_iconv)GetProcAddressA(hlibiconv, &quot;iconv&quot;);
    cd-&gt;_errno = (f_errno)GetProcAddressA(hmsvcrt, &quot;_errno&quot;);
    if (_iconv_open == NULL || cd-&gt;iconv_close == NULL
            || cd-&gt;iconv == NULL || cd-&gt;_errno == NULL)
        goto failed;

    cd-&gt;cd = _iconv_open(tocode, fromcode);
    if (cd-&gt;cd == (iconv_t)(-1))
        goto failed;

    cd-&gt;hlibiconv = hlibiconv;
    return TRUE;

failed:
    if (hlibiconv != NULL)
        FreeLibrary(hlibiconv);
    /* do not free hmsvcrt which is obtained by GetModuleHandle() */
    return FALSE;
}

/*
 * Reference:
 * http://forums.belution.com/ja/vc/000/234/78s.shtml
 * http://nienie.com/~masapico/api_ImageDirectoryEntryToData.html
 *
 * The formal way is
 *   imagehlp.h or dbghelp.h
 *   imagehlp.lib or dbghelp.lib
 *   ImageDirectoryEntryToData()
 */
#define TO_DOS_HEADER(base) ((PIMAGE_DOS_HEADER)(base))
#define TO_NT_HEADERS(base) ((PIMAGE_NT_HEADERS)((LPBYTE)(base) + TO_DOS_HEADER(base)-&gt;e_lfanew))
static PVOID
MyImageDirectoryEntryToData(LPVOID Base, BOOLEAN MappedAsImage, USHORT DirectoryEntry, PULONG Size)
{
    /* TODO: MappedAsImage? */
    PIMAGE_DATA_DIRECTORY p;
    p = TO_NT_HEADERS(Base)-&gt;OptionalHeader.DataDirectory + DirectoryEntry;
    if (p-&gt;VirtualAddress == 0) {
      *Size = 0;
      return NULL;
    }
    *Size = p-&gt;Size;
    return (PVOID)((LPBYTE)Base + p-&gt;VirtualAddress);
}

static HMODULE
find_imported_module_by_funcname(HMODULE hModule, const char *funcname)
{
    DWORD_PTR Base;
    ULONG Size;
    PIMAGE_IMPORT_DESCRIPTOR Imp;
    PIMAGE_THUNK_DATA Name;         /* Import Name Table */
    PIMAGE_IMPORT_BY_NAME ImpName;

    Base = (DWORD_PTR)hModule;
    Imp = (PIMAGE_IMPORT_DESCRIPTOR)MyImageDirectoryEntryToData(
            (LPVOID)Base,
            TRUE,
            IMAGE_DIRECTORY_ENTRY_IMPORT,
            &amp;Size);
    if (Imp == NULL)
        return NULL;
    for ( ; Imp-&gt;OriginalFirstThunk != 0; ++Imp)
    {
        Name = (PIMAGE_THUNK_DATA)(Base + Imp-&gt;OriginalFirstThunk);
        for ( ; Name-&gt;u1.Ordinal != 0; ++Name)
        {
            if (!IMAGE_SNAP_BY_ORDINAL(Name-&gt;u1.Ordinal))
            {
                ImpName = (PIMAGE_IMPORT_BY_NAME)
                    (Base + (DWORD_PTR)Name-&gt;u1.AddressOfData);
                if (strcmp((char *)ImpName-&gt;Name, funcname) == 0)
                    return GetModuleHandleA((char *)(Base + Imp-&gt;Name));
            }
        }
    }
    return NULL;
}
#endif

static int
sbcs_mblen(csconv_t *cv UNUSED, const uchar *buf UNUSED, int bufsize UNUSED)
{
    return 1;
}

static int
dbcs_mblen(csconv_t *cv, const uchar *buf, int bufsize)
{
    int len = IsDBCSLeadByteEx(cv-&gt;codepage, buf[0]) ? 2 : 1;
    if (bufsize &lt; len)
        return seterror(EINVAL);
    return len;
}

static int
mbcs_mblen(csconv_t *cv, const uchar *buf, int bufsize)
{
    int len = 0;

    if (cv-&gt;codepage == 54936) {
	if (buf[0] &lt;= 0x7F) len = 1;
	else if (buf[0] &gt;= 0x81 &amp;&amp; buf[0] &lt;= 0xFE &amp;&amp;
		 bufsize &gt;= 2 &amp;&amp;
		 ((buf[1] &gt;= 0x40 &amp;&amp; buf[1] &lt;= 0x7E) ||
		  (buf[1] &gt;= 0x80 &amp;&amp; buf[1] &lt;= 0xFE))) len = 2;
	else if (buf[0] &gt;= 0x81 &amp;&amp; buf[0] &lt;= 0xFE &amp;&amp;
		 bufsize &gt;= 4 &amp;&amp;
		 buf[1] &gt;= 0x30 &amp;&amp; buf[1] &lt;= 0x39) len = 4;
	else
	    return seterror(EINVAL);
	return len;
    }
    else
	return seterror(EINVAL);
}

static int
utf8_mblen(csconv_t *cv UNUSED, const uchar *buf, int bufsize)
{
    int len = 0;

    if (buf[0] &lt; 0x80) len = 1;
    else if ((buf[0] &amp; 0xE0) == 0xC0) len = 2;
    else if ((buf[0] &amp; 0xF0) == 0xE0) len = 3;
    else if ((buf[0] &amp; 0xF8) == 0xF0) len = 4;
    else if ((buf[0] &amp; 0xFC) == 0xF8) len = 5;
    else if ((buf[0] &amp; 0xFE) == 0xFC) len = 6;

    if (len == 0)
        return seterror(EILSEQ);
    else if (bufsize &lt; len)
        return seterror(EINVAL);
    return len;
}

static int
eucjp_mblen(csconv_t *cv UNUSED, const uchar *buf, int bufsize)
{
    if (buf[0] &lt; 0x80) /* ASCII */
        return 1;
    else if (buf[0] == 0x8E) /* JIS X 0201 */
    {
        if (bufsize &lt; 2)
            return seterror(EINVAL);
        else if (!(0xA1 &lt;= buf[1] &amp;&amp; buf[1] &lt;= 0xDF))
            return seterror(EILSEQ);
        return 2;
    }
    else if (buf[0] == 0x8F) /* JIS X 0212 */
    {
        if (bufsize &lt; 3)
            return seterror(EINVAL);
        else if (!(0xA1 &lt;= buf[1] &amp;&amp; buf[1] &lt;= 0xFE)
                || !(0xA1 &lt;= buf[2] &amp;&amp; buf[2] &lt;= 0xFE))
            return seterror(EILSEQ);
        return 3;
    }
    else /* JIS X 0208 */
    {
        if (bufsize &lt; 2)
            return seterror(EINVAL);
        else if (!(0xA1 &lt;= buf[0] &amp;&amp; buf[0] &lt;= 0xFE)
                || !(0xA1 &lt;= buf[1] &amp;&amp; buf[1] &lt;= 0xFE))
            return seterror(EILSEQ);
        return 2;
    }
}

static int
kernel_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize)
{
    int len;

    len = cv-&gt;mblen(cv, buf, bufsize);
    if (len == -1)
        return -1;
    *wbufsize = MultiByteToWideChar(cv-&gt;codepage, mbtowc_flags (cv-&gt;codepage),
            (const char *)buf, len, (wchar_t *)wbuf, *wbufsize);
    if (*wbufsize == 0)
        return seterror(EILSEQ);
    return len;
}

static int
kernel_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize)
{
    BOOL usedDefaultChar = 0;
    BOOL *p = NULL;
    int flags = 0;
    int len;

    if (bufsize == 0)
        return seterror(E2BIG);
    if (!must_use_null_useddefaultchar(cv-&gt;codepage))
    {
        p = &amp;usedDefaultChar;
#ifdef WC_NO_BEST_FIT_CHARS
        if (!(cv-&gt;flags &amp; FLAG_TRANSLIT))
            flags |= WC_NO_BEST_FIT_CHARS;
#endif
    }
    len = WideCharToMultiByte(cv-&gt;codepage, flags,
            (const wchar_t *)wbuf, wbufsize, (char *)buf, bufsize, NULL, p);
    if (len == 0)
    {
        if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
            return seterror(E2BIG);
        return seterror(EILSEQ);
    }
    else if (usedDefaultChar &amp;&amp; !(cv-&gt;flags &amp; FLAG_TRANSLIT))
        return seterror(EILSEQ);
    else if (cv-&gt;mblen(cv, buf, len) != len) /* validate result */
        return seterror(EILSEQ);
    return len;
}

/*
 * It seems that the mode (cv-&gt;mode) is fixnum.
 * For example, when converting iso-2022-jp(cp50221) to unicode:
 *      in ascii sequence: mode=0xC42C0000
 *   in jisx0208 sequence: mode=0xC42C0001
 * &quot;C42C&quot; is same for each convert session.
 * It should be: ((codepage-1)&lt;&lt;16)|state
 */
static int
mlang_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize)
{
    int len;
    int insize;
    HRESULT hr;

    len = cv-&gt;mblen(cv, buf, bufsize);
    if (len == -1)
        return -1;
    insize = len;
    hr = ConvertINetMultiByteToUnicode(&amp;cv-&gt;mode, cv-&gt;codepage,
            (const char *)buf, &amp;insize, (wchar_t *)wbuf, wbufsize);
    if (hr != S_OK || insize != len)
        return seterror(EILSEQ);
    return len;
}

static int
mlang_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize)
{
    char tmpbuf[MB_CHAR_MAX]; /* enough room for one character */
    int tmpsize = MB_CHAR_MAX;
    int insize = wbufsize;
    HRESULT hr;

    hr = ConvertINetUnicodeToMultiByte(&amp;cv-&gt;mode, cv-&gt;codepage,
            (const wchar_t *)wbuf, &amp;wbufsize, tmpbuf, &amp;tmpsize);
    if (hr != S_OK || insize != wbufsize)
        return seterror(EILSEQ);
    else if (bufsize &lt; tmpsize)
        return seterror(E2BIG);
    else if (cv-&gt;mblen(cv, (uchar *)tmpbuf, tmpsize) != tmpsize)
        return seterror(EILSEQ);
    memcpy(buf, tmpbuf, tmpsize);
    return tmpsize;
}

static int
utf16_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize)
{
    int codepage = cv-&gt;codepage;

    /* swap endian: 1200 &lt;-&gt; 1201 */
    if (cv-&gt;mode &amp; UNICODE_MODE_SWAPPED)
        codepage ^= 1;

    if (bufsize &lt; 2)
        return seterror(EINVAL);
    if (codepage == 1200) /* little endian */
        wbuf[0] = (buf[1] &lt;&lt; 8) | buf[0];
    else if (codepage == 1201) /* big endian */
        wbuf[0] = (buf[0] &lt;&lt; 8) | buf[1];

    if ((cv-&gt;flags &amp; FLAG_USE_BOM) &amp;&amp; !(cv-&gt;mode &amp; UNICODE_MODE_BOM_DONE))
    {
        cv-&gt;mode |= UNICODE_MODE_BOM_DONE;
        if (wbuf[0] == 0xFFFE)
        {
            cv-&gt;mode |= UNICODE_MODE_SWAPPED;
            *wbufsize = 0;
            return 2;
        }
        else if (wbuf[0] == 0xFEFF)
        {
            *wbufsize = 0;
            return 2;
        }
    }

    if (0xDC00 &lt;= wbuf[0] &amp;&amp; wbuf[0] &lt;= 0xDFFF)
        return seterror(EILSEQ);
    if (0xD800 &lt;= wbuf[0] &amp;&amp; wbuf[0] &lt;= 0xDBFF)
    {
        if (bufsize &lt; 4)
            return seterror(EINVAL);
        if (codepage == 1200) /* little endian */
            wbuf[1] = (buf[3] &lt;&lt; 8) | buf[2];
        else if (codepage == 1201) /* big endian */
            wbuf[1] = (buf[2] &lt;&lt; 8) | buf[3];
        if (!(0xDC00 &lt;= wbuf[1] &amp;&amp; wbuf[1] &lt;= 0xDFFF))
            return seterror(EILSEQ);
        *wbufsize = 2;
        return 4;
    }
    *wbufsize = 1;
    return 2;
}

static int
utf16_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize)
{
    if ((cv-&gt;flags &amp; FLAG_USE_BOM) &amp;&amp; !(cv-&gt;mode &amp; UNICODE_MODE_BOM_DONE))
    {
        int r;

        cv-&gt;mode |= UNICODE_MODE_BOM_DONE;
        if (bufsize &lt; 2)
            return seterror(E2BIG);
        if (cv-&gt;codepage == 1200) /* little endian */
            memcpy(buf, &quot;\xFF\xFE&quot;, 2);
        else if (cv-&gt;codepage == 1201) /* big endian */
            memcpy(buf, &quot;\xFE\xFF&quot;, 2);

        r = utf16_wctomb(cv, wbuf, wbufsize, buf + 2, bufsize - 2);
        if (r == -1)
            return -1;
        return r + 2;
    }

    if (bufsize &lt; 2)
        return seterror(E2BIG);
    if (cv-&gt;codepage == 1200) /* little endian */
    {
        buf[0] = (wbuf[0] &amp; 0x00FF);
        buf[1] = (wbuf[0] &amp; 0xFF00) &gt;&gt; 8;
    }
    else if (cv-&gt;codepage == 1201) /* big endian */
    {
        buf[0] = (wbuf[0] &amp; 0xFF00) &gt;&gt; 8;
        buf[1] = (wbuf[0] &amp; 0x00FF);
    }
    if (0xD800 &lt;= wbuf[0] &amp;&amp; wbuf[0] &lt;= 0xDBFF)
    {
        if (bufsize &lt; 4)
            return seterror(E2BIG);
        if (cv-&gt;codepage == 1200) /* little endian */
        {
            buf[2] = (wbuf[1] &amp; 0x00FF);
            buf[3] = (wbuf[1] &amp; 0xFF00) &gt;&gt; 8;
        }
        else if (cv-&gt;codepage == 1201) /* big endian */
        {
            buf[2] = (wbuf[1] &amp; 0xFF00) &gt;&gt; 8;
            buf[3] = (wbuf[1] &amp; 0x00FF);
        }
        return 4;
    }
    return 2;
}

static int
utf32_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize)
{
    int codepage = cv-&gt;codepage;
    uint wc;

    /* swap endian: 12000 &lt;-&gt; 12001 */
    if (cv-&gt;mode &amp; UNICODE_MODE_SWAPPED)
        codepage ^= 1;

    if (bufsize &lt; 4)
        return seterror(EINVAL);
    if (codepage == 12000) /* little endian */
        wc = (buf[3] &lt;&lt; 24) | (buf[2] &lt;&lt; 16) | (buf[1] &lt;&lt; 8) | buf[0];
    else if (codepage == 12001) /* big endian */
        wc = (buf[0] &lt;&lt; 24) | (buf[1] &lt;&lt; 16) | (buf[2] &lt;&lt; 8) | buf[3];

    if ((cv-&gt;flags &amp; FLAG_USE_BOM) &amp;&amp; !(cv-&gt;mode &amp; UNICODE_MODE_BOM_DONE))
    {
        cv-&gt;mode |= UNICODE_MODE_BOM_DONE;
        if (wc == 0xFFFE0000)
        {
            cv-&gt;mode |= UNICODE_MODE_SWAPPED;
            *wbufsize = 0;
            return 4;
        }
        else if (wc == 0x0000FEFF)
        {
            *wbufsize = 0;
            return 4;
        }
    }

    if ((0xD800 &lt;= wc &amp;&amp; wc &lt;= 0xDFFF) || 0x10FFFF &lt; wc)
        return seterror(EILSEQ);
    ucs4_to_utf16(wc, wbuf, wbufsize);
    return 4;
}

static int
utf32_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize)
{
    uint wc;

    if ((cv-&gt;flags &amp; FLAG_USE_BOM) &amp;&amp; !(cv-&gt;mode &amp; UNICODE_MODE_BOM_DONE))
    {
        int r;

        cv-&gt;mode |= UNICODE_MODE_BOM_DONE;
        if (bufsize &lt; 4)
            return seterror(E2BIG);
        if (cv-&gt;codepage == 12000) /* little endian */
            memcpy(buf, &quot;\xFF\xFE\x00\x00&quot;, 4);
        else if (cv-&gt;codepage == 12001) /* big endian */
            memcpy(buf, &quot;\x00\x00\xFE\xFF&quot;, 4);

        r = utf32_wctomb(cv, wbuf, wbufsize, buf + 4, bufsize - 4);
        if (r == -1)
            return -1;
        return r + 4;
    }

    if (bufsize &lt; 4)
        return seterror(E2BIG);
    wc = utf16_to_ucs4(wbuf);
    if (cv-&gt;codepage == 12000) /* little endian */
    {
        buf[0] = wc &amp; 0x000000FF;
        buf[1] = (wc &amp; 0x0000FF00) &gt;&gt; 8;
        buf[2] = (wc &amp; 0x00FF0000) &gt;&gt; 16;
        buf[3] = (wc &amp; 0xFF000000) &gt;&gt; 24;
    }
    else if (cv-&gt;codepage == 12001) /* big endian */
    {
        buf[0] = (wc &amp; 0xFF000000) &gt;&gt; 24;
        buf[1] = (wc &amp; 0x00FF0000) &gt;&gt; 16;
        buf[2] = (wc &amp; 0x0000FF00) &gt;&gt; 8;
        buf[3] = wc &amp; 0x000000FF;
    }
    return 4;
}

/*
 * 50220: ISO 2022 Japanese with no halfwidth Katakana; Japanese (JIS)
 * 50221: ISO 2022 Japanese with halfwidth Katakana; Japanese (JIS-Allow
 *        1 byte Kana)
 * 50222: ISO 2022 Japanese JIS X 0201-1989; Japanese (JIS-Allow 1 byte
 *        Kana - SO/SI)
 *
 * MultiByteToWideChar() and WideCharToMultiByte() behave differently
 * depending on Windows version.  On XP, WideCharToMultiByte() doesn&#039;t
 * terminate result sequence with ascii escape.  But Vista does.
 * Use MLang instead.
 */

#define ISO2022_MODE(cs, shift) (((cs) &lt;&lt; 8) | (shift))
#define ISO2022_MODE_CS(mode) (((mode) &gt;&gt; 8) &amp; 0xFF)
#define ISO2022_MODE_SHIFT(mode) ((mode) &amp; 0xFF)

#define ISO2022_SI  0
#define ISO2022_SO  1

/* shift in */
static const char iso2022_SI_seq[] = &quot;\x0F&quot;;
/* shift out */
static const char iso2022_SO_seq[] = &quot;\x0E&quot;;

typedef struct iso2022_esc_t iso2022_esc_t;
struct iso2022_esc_t {
    const char *esc;
    int esc_len;
    int len;
    int cs;
};

#define ISO2022JP_CS_ASCII            0
#define ISO2022JP_CS_JISX0201_ROMAN   1
#define ISO2022JP_CS_JISX0201_KANA    2
#define ISO2022JP_CS_JISX0208_1978    3
#define ISO2022JP_CS_JISX0208_1983    4
#define ISO2022JP_CS_JISX0212         5

static iso2022_esc_t iso2022jp_esc[] = {
    {&quot;\x1B\x28\x42&quot;, 3, 1, ISO2022JP_CS_ASCII},
    {&quot;\x1B\x28\x4A&quot;, 3, 1, ISO2022JP_CS_JISX0201_ROMAN},
    {&quot;\x1B\x28\x49&quot;, 3, 1, ISO2022JP_CS_JISX0201_KANA},
    {&quot;\x1B\x24\x40&quot;, 3, 2, ISO2022JP_CS_JISX0208_1983}, /* unify 1978 with 1983 */
    {&quot;\x1B\x24\x42&quot;, 3, 2, ISO2022JP_CS_JISX0208_1983},
    {&quot;\x1B\x24\x28\x44&quot;, 4, 2, ISO2022JP_CS_JISX0212},
    {NULL, 0, 0, 0}
};

static int
iso2022jp_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize)
{
    iso2022_esc_t *iesc = iso2022jp_esc;
    char tmp[MB_CHAR_MAX];
    int insize;
    HRESULT hr;
    DWORD dummy = 0;
    int len;
    int esc_len;
    int cs;
    int shift;
    int i;

    if (buf[0] == 0x1B)
    {
        for (i = 0; iesc[i].esc != NULL; ++i)
        {
            esc_len = iesc[i].esc_len;
            if (bufsize &lt; esc_len)
            {
                if (strncmp((char *)buf, iesc[i].esc, bufsize) == 0)
                    return seterror(EINVAL);
            }
            else
            {
                if (strncmp((char *)buf, iesc[i].esc, esc_len) == 0)
                {
                    cv-&gt;mode = ISO2022_MODE(iesc[i].cs, ISO2022_SI);
                    *wbufsize = 0;
                    return esc_len;
                }
            }
        }
        /* not supported escape sequence */
        return seterror(EILSEQ);
    }
    else if (buf[0] == iso2022_SO_seq[0])
    {
        cv-&gt;mode = ISO2022_MODE(ISO2022_MODE_CS(cv-&gt;mode), ISO2022_SO);
        *wbufsize = 0;
        return 1;
    }
    else if (buf[0] == iso2022_SI_seq[0])
    {
        cv-&gt;mode = ISO2022_MODE(ISO2022_MODE_CS(cv-&gt;mode), ISO2022_SI);
        *wbufsize = 0;
        return 1;
    }

    cs = ISO2022_MODE_CS(cv-&gt;mode);
    shift = ISO2022_MODE_SHIFT(cv-&gt;mode);

    /* reset the mode for informal sequence */
    if (buf[0] &lt; 0x20)
    {
        cs = ISO2022JP_CS_ASCII;
        shift = ISO2022_SI;
    }

    len = iesc[cs].len;
    if (bufsize &lt; len)
        return seterror(EINVAL);
    for (i = 0; i &lt; len; ++i)
        if (!(buf[i] &lt; 0x80))
            return seterror(EILSEQ);
    esc_len = iesc[cs].esc_len;
    memcpy(tmp, iesc[cs].esc, esc_len);
    if (shift == ISO2022_SO)
    {
        memcpy(tmp + esc_len, iso2022_SO_seq, 1);
        esc_len += 1;
    }
    memcpy(tmp + esc_len, buf, len);

    if ((cv-&gt;codepage == 50220 || cv-&gt;codepage == 50221
                || cv-&gt;codepage == 50222) &amp;&amp; shift == ISO2022_SO)
    {
        /* XXX: shift-out cannot be used for mbtowc (both kernel and
         * mlang) */
        esc_len = iesc[ISO2022JP_CS_JISX0201_KANA].esc_len;
        memcpy(tmp, iesc[ISO2022JP_CS_JISX0201_KANA].esc, esc_len);
        memcpy(tmp + esc_len, buf, len);
    }

    insize = len + esc_len;
    hr = ConvertINetMultiByteToUnicode(&amp;dummy, cv-&gt;codepage,
            (const char *)tmp, &amp;insize, (wchar_t *)wbuf, wbufsize);
    if (hr != S_OK || insize != len + esc_len)
        return seterror(EILSEQ);

    /* Check for conversion error.  Assuming defaultChar is 0x3F. */
    /* ascii should be converted from ascii */
    if (wbuf[0] == buf[0]
            &amp;&amp; cv-&gt;mode != ISO2022_MODE(ISO2022JP_CS_ASCII, ISO2022_SI))
        return seterror(EILSEQ);

    /* reset the mode for informal sequence */
    if (cv-&gt;mode != (DWORD)ISO2022_MODE(cs, shift))
        cv-&gt;mode = (DWORD)ISO2022_MODE(cs, shift);

    return len;
}

static int
iso2022jp_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize)
{
    iso2022_esc_t *iesc = iso2022jp_esc;
    char tmp[MB_CHAR_MAX];
    int tmpsize = MB_CHAR_MAX;
    int insize = wbufsize;
    HRESULT hr;
    DWORD dummy = 0;
    int len;
    int esc_len;
    int cs;
    int shift;
    int i;

    /*
     * MultiByte = [escape sequence] + character + [escape sequence]
     *
     * Whether trailing escape sequence is added depends on which API is
     * used (kernel or MLang, and its version).
     */
    hr = ConvertINetUnicodeToMultiByte(&amp;dummy, cv-&gt;codepage,
            (const wchar_t *)wbuf, &amp;wbufsize, tmp, &amp;tmpsize);
    if (hr != S_OK || insize != wbufsize)
        return seterror(EILSEQ);
    else if (bufsize &lt; tmpsize)
        return seterror(E2BIG);

    if (tmpsize == 1)
    {
        cs = ISO2022JP_CS_ASCII;
        esc_len = 0;
    }
    else
    {
        for (i = 1; iesc[i].esc != NULL; ++i)
        {
            esc_len = iesc[i].esc_len;
            if (strncmp(tmp, iesc[i].esc, esc_len) == 0)
            {
                cs = iesc[i].cs;
                break;
            }
        }
        if (iesc[i].esc == NULL)
            /* not supported escape sequence */
            return seterror(EILSEQ);
    }

    shift = ISO2022_SI;
    if (tmp[esc_len] == iso2022_SO_seq[0])
    {
        shift = ISO2022_SO;
        esc_len += 1;
    }

    len = iesc[cs].len;

    /* Check for converting error.  Assuming defaultChar is 0x3F. */
    /* ascii should be converted from ascii */
    if (cs == ISO2022JP_CS_ASCII &amp;&amp; !(wbuf[0] &lt; 0x80))
        return seterror(EILSEQ);
    else if (tmpsize &lt; esc_len + len)
        return seterror(EILSEQ);

    if (cv-&gt;mode == ISO2022_MODE(cs, shift))
    {
        /* remove escape sequence */
        if (esc_len != 0)
            memmove(tmp, tmp + esc_len, len);
        esc_len = 0;
    }
    else
    {
        if (cs == ISO2022JP_CS_ASCII)
        {
            esc_len = iesc[ISO2022JP_CS_ASCII].esc_len;
            memmove(tmp + esc_len, tmp, len);
            memcpy(tmp, iesc[ISO2022JP_CS_ASCII].esc, esc_len);
        }
        if (ISO2022_MODE_SHIFT(cv-&gt;mode) == ISO2022_SO)
        {
            /* shift-in before changing to other mode */
            memmove(tmp + 1, tmp, len + esc_len);
            memcpy(tmp, iso2022_SI_seq, 1);
            esc_len += 1;
        }
    }

    if (bufsize &lt; len + esc_len)
        return seterror(E2BIG);
    memcpy(buf, tmp, len + esc_len);
    cv-&gt;mode = ISO2022_MODE(cs, shift);
    return len + esc_len;
}

static int
iso2022jp_flush(csconv_t *cv, uchar *buf, int bufsize)
{
    iso2022_esc_t *iesc = iso2022jp_esc;
    int esc_len;

    if (cv-&gt;mode != ISO2022_MODE(ISO2022JP_CS_ASCII, ISO2022_SI))
    {
        esc_len = 0;
        if (ISO2022_MODE_SHIFT(cv-&gt;mode) != ISO2022_SI)
            esc_len += 1;
        if (ISO2022_MODE_CS(cv-&gt;mode) != ISO2022JP_CS_ASCII)
            esc_len += iesc[ISO2022JP_CS_ASCII].esc_len;
        if (bufsize &lt; esc_len)
            return seterror(E2BIG);

        esc_len = 0;
        if (ISO2022_MODE_SHIFT(cv-&gt;mode) != ISO2022_SI)
        {
            memcpy(buf, iso2022_SI_seq, 1);
            esc_len += 1;
        }
        if (ISO2022_MODE_CS(cv-&gt;mode) != ISO2022JP_CS_ASCII)
        {
            memcpy(buf + esc_len, iesc[ISO2022JP_CS_ASCII].esc,
                    iesc[ISO2022JP_CS_ASCII].esc_len);
            esc_len += iesc[ISO2022JP_CS_ASCII].esc_len;
        }
        return esc_len;
    }
    return 0;
}

#if defined(MAKE_DLL) &amp;&amp; defined(USE_LIBICONV_DLL)
BOOL WINAPI
DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved)
{
    switch( fdwReason )
    {
    case DLL_PROCESS_ATTACH:
        hwiniconv = (HMODULE)hinstDLL;
        break;
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}
#endif

#if defined(MAKE_EXE)
#include &lt;stdio.h&gt;
#include &lt;fcntl.h&gt;
#include &lt;io.h&gt;
int
main(int argc, char **argv)
{
    char *fromcode = NULL;
    char *tocode = NULL;
    int i;
    char inbuf[BUFSIZ];
    char outbuf[BUFSIZ];
    char *pin;
    char *pout;
    size_t inbytesleft;
    size_t outbytesleft;
    size_t rest = 0;
    iconv_t cd;
    size_t r;
    FILE *in = stdin;
    FILE *out = stdout;
    int ignore = 0;
    char *p;

    _setmode(_fileno(stdin), _O_BINARY);
    _setmode(_fileno(stdout), _O_BINARY);

    for (i = 1; i &lt; argc; ++i)
    {
        if (strcmp(argv[i], &quot;-l&quot;) == 0)
        {
            for (i = 0; codepage_alias[i].name != NULL; ++i)
                printf(&quot;%s\n&quot;, codepage_alias[i].name);
            return 0;
        }

        if (strcmp(argv[i], &quot;-f&quot;) == 0)
            fromcode = argv[++i];
        else if (strcmp(argv[i], &quot;-t&quot;) == 0)
            tocode = argv[++i];
        else if (strcmp(argv[i], &quot;-c&quot;) == 0)
            ignore = 1;
        else if (strcmp(argv[i], &quot;--output&quot;) == 0)
        {
            out = fopen(argv[++i], &quot;wb&quot;);
            if(out == NULL)
            {
                fprintf(stderr, &quot;cannot open %s\n&quot;, argv[i]);
                return 1;
            }
        }
        else
        {
            in = fopen(argv[i], &quot;rb&quot;);
            if (in == NULL)
            {
                fprintf(stderr, &quot;cannot open %s\n&quot;, argv[i]);
                return 1;
            }
            break;
        }
    }

    if (fromcode == NULL || tocode == NULL)
    {
        printf(&quot;usage: %s [-c] -f from-enc -t to-enc [file]\n&quot;, argv[0]);
        return 0;
    }

    if (ignore)
    {
        p = tocode;
        tocode = (char *)malloc(strlen(p) + strlen(&quot;//IGNORE&quot;) + 1);
        if (tocode == NULL)
        {
            perror(&quot;fatal error&quot;);
            return 1;
        }
        strcpy(tocode, p);
        strcat(tocode, &quot;//IGNORE&quot;);
    }

    cd = iconv_open(tocode, fromcode);
    if (cd == (iconv_t)(-1))
    {
        perror(&quot;iconv_open error&quot;);
        return 1;
    }

    while ((inbytesleft = fread(inbuf + rest, 1, sizeof(inbuf) - rest, in)) != 0
            || rest != 0)
    {
        inbytesleft += rest;
        pin = inbuf;
        pout = outbuf;
        outbytesleft = sizeof(outbuf);
        r = iconv(cd, &amp;pin, &amp;inbytesleft, &amp;pout, &amp;outbytesleft);
        fwrite(outbuf, 1, sizeof(outbuf) - outbytesleft, out);
        if (r == (size_t)(-1) &amp;&amp; errno != E2BIG &amp;&amp; (errno != EINVAL || feof(in)))
        {
            perror(&quot;conversion error&quot;);
            return 1;
        }
        memmove(inbuf, pin, inbytesleft);
        rest = inbytesleft;
    }
    pout = outbuf;
    outbytesleft = sizeof(outbuf);
    r = iconv(cd, NULL, NULL, &amp;pout, &amp;outbytesleft);
    fwrite(outbuf, 1, sizeof(outbuf) - outbytesleft, out);
    if (r == (size_t)(-1))
    {
        perror(&quot;conversion error&quot;);
        return 1;
    }

    iconv_close(cd);

    return 0;
}
#endif

</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Flibmariadb%2Fwin-iconv'>🔙 Back</a></p>