Changeset 34703

Timestamp:

08/02/09 07:27:53 (4 years ago)

Author:

saturday06

Message:

win_iconv

Files:

• lang/objective-cplusplus/i3/trunk/src/os-windows/msvc/win_iconv.c (modified) (47 diffs)

lang/objective-cplusplus/i3/trunk/src/os-windows/msvc/win_iconv.c

@@ -1 +1 @@
 /*
- * iconv library implemented with Win32 API.
+ * iconv library using Win32 API to conversion.
  *
  * This file is placed in the public domain.
  *
- * Maintainer: Yukihiro Nakadaira <yukihiro.nakadaira@gmail.com>
+ * Last Change: 2009-07-06
  *
- * If $WINICONV_LIBICONV_DLL environment variable was defined, win_iconv
- * loads the specified DLL dynamically and uses it.  If loading the DLL
- * or iconv_open() failed, falls back to internal conversion.
- * $WINICONV_LIBICONV_DLL is a comma separated list.  The first loadable
- * DLL is used.  The specified DLL should have iconv_open(),
- * iconv_close() and iconv() functions.  Or these functions can be
- * libiconv_open(), libiconv_close() and libiconv().
+ * ENVIRONMENT VARIABLE:
+ *     WINICONV_LIBICONV_DLL
+ *         If $WINICONV_LIBICONV_DLL is set, win_iconv uses the DLL.  If
+ *         loading the DLL or iconv_open() failed, falls back to internal
+ *         conversion.  If a few DLL are specified as comma separated list,
+ *         the first loadable DLL is used.  The DLL should have iconv_open(),
+ *         iconv_close() and iconv().  Or libiconv_open(), libiconv_close()
+ *         and libiconv().
+ *         (only available when USE_LIBICONV_DLL is defined at compile time)
  *
  * Win32 API does not support strict encoding conversion for some
@@ -26 +28 @@
 
 #include <windows.h>
+#include <errno.h>
 #include <string.h>
 #include <stdlib.h>
-
-#ifndef _WIN32_WCE
-#include <errno.h>
-#else
-
-#ifdef _MSC_VER
-__declspec (thread) int errno = 0;
-#elif (MINGW32_MAJOR_VERSION >= 4)
-__thread int errno = 0;
-#else
-#error "tls required"
-#endif
-
-static int* _errno(void)
-{
-    return &errno;
-}
-
-#define E2BIG           7       /* Arg list too long */
-#define ENOMEM          12      /* Not enough space */
-#define EINVAL          22      /* Invalid argument */
-#define EILSEQ          42      /* Illegal byte sequence */
-#undef GetProcAddress
-#define GetProcAddress(hModule, lpProcName) GetProcAddressW(hModule, L##lpProcName)
-#endif
 
 #if 0
@@ -69 +47 @@
 #define UNICODE_MODE_SWAPPED    2
 
-#define FLAG_USE_BOM_ENDIAN     1
+#define FLAG_USE_BOM            1
 #define FLAG_TRANSLIT           2 /* //TRANSLIT */
 #define FLAG_IGNORE             4 /* //IGNORE (not implemented) */
-
-#define return_error(code)  \
-    do {                    \
-        errno = code;       \
-        return -1;          \
-    } while (0)
-
-#define xstrlcpy(dst, src, size)    \
-    do {                            \
-        strncpy(dst, src, size);    \
-        dst[size - 1] = 0;          \
-    } while (0)
-
-#define xstrlcpyn(dst, src, srclen, size) \
-    xstrlcpy(dst, src, xmin((srclen) + 1, size))
-
-#define xmin(a, b) ((a) < (b) ? (a) : (b))
-#define xmax(a, b) ((a) > (b) ? (a) : (b))
-
-#define STATIC_STRLEN(arr) (sizeof(arr) - 1)
 
 typedef unsigned char uchar;
@@ -164 +122 @@
 
 static int load_mlang();
-static csconv_t make_csconv(const char *name);
+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 is_unicode(int codepage);
 static int mbtowc_flags(int codepage);
 static int must_use_null_useddefaultchar(int codepage);
-static void check_utf_bom(rec_iconv_t *cd, ushort *wbuf, int *wbufsize);
 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)
@@ -180 +138 @@
 
 static HMODULE hwiniconv;
-static HMODULE hlastdll; /* keep dll loaded for efficiency (unnecessary?) */
 #endif
 
@@ -722 +679 @@
     if (ConvertINetString != NULL)
         return TRUE;
-    h = LoadLibrary(TEXT("mlang.dll"));
+    h = LoadLibrary("mlang.dll");
     if (!h)
         return FALSE;
@@ -741 +698 @@
     cd = (rec_iconv_t *)calloc(1, sizeof(rec_iconv_t));
     if (cd == NULL)
-    {
-        errno = ENOMEM;
         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);
-    errno = EINVAL;
+
     return (iconv_t)(-1);
 }
@@ -786 +744 @@
 win_iconv_open(rec_iconv_t *cd, const char *tocode, const char *fromcode)
 {
-    cd->from = make_csconv(fromcode);
-    cd->to = make_csconv(tocode);
-    if (cd->from.codepage == -1 || cd->to.codepage == -1)
+    if (!make_csconv(fromcode, &cd->from) || !make_csconv(tocode, &cd->to))
         return FALSE;
     cd->iconv_close = win_iconv_close;
@@ -811 +767 @@
     int outsize;
     int wsize;
-    DWORD mode;
+    DWORD frommode;
+    DWORD tomode;
     uint wc;
     compat_t *cp;
@@ -820 +777 @@
         if (outbuf != NULL && *outbuf != NULL && cd->to.flush != NULL)
         {
+            tomode = cd->to.mode;
             outsize = cd->to.flush(&cd->to, (uchar *)*outbuf, *outbytesleft);
             if (outsize == -1)
+            {
+                cd->to.mode = tomode;
                 return (size_t)(-1);
+            }
             *outbuf += outsize;
             *outbytesleft -= outsize;
         }
-        if (is_unicode(cd->from.codepage) && (cd->from.mode & UNICODE_MODE_SWAPPED))
-            cd->from.codepage ^= 1;
         cd->from.mode = 0;
         cd->to.mode = 0;
@@ -835 +794 @@
     while (*inbytesleft != 0)
     {
-        mode = cd->from.mode;
+        frommode = cd->from.mode;
+        tomode = cd->to.mode;
         wsize = MB_CHAR_MAX;
 
         insize = cd->from.mbtowc(&cd->from, (const uchar *)*inbuf, *inbytesleft, wbuf, &wsize);
         if (insize == -1)
+        {
+            cd->from.mode = frommode;
             return (size_t)(-1);
-
-        if (is_unicode(cd->from.codepage) && !(cd->from.mode & UNICODE_MODE_BOM_DONE))
-        {
-            check_utf_bom(cd, wbuf, &wsize);
-            cd->from.mode |= UNICODE_MODE_BOM_DONE;
         }
 
@@ -886 +843 @@
         if (outsize == -1)
         {
-            cd->from.mode = mode;
+            cd->from.mode = frommode;
+            cd->to.mode = tomode;
             return (size_t)(-1);
         }
@@ -899 +857 @@
 }
 
-static csconv_t
-make_csconv(const char *_name)
+static int
+make_csconv(const char *_name, csconv_t *cv)
 {
     CPINFOEX cpinfoex;
-    csconv_t cv;
     int use_compat = TRUE;
     int flag = 0;
-    char name[128];
+    char *name;
     char *p;
 
-    xstrlcpy(name, _name, sizeof(name));
+    name = xstrndup(_name, strlen(_name));
+    if (name == NULL)
+        return FALSE;
 
     /* check for option "enc_name//opt1//opt2" */
@@ -923 +882 @@
     }
 
-    cv.mode = 0;
-    cv.flags = flag;
-    cv.mblen = NULL;
-    cv.flush = NULL;
-    cv.compat = NULL;
-    cv.codepage = name_to_codepage(name);
-    if (cv.codepage == 1200 || cv.codepage == 1201)
-    {
-        cv.mbtowc = utf16_mbtowc;
-        cv.wctomb = utf16_wctomb;
-        if (_stricmp(name, "UTF-16") == 0 ||
-            _stricmp(name, "UTF16") == 0 ||
-            _stricmp(name, "UCS-2") == 0)
-            cv.flags |= FLAG_USE_BOM_ENDIAN;
-    }
-    else if (cv.codepage == 12000 || cv.codepage == 12001)
-    {
-        cv.mbtowc = utf32_mbtowc;
-        cv.wctomb = utf32_wctomb;
+    cv->mode = 0;
+    cv->flags = flag;
+    cv->mblen = NULL;
+    cv->flush = NULL;
+    cv->compat = NULL;
+    cv->codepage = name_to_codepage(name);
+    if (cv->codepage == 1200 || cv->codepage == 1201)
+    {
+        cv->mbtowc = utf16_mbtowc;
+        cv->wctomb = utf16_wctomb;
+        if (_stricmp(name, "UTF-16") == 0 || _stricmp(name, "UTF16") == 0)
+            cv->flags |= FLAG_USE_BOM;
+    }
+    else if (cv->codepage == 12000 || cv->codepage == 12001)
+    {
+        cv->mbtowc = utf32_mbtowc;
+        cv->wctomb = utf32_wctomb;
         if (_stricmp(name, "UTF-32") == 0 || _stricmp(name, "UTF32") == 0)
-            cv.flags |= FLAG_USE_BOM_ENDIAN;
-    }
-    else if (cv.codepage == 65001)
-    {
-        cv.mbtowc = kernel_mbtowc;
-        cv.wctomb = kernel_wctomb;
-        cv.mblen = utf8_mblen;
-    }
-    else if ((cv.codepage == 50220 || cv.codepage == 50221 || cv.codepage == 50222) && load_mlang())
-    {
-        cv.mbtowc = iso2022jp_mbtowc;
-        cv.wctomb = iso2022jp_wctomb;
-        cv.flush = iso2022jp_flush;
-    }
-    else if (cv.codepage == 51932 && load_mlang())
-    {
-        cv.mbtowc = mlang_mbtowc;
-        cv.wctomb = mlang_wctomb;
-        cv.mblen = eucjp_mblen;
-    }
-    else if (IsValidCodePage(cv.codepage)
-             && GetCPInfoEx(cv.codepage, 0, &cpinfoex) != 0)
-    {
-        cv.mbtowc = kernel_mbtowc;
-        cv.wctomb = kernel_wctomb;
+            cv->flags |= FLAG_USE_BOM;
+    }
+    else if (cv->codepage == 65001)
+    {
+        cv->mbtowc = kernel_mbtowc;
+        cv->wctomb = kernel_wctomb;
+        cv->mblen = utf8_mblen;
+    }
+    else if ((cv->codepage == 50220 || cv->codepage == 50221 || cv->codepage == 50222) && load_mlang())
+    {
+        cv->mbtowc = iso2022jp_mbtowc;
+        cv->wctomb = iso2022jp_wctomb;
+        cv->flush = iso2022jp_flush;
+    }
+    else if (cv->codepage == 51932 && load_mlang())
+    {
+        cv->mbtowc = mlang_mbtowc;
+        cv->wctomb = mlang_wctomb;
+        cv->mblen = eucjp_mblen;
+    }
+    else if (IsValidCodePage(cv->codepage)
+             && GetCPInfoEx(cv->codepage, 0, &cpinfoex) != 0)
+    {
+        cv->mbtowc = kernel_mbtowc;
+        cv->wctomb = kernel_wctomb;
         if (cpinfoex.MaxCharSize == 1)
-            cv.mblen = sbcs_mblen;
+            cv->mblen = sbcs_mblen;
         else if (cpinfoex.MaxCharSize == 2)
-            cv.mblen = dbcs_mblen;
+            cv->mblen = dbcs_mblen;
         else
-            cv.mblen = mbcs_mblen;
+            cv->mblen = mbcs_mblen;
     }
     else
     {
         /* not supported */
-        cv.codepage = -1;
-    }
+        free(name);
+        errno = EINVAL;
+        return FALSE;
+    }
+
     if (use_compat)
     {
-        switch (cv.codepage)
-        {
-        case 932: cv.compat = cp932_compat; break;
-        case 20932: cv.compat = cp20932_compat; break;
-        case 51932: cv.compat = cp51932_compat; break;
-        case 50220: case 50221: case 50222: cv.compat = cp5022x_compat; break;
-        }
-    }
-    return cv;
+        switch (cv->codepage)
+        {
+        case 932: cv->compat = cp932_compat; break;
+        case 20932: cv->compat = cp20932_compat; break;
+        case 51932: cv->compat = cp51932_compat; break;
+        case 50220: case 50221: case 50222: cv->compat = cp5022x_compat; break;
+        }
+    }
+
+    free(name);
+
+    return TRUE;
 }
 
@@ -1045 +1008 @@
 }
 
-static int
-is_unicode(int codepage)
-{
-    return (codepage == 1200 || codepage == 1201 ||
-            codepage == 12000 || codepage == 12001 ||
-            codepage == 65000 || codepage == 65001);
-}
-
 /*
  * Check if codepage is one of those for which the dwFlags parameter
@@ -1094 +1049 @@
 }
 
-static void
-check_utf_bom(rec_iconv_t *cd, ushort *wbuf, int *wbufsize)
-{
-    /* If we have a BOM, trust it, despite what the caller said */
-    if (wbuf[0] == 0xFFFE && (cd->from.flags & FLAG_USE_BOM_ENDIAN))
-    {
-        /* swap endian: 1200 <-> 1201 or 12000 <-> 12001 */
-        cd->from.codepage ^= 1;
-        cd->from.mode |= UNICODE_MODE_SWAPPED;
-        wbuf[0] = 0xFEFF;
-    }
-
-    /*
-     * Remove BOM.
-     * Don't do this if "to" is Unicode,
-     * except if "to" is UTF-8.
-     */
-    if (wbuf[0] == 0xFEFF && (!is_unicode(cd->to.codepage) || cd->to.codepage == 65001))
-        *wbufsize = 0;
-}
-
 static char *
 strrstr(const char *str, const char *token)
@@ -1127 +1061 @@
 }
 
+static char *
+xstrndup(const char *s, size_t n)
+{
+    char *p;
+
+    p = malloc(n + 1);
+    if (p == NULL)
+        return NULL;
+    memcpy(p, s, n);
+    p[n] = '\0';
+    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 *fromcode, const char *tocode)
+libiconv_iconv_open(rec_iconv_t *cd, const char *tocode, const char *fromcode)
 {
     HMODULE hlibiconv = NULL;
     HMODULE hmsvcrt = NULL;
-    char dllname[_MAX_PATH];
+    char *dllname;
     const char *p;
     const char *e;
@@ -1154 +1108 @@
         else if (e == NULL)
             e = p + strlen(p);
-        xstrlcpyn(dllname, p, e - p, sizeof(dllname));
+        dllname = xstrndup(p, e - p);
+        if (dllname == NULL)
+            return FALSE;
         hlibiconv = LoadLibrary(dllname);
+        free(dllname);
         if (hlibiconv != NULL)
         {
@@ -1166 +1123 @@
             break;
         }
-    }
-
-    if (hlastdll != NULL)
-    {
-        /* decrement reference count */
-        FreeLibrary(hlastdll);
-        hlastdll = NULL;
     }
 
@@ -1195 +1145 @@
             || cd->iconv == NULL || cd->_errno == NULL)
         goto failed;
-
-    /* increment reference count */
-    hlastdll = LoadLibrary(dllname);
 
     cd->cd = _iconv_open(tocode, fromcode);
@@ -1285 +1232 @@
     int len = IsDBCSLeadByteEx(cv->codepage, buf[0]) ? 2 : 1;
     if (bufsize < len)
-        return_error(EINVAL);
+        return seterror(EINVAL);
     return len;
 }
@@ -1304 +1251 @@
                  buf[1] >= 0x30 && buf[1] <= 0x39) len = 4;
         else
-            return_error(EINVAL);
+            return seterror(EINVAL);
         return len;
     }
     else
-        return_error(EINVAL);
+        return seterror(EINVAL);
 }
 
@@ -1324 +1271 @@
 
     if (len == 0)
-        return_error(EILSEQ);
+        return seterror(EILSEQ);
     else if (bufsize < len)
-        return_error(EINVAL);
+        return seterror(EINVAL);
     return len;
 }
@@ -1338 +1285 @@
     {
         if (bufsize < 2)
-            return_error(EINVAL);
+            return seterror(EINVAL);
         else if (!(0xA1 <= buf[1] && buf[1] <= 0xDF))
-            return_error(EILSEQ);
+            return seterror(EILSEQ);
         return 2;
     }
@@ -1346 +1293 @@
     {
         if (bufsize < 3)
-            return_error(EINVAL);
+            return seterror(EINVAL);
         else if (!(0xA1 <= buf[1] && buf[1] <= 0xFE)
                 || !(0xA1 <= buf[2] && buf[2] <= 0xFE))
-            return_error(EILSEQ);
+            return seterror(EILSEQ);
         return 3;
     }
@@ -1355 +1302 @@
     {
         if (bufsize < 2)
-            return_error(EINVAL);
+            return seterror(EINVAL);
         else if (!(0xA1 <= buf[0] && buf[0] <= 0xFE)
                 || !(0xA1 <= buf[1] && buf[1] <= 0xFE))
-            return_error(EILSEQ);
+            return seterror(EILSEQ);
         return 2;
     }
@@ -1374 +1321 @@
             (const char *)buf, len, (wchar_t *)wbuf, *wbufsize);
     if (*wbufsize == 0)
-        return_error(EILSEQ);
+        return seterror(EILSEQ);
     return len;
 }
@@ -1387 +1334 @@
 
     if (bufsize == 0)
-        return_error(E2BIG);
+        return seterror(E2BIG);
     if (!must_use_null_useddefaultchar(cv->codepage))
     {
@@ -1401 +1348 @@
     {
         if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
-            return_error(E2BIG);
-        return_error(EILSEQ);
+            return seterror(E2BIG);
+        return seterror(EILSEQ);
     }
     else if (usedDefaultChar)
-        return_error(EILSEQ);
+        return seterror(EILSEQ);
     else if (cv->mblen(cv, buf, len) != len) /* validate result */
-        return_error(EILSEQ);
+        return seterror(EILSEQ);
     return len;
 }
@@ -1433 +1380 @@
             (const char *)buf, &insize, (wchar_t *)wbuf, wbufsize);
     if (hr != S_OK || insize != len)
-        return_error(EILSEQ);
+        return seterror(EILSEQ);
     return len;
 }
@@ -1448 +1395 @@
             (const wchar_t *)wbuf, &wbufsize, tmpbuf, &tmpsize);
     if (hr != S_OK || insize != wbufsize)
-        return_error(EILSEQ);
+        return seterror(EILSEQ);
     else if (bufsize < tmpsize)
-        return_error(E2BIG);
+        return seterror(E2BIG);
     else if (cv->mblen(cv, (uchar *)tmpbuf, tmpsize) != tmpsize)
-        return_error(EILSEQ);
+        return seterror(EILSEQ);
     memcpy(buf, tmpbuf, tmpsize);
     return tmpsize;
@@ -1460 +1407 @@
 utf16_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize)
 {
+    int codepage = cv->codepage;
+
+    /* swap endian: 1200 <-> 1201 */
+    if (cv->mode & UNICODE_MODE_SWAPPED)
+        codepage ^= 1;
+
     if (bufsize < 2)
-        return_error(EINVAL);
-    if (cv->codepage == 1200) /* little endian */
+        return seterror(EINVAL);
+    if (codepage == 1200) /* little endian */
         wbuf[0] = (buf[1] << 8) | buf[0];
-    else if (cv->codepage == 1201) /* big endian */
+    else if (codepage == 1201) /* big endian */
         wbuf[0] = (buf[0] << 8) | buf[1];
+
+    if ((cv->flags & FLAG_USE_BOM) && !(cv->mode & UNICODE_MODE_BOM_DONE))
+    {
+        cv->mode |= UNICODE_MODE_BOM_DONE;
+        if (wbuf[0] == 0xFFFE)
+        {
+            cv->mode |= UNICODE_MODE_SWAPPED;
+            *wbufsize = 0;
+            return 2;
+        }
+        else if (wbuf[0] == 0xFEFF)
+        {
+            *wbufsize = 0;
+            return 2;
+        }
+    }
+
     if (0xDC00 <= wbuf[0] && wbuf[0] <= 0xDFFF)
-        return_error(EILSEQ);
+        return seterror(EILSEQ);
     if (0xD800 <= wbuf[0] && wbuf[0] <= 0xDBFF)
     {
         if (bufsize < 4)
-            return_error(EINVAL);
-        if (cv->codepage == 1200) /* little endian */
+            return seterror(EINVAL);
+        if (codepage == 1200) /* little endian */
             wbuf[1] = (buf[3] << 8) | buf[2];
-        else if (cv->codepage == 1201) /* big endian */
+        else if (codepage == 1201) /* big endian */
             wbuf[1] = (buf[2] << 8) | buf[3];
         if (!(0xDC00 <= wbuf[1] && wbuf[1] <= 0xDFFF))
-            return_error(EILSEQ);
+            return seterror(EILSEQ);
         *wbufsize = 2;
         return 4;
@@ -1488 +1458 @@
 utf16_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize)
 {
+    if ((cv->flags & FLAG_USE_BOM) && !(cv->mode & UNICODE_MODE_BOM_DONE))
+    {
+        int r;
+
+        cv->mode |= UNICODE_MODE_BOM_DONE;
+        if (bufsize < 2)
+            return seterror(E2BIG);
+        if (cv->codepage == 1200) /* little endian */
+            memcpy(buf, "\xFF\xFE", 2);
+        else if (cv->codepage == 1201) /* big endian */
+            memcpy(buf, "\xFE\xFF", 2);
+
+        r = utf16_wctomb(cv, wbuf, wbufsize, buf + 2, bufsize - 2);
+        if (r == -1)
+            return -1;
+        return r + 2;
+    }
+
     if (bufsize < 2)
-        return_error(E2BIG);
+        return seterror(E2BIG);
     if (cv->codepage == 1200) /* little endian */
     {
@@ -1503 +1491 @@
     {
         if (bufsize < 4)
-            return_error(E2BIG);
+            return seterror(E2BIG);
         if (cv->codepage == 1200) /* little endian */
         {
@@ -1522 +1510 @@
 utf32_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize)
 {
+    int codepage = cv->codepage;
     uint wc;
 
+    /* swap endian: 12000 <-> 12001 */
+    if (cv->mode & UNICODE_MODE_SWAPPED)
+        codepage ^= 1;
+
     if (bufsize < 4)
-        return_error(EINVAL);
-    if (cv->codepage == 12000) /* little endian */
+        return seterror(EINVAL);
+    if (codepage == 12000) /* little endian */
         wc = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
-    else if (cv->codepage == 12001) /* big endian */
+    else if (codepage == 12001) /* big endian */
         wc = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
+
+    if ((cv->flags & FLAG_USE_BOM) && !(cv->mode & UNICODE_MODE_BOM_DONE))
+    {
+        cv->mode |= UNICODE_MODE_BOM_DONE;
+        if (wc == 0xFFFE0000)
+        {
+            cv->mode |= UNICODE_MODE_SWAPPED;
+            *wbufsize = 0;
+            return 4;
+        }
+        else if (wc == 0x0000FEFF)
+        {
+            *wbufsize = 0;
+            return 4;
+        }
+    }
+
     if ((0xD800 <= wc && wc <= 0xDFFF) || 0x10FFFF < wc)
-        return_error(EILSEQ);
+        return seterror(EILSEQ);
     ucs4_to_utf16(wc, wbuf, wbufsize);
     return 4;
@@ -1541 +1551 @@
     uint wc;
 
+    if ((cv->flags & FLAG_USE_BOM) && !(cv->mode & UNICODE_MODE_BOM_DONE))
+    {
+        int r;
+
+        cv->mode |= UNICODE_MODE_BOM_DONE;
+        if (bufsize < 4)
+            return seterror(E2BIG);
+        if (cv->codepage == 12000) /* little endian */
+            memcpy(buf, "\xFF\xFE\x00\x00", 4);
+        else if (cv->codepage == 12001) /* big endian */
+            memcpy(buf, "\x00\x00\xFE\xFF", 4);
+
+        r = utf32_wctomb(cv, wbuf, wbufsize, buf + 4, bufsize - 4);
+        if (r == -1)
+            return -1;
+        return r + 4;
+    }
+
     if (bufsize < 4)
-        return_error(E2BIG);
+        return seterror(E2BIG);
     wc = utf16_to_ucs4(wbuf);
     if (cv->codepage == 12000) /* little endian */
@@ -1633 +1661 @@
             {
                 if (strncmp((char *)buf, iesc[i].esc, bufsize) == 0)
-                    return_error(EINVAL);
+                    return seterror(EINVAL);
             }
             else
@@ -1646 +1674 @@
         }
         /* not supported escape sequence */
-        return_error(EILSEQ);
+        return seterror(EILSEQ);
     }
     else if (buf[0] == iso2022_SO_seq[0])
@@ -1673 +1701 @@
     len = iesc[cs].len;
     if (bufsize < len)
-        return_error(EINVAL);
+        return seterror(EINVAL);
     for (i = 0; i < len; ++i)
         if (!(buf[i] < 0x80))
-            return_error(EILSEQ);
+            return seterror(EILSEQ);
     esc_len = iesc[cs].esc_len;
     memcpy(tmp, iesc[cs].esc, esc_len);
@@ -1700 +1728 @@
             (const char *)tmp, &insize, (wchar_t *)wbuf, wbufsize);
     if (hr != S_OK || insize != len + esc_len)
-        return_error(EILSEQ);
+        return seterror(EILSEQ);
 
     /* Check for conversion error.  Assuming defaultChar is 0x3F. */
@@ -1706 +1734 @@
     if (wbuf[0] == buf[0]
             && cv->mode != ISO2022_MODE(ISO2022JP_CS_ASCII, ISO2022_SI))
-        return_error(EILSEQ);
+        return seterror(EILSEQ);
 
     /* reset the mode for informal sequence */
@@ -1739 +1767 @@
             (const wchar_t *)wbuf, &wbufsize, tmp, &tmpsize);
     if (hr != S_OK || insize != wbufsize)
-        return_error(EILSEQ);
+        return seterror(EILSEQ);
     else if (bufsize < tmpsize)
-        return_error(E2BIG);
+        return seterror(E2BIG);
 
     if (tmpsize == 1)
@@ -1761 +1789 @@
         if (iesc[i].esc == NULL)
             /* not supported escape sequence */
-            return_error(EILSEQ);
+            return seterror(EILSEQ);
     }
 
@@ -1776 +1804 @@
     /* ascii should be converted from ascii */
     if (cs == ISO2022JP_CS_ASCII && !(wbuf[0] < 0x80))
-        return_error(EILSEQ);
+        return seterror(EILSEQ);
     else if (tmpsize < esc_len + len)
-        return_error(EILSEQ);
+        return seterror(EILSEQ);
 
     if (cv->mode == ISO2022_MODE(cs, shift))
@@ -1805 +1833 @@
 
     if (bufsize < len + esc_len)
-        return_error(E2BIG);
+        return seterror(E2BIG);
     memcpy(buf, tmp, len + esc_len);
     cv->mode = ISO2022_MODE(cs, shift);
@@ -1825 +1853 @@
             esc_len += iesc[ISO2022JP_CS_ASCII].esc_len;
         if (bufsize < esc_len)
-            return_error(E2BIG);
+            return seterror(E2BIG);
 
         esc_len = 0;
@@ -1933 +1961 @@
         r = iconv(cd, &pin, &inbytesleft, &pout, &outbytesleft);
         fwrite(outbuf, 1, sizeof(outbuf) - outbytesleft, stdout);
-        if (r == (size_t)(-1) && errno != EINVAL && errno != E2BIG)
+        if (r == (size_t)(-1) && errno != E2BIG && (errno != EINVAL || feof(in)))
         {
             perror("conversion error");