wcodecvt.cpp

Go to the documentation of this file.

 
#define _RWSTD_LIB_SRC
 
#include <rw/_defs.h>
 
 
// working around a Compaq C++ bug (see PR #26778)
#if __DECCXX_VER >= 60300000 && __DECCXX_VER < 60400000
 
#  include <stdarg.h>
_USING (std::va_list);
 
// override autoconfigured macro whose value is incorrect
// if <unistd.h> is #included before <iconv.h>
#  include <unistd.h>
#  define _RWSTD_NO_ICONV_CONST_CHAR
 
#endif   // Compaq C++ 6.3
 
#include <wchar.h>
#include <limits.h>
#include <locale.h>
#include <stdlib.h>   // for MB_CUR_MAX, mblen(), mbtowc()
#include <string.h>   // for memcmp()
#include <errno.h>
 
#if    defined (__SUNPRO_CC) && __SUNPRO_CC <= 0x540 \
    && (defined (__SunOS_5_8) || defined (__SunOS_5_9))
   // working around SunOS/SunPro header dependencies (see PR #26255)
#  undef _TIME_T
#endif   // SunPro <= 5.4 && SunOS 5.{8,9}
 
#include <loc/_codecvt.h>
#include <loc/_locale.h>
#include <loc/_localedef.h>
 
#include <rw/_traits.h>   // for _RWSTD_WCSLEN()
 
#include "iso2022.h"
#include "setlocale.h"
#include "use_facet.h"
 
 
// declare mbrlen() if it's not declared in the system headers
// but is known to be defined in the libc binary
#if defined (_RWSTD_NO_MBRLEN) && !defined (_RWSTD_NO_MBRLEN_IN_LIBC)
 
#  undef _RWSTD_NO_MBRLEN
 
extern "C" size_t
mbrlen (const char*, size_t, _RWSTD_MBSTATE_T*) _LIBC_THROWS();
 
#endif   // _RWSTD_NO_MBRLEN && !_RWSTD_NO_MBRLEN_IN_LIBC
 
 
// declare mblen() if it's not declared in the system headers
// but is known to be defined in the libc binary
#if defined (_RWSTD_NO_MBLEN) && !defined (_RWSTD_NO_MBLEN_IN_LIBC)
 
#  undef _RWSTD_NO_MBLEN
 
extern "C" int
mblen (const char*, size_t) _LIBC_THROWS();
 
#endif   // _RWSTD_NO_MBLEN && !_RWSTD_NO_MBLEN_IN_LIBC
 
 
// declare mbtowc() if it's not declared in the system headers
// but is known to be defined in the libc binary
#if defined (_RWSTD_NO_MBTOWC) && !defined (_RWSTD_NO_MBTOWC_IN_LIBC)
 
#  undef _RWSTD_NO_MBTOWC
 
extern "C" int
mbtowc (wchar_t*, const char*, size_t) _LIBC_THROWS();
 
#endif   // _RWSTD_NO_MBTOWC && !_RWSTD_NO_MBTOWC_IN_LIBC
 
 
// declare wcsrtombs() if it's not declared in the system headers
// but is known to be defined in the libc binary
#if defined (_RWSTD_NO_WCSRTOMBS) && !defined (_RWSTD_NO_WCSRTOMBS_IN_LIBC)
 
#  undef _RWSTD_NO_WCSRTOMBS
 
extern "C" size_t
wcsrtombs (char*, const wchar_t**, size_t, _RWSTD_MBSTATE_T*) _LIBC_THROWS();
 
#endif   // _RWSTD_NO_WCSRTOMBS && !_RWSTD_NO_WCSRTOMBS_IN_LIBC
 
 
// declare wcrtomb() if it's not declared in the system headers
// but is known to be defined in the libc binary
#if defined (_RWSTD_NO_WCRTOMB) && !defined (_RWSTD_NO_WCRTOMB_IN_LIBC)
 
#  undef _RWSTD_NO_WCRTOMB
 
extern "C" size_t
wcrtomb (char*, wchar_t, _RWSTD_MBSTATE_T*) _LIBC_THROWS();
 
#endif   // _RWSTD_NO_WCRTOMB && !_RWSTD_NO_WCRTOMB_IN_LIBC
 
 
// declare wctomb() if it's not declared in the system headers
// but is known to be defined in the libc binary
#if defined (_RWSTD_NO_WCTOMB) && !defined (_RWSTD_NO_WCTOMB_IN_LIBC)
 
#  undef _RWSTD_NO_WCTOMB
 
extern "C" {
 
_RWSTD_DLLIMPORT int
wctomb (char*, wchar_t) _LIBC_THROWS();
 
}   // extern "C"
 
#endif   // _RWSTD_NO_WCTOMB && !_RWSTD_NO_WCTOMB_IN_LIBC
 
 
// utf8 encoding maximum size
#undef  _UTF8_MB_CUR_MAX
#define _UTF8_MB_CUR_MAX   6
 
 
enum {
    // mask to retrieve ISO-2022 encoding type
    __rw_2022_mask   = 0x000f,
 
    // UCS-4 or UCS-2 (wchar_t width) encoding type
    __rw_ucs_be      = 0x000010,   // big-endian word and byte order
    __rw_ucs_le      = 0x000040,   // little-endian word and byte order
    __rw_ucs         = 0x0000f0,   // platform-endianness
 
    // UCS-4 encoding type
    __rw_ucs4_be     = 0x000100,   // big-endian word and byte order
    __rw_ucs4_be_le  = 0x000200,   // big-endian word, little-endian byte order
    __rw_ucs4_le     = 0x000400,   // little-endian word and byte order
    __rw_ucs4_le_be  = 0x000800,   // little-endian word, big-endian byte order
    __rw_ucs4        = 0x000f00,   // platform-endianness
 
    // UCS-2 encoding type
    __rw_ucs2_be     = 0x001000,   // big-endian word and byte order
    __rw_ucs2_le     = 0x004000,   // little-endian word and byte order
    __rw_ucs2        = 0x00f000,   // platform-endianness
 
    // UTF encoding type
    __rw_utf8        = 0x010000,   // UTF-8
    __rw_utf16_be    = 0x020000,   // UTF-16, big-endian byte order
    __rw_utf16_le    = 0x040000,   // UTF-16, little-endian byte order
    __rw_utf16       = 0x060000,   // UTF-16, platform endianness
 
    __rw_strict      = 0x100000,   // do strict UCS validation
 
    __rw_use_libc    = 0x200000,   // always use libc locale
 
    // mask to retrieve UCS encoding type
    __rw_ucs_mask    =   __rw_ucs_be | __rw_ucs_le | __rw_ucs
                       | __rw_ucs4_be | __rw_ucs4_le
                       | __rw_ucs4_be_le | __rw_ucs4_le_be | __rw_ucs4
                       | __rw_ucs2_be | __rw_ucs2_le | __rw_ucs2,
 
    // mask to retrieve UTF encoding type
    __rw_utf_mask    =   __rw_utf8 | __rw_utf16_be | __rw_utf16_le
};
 
#define ISO2022_TYPE(x)   ((x) & __rw_2022_mask)
 
// helper macros to retrieve the type of an UCS and UTF encoding
#define UCS_TYPE(x)       ((x) & __rw_ucs_mask)
#define UTF_TYPE(x)       ((x) & __rw_utf_mask)
 
#define IS_UCS(x)         (UCS_TYPE (x) == __rw_ucs)
#define IS_UCS_BE(x)      (UCS_TYPE (x) == __rw_ucs_be)
#define IS_UCS_LE(x)      (UCS_TYPE (x) == __rw_ucs_le)
#define IS_UCS_BE_LE(x)   (UCS_TYPE (x) == __rw_ucs_be_le)
#define IS_UCS_LE_BE(x)   (UCS_TYPE (x) == __rw_ucs_le_be)
 
#define IS_UTF8(x)        (UCS_TYPE (x) == __rw_utf8)
#define IS_UTF16(x)       (UCS_TYPE (x) == __rw_utf16)
#define IS_UTF16_BE(x)    (UCS_TYPE (x) == __rw_utf16_be)
#define IS_UTF16_LE(x)    (UCS_TYPE (x) == __rw_utf16_le)
 
// evaluates to 1 if the facet should use the libc locale, 0 otherwise
#define USE_LIBC(impl, x) \
    ((!(impl) || ((x) & __rw_use_libc)) && !(UCS_TYPE (x) || UTF_TYPE (x)))
 
 
// _RWSTD_MBSTATE_T macro might expand to char* (on AIX)
typedef _RWSTD_MBSTATE_T StateT;
 
 
_RWSTD_NAMESPACE (__rw) {
 
 
static const struct {
    const char *mod;
    int         flags;
} __rw_ucsmods[] = {
    { "UCS",         __rw_ucs },
    { "UCS-4",       __rw_ucs4 },
    { "UCS-2",       __rw_ucs2 },
    { "UCS-4-BE",    __rw_ucs4_be },
    { "UCS-4-LE",    __rw_ucs4_le },
    { "UCS-2-BE",    __rw_ucs2_be },
    { "UCS-2-LE",    __rw_ucs2_le },
    { "UCS-4-BE-LE", __rw_ucs4_be_le },
    { "UCS-4-LE-BE", __rw_ucs4_le_be },
    { "UCS-BE",      __rw_ucs_be },
    { "UCS-LE",      __rw_ucs_le }
};
 
static const size_t
__rw_n_ucsmods = sizeof __rw_ucsmods / sizeof *__rw_ucsmods;
 
 
static inline int
__rw_mbsinit (const StateT *psrc)
{
#ifndef _RWSTD_NO_MBSINIT
 
    return mbsinit (psrc);
 
#else   // if defined (_RWSTD_NO_MBSINIT)
 
    // commented out to work around an HP aCC 1.21 bug
    /* static */ const StateT state = StateT ();
    return !psrc || 0 == memcmp (psrc, &state, sizeof state);
 
#endif   // _RWSTD_NO_MBSINIT
 
}
 
 
#undef min
#define min(a, b)   ((a) < (b) ? (a) : (b))
#undef max
#define max(a,b)    ((a) > (b)) ? (a) : (b)
 
 
#ifndef _RWSTD_NO_WCHAR_T
 
// behaves just like mbrlen(), except that if the character pointed to
// by `str' is the NUL character and `emax' is non-zero, the function
// returns 1
static inline size_t
__rw_libc_mbrlen (_RWSTD_MBSTATE_T &state,
                  const char       *str,
                  size_t            emax)
{
    _RWSTD_ASSERT (0 != str);
 
    if ('\0' == *str)
        return 0 < emax;
 
#ifndef _RWSTD_NO_MBRLEN
 
    // `emax' is the maximum number of elements of type char in `str'
    return mbrlen (str, emax, &state);
 
#elif !defined (_RWSTD_NO_MBLEN)
 
    _RWSTD_UNUSED (state);
 
    return mblen (str, emax);
 
#else   // if defined (_RWSTD_NO_MBLEN)
 
    _RWSTD_UNUSED (state);
 
    // this is bogus but it's the best we can do given the absence
    // of libc support for this functionality (more likely than not,
    // this code will never end up getting executed because we'll
    // never get this far)
    const char *next = str;
 
    for (; *next && emax; ++next, --emax);
        
    return next - str;
 
#endif   // _RWSTD_NO_MBRLEN
 
}
 
 
// does a simple transliteration of the UTF-8 encoded character string
static unsigned int
__rw_xlit (const _RW::__rw_codecvt_t* impl,
           const char *utf8s, size_t sz)
{
    const unsigned int* const ptbls = impl->get_xliteration_tab ();
 
    unsigned int index = 0;
 
    for (const unsigned int* ptbl = ptbls; sz; --sz, ++utf8s) {
 
        typedef unsigned char UChar;
 
        index = ptbl [UChar (*utf8s)];
 
        if (_RWSTD_UINT_MAX == index) 
            // transliteration not provided for this character
            return 0;
 
        if (index & 0x80000000) {
            ptbl = ptbls + 256 * index;
        }
        else {
            // utf-8 string representation should end here
            _RWSTD_ASSERT (0 == sz);
        }
    }
 
    return index & 0x80000000 ? 0 : index;
}
 
 
static _STD::codecvt_base::result
__rw_libc_do_in (_RWSTD_MBSTATE_T &state,
                 const char       *from, 
                 const char       *from_end,
                 const char*      &from_next,
                 wchar_t          *to, 
                 wchar_t          *to_limit,
                 wchar_t*         &to_next)
{
    _RWSTD_ASSERT (from <= from_end);
    _RWSTD_ASSERT (to <= to_limit);
 
    _STD::codecvt_base::result res = _STD::codecvt_base::ok;
 
    // compute the length of the source sequence in bytes and
    // the size of the destination buffer in wide characters
    size_t src_len  = from_end - from;
    size_t dst_size = to_limit - to;
 
    // set the initial values to the source and destination pointers
    const char* psrc = from;
    wchar_t*    pdst = to;
 
    while (dst_size && src_len) {
 
        // the number of bytes that form the next multibyte character
        size_t nbytes;
 
#ifndef _RWSTD_NO_MBRTOWC
        nbytes = mbrtowc (pdst, psrc, src_len, &state);
#elif !defined (_RWSTD_NO_MBTOWC)
        nbytes = mbtowc (pdst, psrc, src_len);
#else
        nbytes = _RWSTD_SIZE_MAX;
#endif
 
        // -1 indicates an invalid sequence (i.e., error)
        if (nbytes == size_t (-1)) {
        res = _STD::codecvt_base::error;
            break;
        }
 
        // -2 indicates an ambiguous but valid subsequence
        // (i.e., ok)
        if (nbytes == size_t (-2))
            break;
 
        // 0 indicates the NUL character (skip over it)
        if (nbytes == 0) 
            ++nbytes;
 
        // > 0 indicates the number of bytes in the successfully
        // converted multibyte character
        psrc    += nbytes;
        src_len -= nbytes;
        ++pdst;
        --dst_size;
    }
 
    // adjust "next" pointers
    from_next = psrc;
    to_next   = pdst;
 
    // if the conversion has exhausted all space in the destination
    // range AND there are more COMPLETE characters in the source
    // range then we have a "partial" conversion
    if (res == _STD::codecvt_base::ok && src_len && !dst_size) {
        _RWSTD_MBSTATE_T tmp_state = state;
        size_t tmp = __rw_libc_mbrlen (tmp_state, psrc, src_len);
        if (tmp < size_t (-2))
            res = _STD::codecvt_base::partial;
    }
 
    return res;
}
 
 
static _STD::codecvt_base::result
__rw_libc_do_out (_RWSTD_MBSTATE_T &state,
                  const wchar_t    *from, 
                  const wchar_t    *from_end,
                  const wchar_t*   &from_next,
                  char             *to, 
                  char             *to_limit,
                  char*            &to_next)
{
    _RWSTD_ASSERT (from <= from_end);
    _RWSTD_ASSERT (to <= to_limit);
 
    // verify that both ranges are valid
    _RWSTD_ASSERT (from && from_end || !from && !from_end);
    _RWSTD_ASSERT (to && to_limit || !to && !to_limit);
 
    // set the (possibly uninitialized) next pointers
    // to point to the beginning of each sequence
    from_next = from;
    to_next   = to;
 
    // save the value of MB_CUR_MAX and avoid repeatedly using
    // the macro for efficiency (it may expand to a function call)
    const size_t mb_cur_max = size_t (MB_CUR_MAX);
 
    // the result of conversion
    _STD::codecvt_base::result res = _STD::codecvt_base::ok;
 
    // the size of the available space in the destination range
    size_t dst_free = size_t (to_limit - to_next);
 
    // small temporary buffer used when the space in the destination
    // buffer is less than MB_CUR_MAX
    char buff [_RWSTD_MB_LEN_MAX];
 
    // convert the source sequence one character at a time
    for ( ; from_next < from_end; ++from_next) {
 
        // since there is no guarantee that the converted internal
        // character would fit in the remaining space in the
        // destination buffer, use the small local buffer if
        // the remaining space is less that the longest external
        // multibyte character (i.e., MB_CUR_MAX)
        char* const tmpdst = dst_free < mb_cur_max ? buff : to_next;
 
        // save the state in case it's changed but the converted
        // character doesn't fit in the destination buffer
        const _RWSTD_MBSTATE_T save_state = state;
 
        // the number of bytes in the resulting multibyte character
        // sequence, not including the terminating NUL
        size_t dst_len = 0;
 
#ifndef _RWSTD_NO_WCRTOMB
 
        // convert the next source character (note that it would be
        // unsafe to use wcsrtombs() since the source sequence may
        // not be NUL terminated)
        dst_len = wcrtomb (tmpdst, *from_next, &state);
 
#elif !defined (_RWSTD_NO_WCTOMB)
 
        _RWSTD_UNUSED (state);
        dst_len = wctomb (tmpdst, *from_next);
 
#else   // error
 
        _RWSTD_UNUSED (state);
        dst_len = _RWSTD_SIZE_MAX;
 
#endif   // _RWSTD_NO_WCRTOMB, _RWSTD_NO_WCTOMB
 
        // -1 is returned as an indication of an illegal sequence
        if (_RWSTD_SIZE_MAX == dst_len) {
            res = _STD::codecvt_base::error;
            break;
        }
 
        // if the multibyte sequence is the NUL character
        // adjust the result by one (i.e., the length of
        // the multibyte NUL character)
        if (0 == dst_len)
            ++dst_len;
 
        // if the remaining space in the destination sequence
        // is less than MB_CUR_MAX, check to see if the multibyte
        // character will fit in there
        if (dst_free < mb_cur_max) {
            if (dst_free < dst_len) {
                // the source character converted to a multibyte
                // character whose length in bytes is greater than
                // the available space in the destination sequence
 
                // restore the state to the value prior to the last
                // conversion and return partial
                state = save_state;
                res   = _STD::codecvt_base::partial;
                break;
            } 
 
            // the destination sequence has sufficient space
            // for the multibyte character
            memcpy (to_next, buff, dst_len);
        }
 
        // advance the destination next pointer one past the end
        // of the multibyte character and decrement the size of
        // of the available space in the destination sequence
        to_next  += dst_len;
        dst_free -= dst_len;
    }
 
    return res;
}
 
 
static _STD::codecvt_base::result
__rw_libc_do_unshift (_RWSTD_MBSTATE_T& state, char*& to_next, char* to_limit)
{
    // save current state
    _RWSTD_MBSTATE_T tmp_state = state;
 
    // use libc locale to obtain the shift sequence
    char tmp [_RWSTD_MB_LEN_MAX];
 
    size_t ret;
 
#ifndef _RWSTD_NO_WCRTOMB
    ret = wcrtomb (tmp, wchar_t (0), &state);
#elif !defined (_RWSTD_NO_WCTOMB)
    ret = wctomb (tmp, wchar_t (0));
#else
    ret = _RWSTD_SIZE_MAX;
#endif
 
    if (_RWSTD_SIZE_MAX == ret)
        return  _STD::codecvt_base::error;
 
    if (ret > size_t (to_limit - to_next)) {
        // restore the state and return partial
        state = tmp_state;
        return _STD::codecvt_base::partial;
    }
 
    // copy the shift sequence
    memcpy (to_next, tmp, ret);
    to_next += ret;
    return _STD::codecvt_base::ok;
}
 
 
// checks a UTF-8 sequence representing a single character
// for validity by performing a number of computationally
// relatively expensive tests; used only in strict mode
static bool
__rw_utf8validate (const char* from, size_t nbytes)
{
    _RWSTD_ASSERT (0 != from);
    _RWSTD_ASSERT (1 < nbytes && 7 > nbytes);
 
    const unsigned char* const byte =
        _RWSTD_REINTERPRET_CAST (const unsigned char*, from);
 
    // check for overlong sequences with the bit pattern shown below
 
    // 2 bytes: 1100 000x (10xx xxxx)
    if (2 == nbytes && (byte [0] & 0xfeU) == 0xfeU)
        return false;
 
    // 3 bytes: 1110 0000 100x xxxx (10xx xxxx)
    if (3 == nbytes) {
 
        // first detect and reject all overlong sequences
        if (0xe0U == byte [0] && (byte [1] & 0xe0U) == 0x80U)
            return false;
 
        // detect and reject UTF-16 surrogate pairs, i.e., UCS characters
        // in the range [U+D800, U+DFFF] (i.e., inclusive of both ends),
        // i.e., "\xed\xa0\x80" through "\xed\xbf\xbf", as well as U+FFFE
        // and U+FFFF, i.e., "\xef\xbf\xbe" and "\xef\xbf\xbf"
        if (0xedU == byte [0]) {
            if (byte [1] >= 0xa0)
                return false;
        }
        else if (   0xefU == byte [0] && 0xbfU == byte [1]
                 && 0xbeU <= byte [2] && 0xbfU >= byte [2])
            return false;
    }
 
    // 4 bytes: 1111 0000 1000 xxxx (10xx xxxx 10xx xxxx)
    if (4 == nbytes && 0xf0U == byte [0] && (byte [1] & 0xf0U) == 0x80U)
        return false;
 
    // 5 bytes: 11111 000 1000 0xxx (10xxx xxx 10xx xxxx 10xx xxxx)
    if (5 == nbytes && 0xf8U == byte [0] && (byte [1] & 0xf8U) == 0x80U)
        return false;
 
    // 6 bytes: 1111 1100 1000 00xx (10xx xxxx 10xx xxxx 10xxx xxx 10xxx xxx)
    if (6 == nbytes && 0xfcU == byte [0] && (byte [1] & 0xfcU) == 0x80U)
        return false;
 
    for (size_t i = 1; i < nbytes; ++i) {
        if ((byte [i] & ~0x3fU) != 0x80U)
            return false;   // invalid byte
    }
 
    return true;
}
 
 
static _STD::codecvt_base::result
__rw_libstd_do_in (const char                *from_end,
                   const char               *&from_next,
                   wchar_t                   *to_limit,
                   wchar_t                  *&to_next,
                   int                        flags,
                   const _RW::__rw_codecvt_t *impl)
{
    // use UCS as the internal encoding if `impl' is 0
    // (i.e., if the codecvt database is not available)
    if (!impl && !UCS_TYPE (flags))
        flags |= __rw_ucs;
 
    const bool use_ucs    = 0 != UCS_TYPE (flags);
    const bool strict_utf = 0 != (flags & __rw_strict);
 
    _STD::codecvt_base::result res;
    
    for (const unsigned* const tab = impl ? impl->n_to_w_tab () : 0; ; ) {
 
        if (from_next == from_end) {
            res = _STD::codecvt_base::ok;
            break;
        }
 
        if (to_next == to_limit) {
            res = _STD::codecvt_base::partial;
            break;
        }
 
        const char* from = from_next;
 
        wchar_t wchar;
 
        if (impl) {
 
            // compute the offset of the multibyte character into
            // one of the tables (UCS or wchar_t) where the value
            // of the internal character corresponding to the
            // multibyte character is stored
            const unsigned off = __rw_mbtowco (tab, from, from_end);
 
            if (_RWSTD_UINT_MAX == off) {
                // the source sequence forms neither a valid multibyte
                // character, nor is it an initial subsequence of one
                res = _STD::codecvt_base::error;
                break;
            }
 
            if (from == from_next) {
                // the source sequence forms an incomplete initial
                // subsequence of a valid multibyte character
                res = _STD::codecvt_base::partial;
                break;
            }
 
            wchar = use_ucs ? impl->get_ucs4_at_offset (off)
                            : impl->get_internal_at_offset (off);
        }
        else {
            // use an algorithmic transformation from UTF-8 to UCS-4
            _RWSTD_INT32_T wi;
 
            const char* tmp = __rw_utf8toucs4 (&wi, from, from_end);
 
            if (strict_utf && tmp) {
 
                // perform additional expensive UTF-8 validation
                const size_t utf_len = tmp - from;
 
                if (utf_len > 1 && !__rw_utf8validate (from, utf_len))
                    tmp = 0;
            }
 
            from = tmp;
 
            if (!from) {
                // the source sequence forms neither a valid UTF-8
                // character, nor is it an initial subsequence of one
                res = _STD::codecvt_base::error;
                break;
            }
 
            if (from_next == from) {
                // the source sequence forms an incomplete initial
                // subsequence of a valid UTF-8 character
                res = _STD::codecvt_base::partial;
                break;
            }
 
            wchar = wchar_t (wi);
        }
 
        from_next  = from;
        *to_next++ = wchar;
    }
 
    return res;
}
 
 
static _STD::codecvt_base::result
__rw_libstd_do_out (const wchar_t             *from,
                    const wchar_t             *from_end,
                    const wchar_t            *&from_next,
                    char                      *to,
                    char                      *to_limit,
                    char                     *&to_next,
                    int                        flags,
                    const _RW::__rw_codecvt_t *impl)
{
    // final result of the transformation
    _STD::codecvt_base::result res = _STD::codecvt_base::ok;
 
    const bool use_ucs = IS_UCS (flags);
 
    // utf8 temporary buffer
    char utfbuf [_UTF8_MB_CUR_MAX + 1];
 
    const unsigned int* const tbl =
        impl ? use_ucs ? impl->utf8_to_ext_tab () : impl->w_to_n_tab () : 0;
 
    for (from_next = from, to_next = to; from_next != from_end; ++from_next) {
 
        if (to_next == to_limit) {
            res = _STD::codecvt_base::partial;
            break;
        }
 
        if (flags & __rw_strict) {
 
            // in strict mode check wide character for validity
            // (i.e., diagnose surrogate pairs as illegal)
 
            typedef _RWSTD_UWCHAR_INT_T WIntT;
 
            // convert wchar_t to the unsigned form of its underlying
            // integer type that's safe in arithmetic comaprisons and
            // doesn't generate signed/unsigned compiler warnings
            const WIntT wi = _RWSTD_STATIC_CAST (WIntT, *from_next);
 
            if (   WIntT (0xd800U) <= wi && wi <= WIntT (0xdfffU)
                || WIntT (0xfffeU) <= wi && wi <= WIntT (0xffffU)) {
                res = _STD::codecvt_base::error;
                break;
            }
        }
 
        // compute the number of bytes available in the destination sequence
        const size_t bytes_avail = to_limit - to_next;
 
        size_t utf8_len;
 
        if (impl) {
 
            // encode the wide character value in UTF-8 as if it was UCS
            utf8_len = __rw_itoutf8 (*from_next, utfbuf);
 
            // convert the UTF-8 encoded wchar_t value into
            // into the external representation
            const char* utf = utfbuf;
            unsigned    off = __rw_mbtowco (tbl, utf, utf + utf8_len);
 
            // FIXME: block below has been disabled but is being compiled
            // to avoid syntax regressions; it might produce "unreachable
            // code" warnings with some compilers
            if (0 /* disbled */ && _RWSTD_UINT_MAX == off) {
                // try transliteration
                off = __rw_xlit (impl, utfbuf, utf8_len);
                if (0 == off) {
                    res = _STD::codecvt_base::error;
                    break;
                }
            }
 
            if (_RWSTD_UINT_MAX == off) {
                // the sequence does not form a valid character
                res = _STD::codecvt_base::error;
                break;
            }
 
            if (utf == utfbuf) {
                // the next multibyte character position was incomplete
                res = _STD::codecvt_base::ok;
                break;
            }
 
            // get the UTF-8 sequence corresponding to the wide character
            utf = _RWSTD_REINTERPRET_CAST (const char*, impl + 1) + off;
 
            // check that there's enough space in the destination sequence
            utf8_len = *utf ? strlen (utf) : 1;
            if (bytes_avail < utf8_len) {
                res = _STD::codecvt_base::partial;
                break;
            }
 
            // copy the UTF-8 sequence into the destination sequence
            memcpy (to_next, utf, utf8_len);
        }
        else  {
 
            // codeset is UTF-8
            // external encoding is UTF-8, so no lookup is necessary
 
            // encode the wide char in the destination buffer if it fits
 
            if (bytes_avail < _UTF8_MB_CUR_MAX) {
                utf8_len = __rw_itoutf8 (*from_next, utfbuf);
 
                if (bytes_avail < utf8_len) {
                    res = _STD::codecvt_base::partial;
                    break;
                }
 
                // move from temporary buffer to destination buffer
                memcpy (to_next, utfbuf, utf8_len);
            }
            else
                utf8_len = __rw_itoutf8 (*from_next, to_next);
        }
 
        to_next += utf8_len;
    }
 
    return res;
}
 
 
// implements do_length() on top of libc mbrlen()
static size_t 
__rw_libc_do_length (_RWSTD_MBSTATE_T &state,
                     const char       *from,
                     const char       *from_end,
                     size_t            imax)
{
    const char* const from_begin = from;
 
    for ( ; imax && from < from_end; --imax) {
 
        // compute the maximum length (in bytes) of the multibyte
        // character sequence starting at `from'
        size_t nbytes = from_end - from;
        if (_RWSTD_MB_LEN_MAX < nbytes)
            nbytes = _RWSTD_MB_LEN_MAX;
 
        // get the number of bytes used to encode the next multibyte
        // character (including NUL), or -1 if the sequence at `from'
        // does not form a valid multibyte character (and -2 if it's
        // an incomplete subsequence of a valid multibyte character)
        nbytes = __rw_libc_mbrlen (state, from, nbytes);
 
        // stop when an invalid or incomplete character is encountered
        if (nbytes >= size_t (-2))
            break;
 
        from += nbytes;
    }
 
    // return the number of bytes (extern_type characters) in the sequence
    return from - from_begin;
}
 
 
// implements do_length() for UTF-8@UCS
static size_t
__rw_utf8_do_length (const char    *from,
                     const char    *from_end,
                     size_t         imax,
                     int            flags)
{
    _RWSTD_ASSERT (from <= from_end);
 
    const bool strict_utf = 0 != (flags & __rw_strict);
 
    const char *from_next = from;
 
    // count successive utf8 characters - this is a UTF-8 encoding
    for ( ; imax && from_next < from_end; --imax) {
 
        // use an algorithmic transformation from UTF-8 to UCS-4
        _RWSTD_INT32_T wi;
 
        const char* const next = __rw_utf8toucs4 (&wi, from_next, from_end);
 
        // stop if the character is either invalid or incomplete
        if (!next || next == from_next)
            break;
 
        _RWSTD_ASSERT (from_next <= next);
        _RWSTD_ASSERT (next <= from_end);
 
        // perform additional expensive UTF-8 validation in strict mode
        const size_t utf_len = next - from_next;
 
        if (   strict_utf
            && utf_len > 1 && !__rw_utf8validate (from_next, utf_len))
            break;
 
        from_next = next;
    }
 
    // return the number of extern characters
    return from_next - from;
}
 
 
// 22.2.1.5.2  [lib.locale.codecvt.virtuals]
// including the resolution of lwg issue 305
//
// -9-  Preconditions: (from<=from_end) well-defined and true; state
//      initialized, if at the beginning of a sequence, or else equal
//      to the result of converting the preceding characters in the
//      sequence.
//
// -9a- Effects: The effect on the state argument is "as if" it called
//      do_in(state, from, from_end, from, to, to+max, to) for to pointing
//      to a buffer of at least max elements.
//
// -10- Returns: (from_next-from) where from_next is the largest value
//      in the range [from,from_end] such that the sequence of values
//      in the range [from,from_next) represents max or fewer valid
//      complete characters of type internT. The instantiation
//      codecvt<char, char, mbstate_t> returns the lesser of max
//      and (from_end-from).
 
// Note that the function returns the number of externT characters
// (i.e., those of type char for the required instantiations).
 
static size_t
__rw_libstd_do_length (const char*                from,
                       const char*                from_end, 
                       size_t                     imax,
                       int                        flags,
                       const _RW::__rw_codecvt_t* impl)  
{
    // use UCS as the internal encoding if `impl' is 0
    // (i.e., if the codecvt database is not available)
    if (!impl && !UCS_TYPE (flags))
        flags |= __rw_ucs;
 
    const bool use_ucs = 0 != UCS_TYPE (flags);
 
    if (impl) {
 
        const char* from_next = from;
 
        const unsigned char* const limit =
            _RWSTD_REINTERPRET_CAST (const unsigned char*, from_end);
 
        const unsigned int* const tbls =
            use_ucs ? impl->utf8_to_ext_tab () : impl->n_to_w_tab ();
 
        _RWSTD_ASSERT (tbls);
 
        // `imax' is the maximum number of intern_type characters
        for ( ; imax && from_next < from_end; --imax) {
 
            const unsigned char* next =
                _RWSTD_REINTERPRET_CAST (const unsigned char*, from_next);
 
            for (const unsigned* tbl = tbls; tbl [*next] & 0x80000000; ) {
 
                // check if the extern character is valid
                if (_RWSTD_UINT_MAX == tbl [*next]) 
                    return from_next - from;
                
                // the value here is the table index
                const unsigned index = tbl [*next] & 0x7fffffff;
                tbl = tbls + 256 * index;
 
                ++next;
 
                if (next == limit) 
                    return from_next - from;
            }
 
            from_next = _RWSTD_REINTERPRET_CAST (const char*, next + 1);
        }
 
        // return the number of extern characters
        return from_next - from;
    }
 
    return __rw_utf8_do_length (from, from_end, imax, flags);
}
 
}  //  namespace __rw
 
 
_RWSTD_NAMESPACE (std) {
        
 
_RW::__rw_facet_id codecvt<wchar_t, char, _RWSTD_MBSTATE_T>::id;
 
 
/* explicit */ codecvt<wchar_t, char, _RWSTD_MBSTATE_T>::
codecvt (size_t __ref /* = 0 */)
    : _RW::__rw_facet (__ref)
{
    // no-op
}
 
 
// outlined to avoid generating a vtable in each translation unit
// that uses the class
/* virtual */ codecvt<wchar_t, char, _RWSTD_MBSTATE_T>::
~codecvt ()
{
    // no-op
}
 
 
/* virtual */ bool
codecvt<wchar_t, char, _RWSTD_MBSTATE_T>::
do_always_noconv () const _THROWS (())
{
    return false;   // conversion always necessary
}
 
 
/* virtual */ int
codecvt<wchar_t, char, _RWSTD_MBSTATE_T>::
do_encoding () const _THROWS (())
{
    // 22.2.1.5.2 p6    1(ext.) <=> 1(int.)
    return 1;   
}
 
 
/* virtual */ int
codecvt<wchar_t, char, _RWSTD_MBSTATE_T>::
do_max_length () const _THROWS (())
{
    return 1;
}
 
 
/* virtual */ codecvt_base::result
codecvt<wchar_t, char, _RWSTD_MBSTATE_T>::
do_out (state_type         &state,
        const intern_type  *from,
        const intern_type  *from_end,
        const intern_type *&from_next,
        extern_type        *to,
        extern_type        *to_end,
        extern_type       *&to_next) const
{
    // 22.2.1.5.2, p1 - preconditions
    _RWSTD_ASSERT (from <= from_end);
    _RWSTD_ASSERT (to   <= to_end);
 
    // verify that both ranges are valid
    _RWSTD_ASSERT (from && from_end || !from && !from_end);
    _RWSTD_ASSERT (to && to_end || !to && !to_end);
 
    // next pointers must always be set before returning, even on error
    from_next = from;
    to_next   = to;
 
#ifdef _RWSTDDEBUG
 
    // verify that the conversion state is valid
    const int mbstate_valid = _RW::__rw_mbsinit (&state);
 
    _RWSTD_ASSERT (0 != mbstate_valid);
 
#else   // if !defined (_RWSTDDEBUG)
 
    _RWSTD_UNUSED (state);
 
#endif   // _RWSTDDEBUG
 
    // copy internal sequence to external
    for (; from_next != from_end && to_next != to_end; ++from_next, ++to_next)
        // prevent conversion problems due to char signedness
        *to_next = _RWSTD_STATIC_CAST (unsigned char, *from_next);
 
    // Table 53, and lwg issue 382: do_out() returns partial
    // if not all source characters could be converted (e.g.,
    // because the destination range is full)
    return from_next == from_end ? ok : partial;
}
 
 
/* virtual */ codecvt_base::result
codecvt<wchar_t, char, _RWSTD_MBSTATE_T>::
do_in (state_type         &state,
       const extern_type  *from,
       const extern_type  *from_end,
       const extern_type *&from_next,
       intern_type        *to,
       intern_type        *to_end,
       intern_type       *&to_next) const
{
    // 22.2.1.5.2, p1 - preconditions
    _RWSTD_ASSERT (from <= from_end);
    _RWSTD_ASSERT (to   <= to_end);
 
    // verify that both ranges are valid
    _RWSTD_ASSERT (from && from_end || !from && !from_end);
    _RWSTD_ASSERT (to && to_end || !to && !to_end);
 
    // next pointers must always be set before returning, even on error
    from_next = from;
    to_next   = to;
 
    const int mbstate_valid = _RW::__rw_mbsinit (&state);
 
    _RWSTD_ASSERT (0 != mbstate_valid);
    if (!mbstate_valid)
        return error;
 
    // copy external sequence to internal
    for (; from_next != from_end && to_next != to_end;
         ++from_next, ++to_next) {
        // prevent conversion problems due to char signedness
        *to_next = _RWSTD_STATIC_CAST (unsigned char, *from_next);
    }
 
    return from_next == from_end ? ok : partial;
}
 
 
/* virtual */ codecvt_base::result
codecvt<wchar_t, char, _RWSTD_MBSTATE_T>::
do_unshift (state_type   &state,
            extern_type  *to,
            extern_type  *to_end,
            extern_type *&to_next) const
{
    // verify that the range is valid
    _RWSTD_ASSERT (to <= to_end);
    _RWSTD_ASSERT (to && to_end || !to && !to_end);
 
    _RWSTD_UNUSED (to_end);
 
    // next pointer must always be set before returning, even on error
    to_next = to;
 
    const int mbstate_valid = _RW::__rw_mbsinit (&state);
 
    _RWSTD_ASSERT (0 != mbstate_valid);
    if (!mbstate_valid)
        return error;
 
    return noconv;
}
 
 
/* virtual */ int
codecvt<wchar_t, char, _RWSTD_MBSTATE_T>::
do_length (state_type        &state,
           const extern_type *from,
           const extern_type *from_end,
           size_t             imax) const
{
    // 22.2.1.5.2, p9 - preconditions
    _RWSTD_ASSERT (from <= from_end);
 
    // verify that the range is valid
    _RWSTD_ASSERT (from && from_end || !from && !from_end);
 
    const int mbstate_valid = _RW::__rw_mbsinit (&state);
 
    _RWSTD_ASSERT (0 != mbstate_valid);
    if (!mbstate_valid)
        return 0;
 
    // 22.2.1.5.2, p10
    const size_t len = from_end - from;
    return int (len < imax ? len : imax);
}
 
 
// codecvt_byname <wchar,char> specialization
codecvt_byname<wchar_t, char, _RWSTD_MBSTATE_T>:: 
codecvt_byname (const char *name, size_t ref)
    : codecvt<wchar_t, char, _RWSTD_MBSTATE_T>(ref)
{
    _C_flags = _RW::__rw_encoding_from_name (name);
 
#if 0
 
    // FIXME: reliably detect whether the encoding is really stateless
    //        when `name' refers to a libc locale name
 
    if (_RW::stateless == (_C_flags & 0xf)) {
        const _RW::__rw_setlocale clocale (_C_name, LC_CTYPE);
 
        _C_flags = mbtowc (0, 0, 0) ? _RW::stateful : _RW::stateless;
    }
 
#endif   // 0/1
 
    char locale_name [256];
 
    // look for the `@' name modifier in the locale name
    const char* mod = strchr (name, '@');
    if (mod) {
 
        const char* const   mod_nam = mod + 1;
        const size_t        mod_len = strlen (mod_nam);
 
        // search for one of the known modifiers
        if (mod_len > 2 && !memcmp (mod_nam, "UCS", 3)) {
 
            int flags = 0;
 
            for (size_t i = 0; i != _RW::__rw_n_ucsmods; ++i) {
                if (!strcmp (_RW::__rw_ucsmods [i].mod, mod_nam)) {
                    flags = _RW::__rw_ucsmods [i].flags;
                    break;
                }
            }
 
            if (flags)
                _C_flags |= flags;
            else
                mod = 0;
        }
        else
            mod = 0;   // not a "@UCS-" modifier
    }
 
    if (mod) {
        _RWSTD_ASSERT (long (mod - name) < long (sizeof locale_name));
 
        memcpy (locale_name, name, mod - name);
        locale_name [mod - name] = '\0';
        name = locale_name;
    }
 
    // handle the special names: UTF-8, UTF-16, UTF-16-BE, UTF-16-LE,
    // denoting an external UTF encoding with strict validation rules
    // but slower processing, and their relaxed but faster equivalents,
    // utf-8, utf-16, utf-16-be, utf-16-le
    const size_t name_len = strlen (name);
 
    if (4 < name_len) {
 
        // check whether the UTF- prefix is in lowercase or capital letters
        const bool pfx_low = !memcmp (name, "utf-", 4);
        const bool pfx_cap = !pfx_low && !memcmp (name, "UTF-", 4);
 
        int flags = 0;
 
        if (pfx_low || pfx_cap) {
 
            if (5 == name_len && '8' == name [4])
                flags = __rw_utf8;
            else if (!strcmp (name + 4, "16"))
                flags = __rw_utf16;
            else if (pfx_low) {
                if (!strcmp (name + 4, "16-BE"))
                    flags = __rw_utf16_be;
                else if (!strcmp (name + 4, "16-LE"))
                    flags = __rw_utf16_le;
            }
            else if (pfx_cap) {
                if (!strcmp (name + 4, "16-BE"))
                    flags = __rw_utf16_be;
                else if (!strcmp (name + 4, "16-LE"))
                    flags = __rw_utf16_le;
            }
        }
 
        if (flags) {
            _C_flags |= flags;
 
            if (pfx_cap)
                _C_flags |= __rw_strict ;
 
            *locale_name  = '\0';
            name          = locale_name;
        }
    }
 
    if (   this->_C_opts & this->_C_use_libc
        && !UCS_TYPE (_C_flags) && !UTF_TYPE (_C_flags))
        _C_flags |= __rw_use_libc;
 
    this->_C_set_name (name, _C_namebuf, sizeof _C_namebuf);
}
 
 
// outlined to avoid generating a vtable in each translation unit
// that uses the class
/* virtual */ codecvt_byname<wchar_t, char, _RWSTD_MBSTATE_T>::~
codecvt_byname ()
{
    // no-op
}
 
 
/* virtual */ codecvt_base::result
codecvt_byname<wchar_t, char, _RWSTD_MBSTATE_T>::
do_in (state_type&         state,
       const extern_type*  from, 
       const extern_type*  from_end,
       const extern_type*& from_next,
       intern_type*        to, 
       intern_type*        to_limit,
       intern_type*&       to_next) const 
{
    // 22.2.1.5.2 p1
    _RWSTD_ASSERT (from <= from_end);
    _RWSTD_ASSERT (to <= to_limit);
 
    // verify that both ranges are valid
    _RWSTD_ASSERT (from && from_end || !from && !from_end);
    _RWSTD_ASSERT (to && to_limit || !to && !to_limit);
 
    // the standard does not specify the value of
    // *next pointers at entry;
    from_next = from;
    to_next = to;
 
    // do_in result
    result res = error;
 
    // test the type of the encoding that the facet is interpreting
    switch (ISO2022_TYPE (_C_flags)) {
 
    case _RW::stateless: {
 
        // obtain the mapping of the database file
        const _RW::__rw_codecvt_t* const impl =
            _RWSTD_STATIC_CAST (const _RW::__rw_codecvt_t*, this->_C_data ());
    
        if (USE_LIBC (impl, _C_flags)) {
            // use libc locale
            const _RW::__rw_setlocale clocale (_C_name, LC_CTYPE);
 
#ifndef _RWSTD_NO_MBTOWC
 
            // verify that either the encoding is stateful
            // or the state is in its initial shift state
            const bool mbstate_valid =
               mbtowc (0, 0, 0) || _RW::__rw_mbsinit (&state);
 
            _RWSTD_ASSERT (mbstate_valid);
            _RWSTD_UNUSED (mbstate_valid);
 
#endif   // _RWSTD_NO_MBTOWC
 
            res = _RW::__rw_libc_do_in (state, 
                                        from, from_end, from_next,
                                        to, to_limit, to_next);
        }
        else {
 
            // verify that the state is in its initial shift state
            const int mbstate_valid = _RW::__rw_mbsinit (&state);
            _RWSTD_ASSERT (mbstate_valid);
 
            _RWSTD_UNUSED (mbstate_valid);
 
            res = _RW::__rw_libstd_do_in (from_end, from_next,
                                          to_limit, to_next,
                                          _C_flags, impl);
        }
        break;
    }
 
    case _RW::iso2022_jp:
        res =  _RW::__rw_iso2022jp_do_in (state, from_next, from_end, 
                                          to_next, to_limit);
        break;
 
    case _RW::iso2022_jp2:
        res =  _RW::__rw_iso2022jp2_do_in (state, from_next, from_end, 
                                           to_next, to_limit);
        break;
 
    case _RW::iso2022_kr:
    case _RW::iso2022_cn:
    default:
        break;
    };
 
    return res;
}
 
 
/* virtual */ codecvt_base::result
codecvt_byname<wchar_t, char, _RWSTD_MBSTATE_T>::
do_out (state_type         &state, 
        const intern_type  *from, 
        const intern_type  *from_end, 
        const intern_type *&from_next,
        extern_type        *to, 
        extern_type        *to_limit, 
        extern_type       *&to_next) const
{
    // 22.2.1.5.2 p1
    _RWSTD_ASSERT (from <= from_end);
    _RWSTD_ASSERT (to <= to_limit);
 
    // verify that both ranges are valid
    _RWSTD_ASSERT (from && from_end || !from && !from_end);
    _RWSTD_ASSERT (to && to_limit || !to && !to_limit);
 
    // the standard does not specify the value of the next pointers on entry
    from_next = from;
    to_next   = to;
 
    // conversion result
    codecvt_base::result res = codecvt_base::error;
 
    // test the type of the encoding that the facet is interpreting
    switch (ISO2022_TYPE (_C_flags)) {
 
    case _RW::stateless: {
 
        // obtain the mapping of the database file
        const _RW::__rw_codecvt_t* impl = 
            _RWSTD_STATIC_CAST(const _RW::__rw_codecvt_t*, this->_C_data ());
    
        if (USE_LIBC (impl, _C_flags)) {
            // use libc locale
            const _RW::__rw_setlocale clocale (_C_name, LC_CTYPE);
 
#ifndef _RWSTD_NO_MBTOWC
 
            // verify that either the encoding is stateful
            // or the state is in its initial shift state
            const bool mbstate_valid =
               mbtowc (0, 0, 0) || _RW::__rw_mbsinit (&state);
 
            _RWSTD_ASSERT (mbstate_valid);
            _RWSTD_UNUSED (mbstate_valid);
 
#endif   // _RWSTD_NO_MBTOWC
            
            res = _RW::__rw_libc_do_out (state, from, from_end, from_next,
                                         to, to_limit, to_next);
        }
        else {
            // verify that the state is in its initial shift state
            const int mbstate_valid = _RW::__rw_mbsinit (&state);
            _RWSTD_ASSERT (mbstate_valid);
 
            _RWSTD_UNUSED (mbstate_valid);
 
            // use own implementation
            res = _RW::__rw_libstd_do_out (from, from_end, from_next,
                                           to, to_limit, to_next,
                                           _C_flags, impl);
        }
        break;
    }
    case _RW::iso2022_jp:
        res = _RW::__rw_iso2022jp_do_out (state, from_next, from_end, 
                                          to_next, to_limit);
        break;
    case _RW::iso2022_jp2:
        res = _RW::__rw_iso2022jp2_do_out (state, from_next, from_end, 
                                           to_next, to_limit);
        break;
    case _RW::iso2022_kr:
    case _RW::iso2022_cn:
    default:
        break;
    };
 
    return res;
}
 
 
/* virtual */ codecvt_base::result
codecvt_byname<wchar_t, char, _RWSTD_MBSTATE_T>::
do_unshift (state_type&   state, 
            extern_type*  to, 
            extern_type*  to_limit, 
            extern_type*& to_next) const
{
    // verify that the range is valid
    _RWSTD_ASSERT (to <= to_limit);
    _RWSTD_ASSERT (to && to_limit || !to && !to_limit);
 
    // the standard does not specify the value of
    // to_next pointer at entry;
    to_next = to;
 
    // do_unshift result
    codecvt_base::result res = codecvt_base::error;
 
    // test the type of the encoding that the facet is interpreting
    switch (ISO2022_TYPE (_C_flags)) {
 
    case _RW::stateless:
 
        if (USE_LIBC (_C_impdata, _C_flags)) {
 
            const _RW::__rw_setlocale clocale (_C_name, LC_CTYPE);
            
            if (mbtowc (0, 0, 0) == 0) {
                // verify that the state is in its initial shift state
                const int mbstate_valid = _RW::__rw_mbsinit (&state);
                _RWSTD_ASSERT (mbstate_valid);
 
                res = mbstate_valid ? noconv : error;
            }
            else
                res = _RW::__rw_libc_do_unshift (state, to_next, to_limit);
        }
        else {
            // use our own implementation
 
            // verify that the state is in its initial shift state
            const int mbstate_valid = _RW::__rw_mbsinit (&state);
            _RWSTD_ASSERT (mbstate_valid);
 
            res = mbstate_valid ? noconv : error;
        }
        break;
 
    case _RW::iso2022_jp:
        res = _RW::__rw_iso2022jp_do_unshift (state, to_next, to_limit);
        break;
    case _RW::iso2022_jp2:
        res = _RW::__rw_iso2022jp2_do_unshift (state, to_next, to_limit);
        break;
    case _RW::iso2022_kr:
    case _RW::iso2022_cn:
    default:
        break;
    };
 
    return res;
}
 
 
/* virtual */ int
codecvt_byname<wchar_t, char, _RWSTD_MBSTATE_T>::
do_length (state_type&        state, 
           const extern_type *from, 
           const extern_type *from_end, 
           size_t             cmax) const 
{
    // 22.2.1.5.2 p1
    _RWSTD_ASSERT (from <= from_end);
 
    // verify that the range is valid
    _RWSTD_ASSERT (from && from_end || !from && !from_end);
 
    size_t len = 0;
 
    // test the type of the encoding that the facet is interpreting
    switch (ISO2022_TYPE (_C_flags)) {
 
    case _RW::stateless: {
 
        // obtain the mapping of the database file
        const _RW::__rw_codecvt_t* impl = 
            _RWSTD_STATIC_CAST(const _RW::__rw_codecvt_t*, this->_C_data ());
 
        if (USE_LIBC (impl, _C_flags)) {
            // use libc locale
            const _RW::__rw_setlocale clocale (this->_C_name, LC_CTYPE);
 
#ifndef _RWSTD_NO_MBTOWC
 
            // verify that either the encoding is stateful
            // or the state is in its initial shift state
            const bool mbstate_valid =
                mbtowc (0, 0, 0) || _RW::__rw_mbsinit (&state);
 
            _RWSTD_ASSERT (mbstate_valid);
            _RWSTD_UNUSED (mbstate_valid);
 
#endif   // _RWSTD_NO_MBTOWC
 
            len = _RW::__rw_libc_do_length (state, from, from_end, cmax);
        }
        else {
            // verify that the state is in its initial shift state
            const int mbstate_valid = _RW::__rw_mbsinit (&state);
            _RWSTD_ASSERT (mbstate_valid);
 
            _RWSTD_UNUSED (mbstate_valid);
 
            len = _RW::__rw_libstd_do_length (from, from_end,
                                              cmax, _C_flags, impl);
        }
        break;
    }
    case _RW::iso2022_jp:
        len = _RW::__rw_iso2022jp_do_length (state, from, from_end, cmax);
        break;
    case _RW::iso2022_jp2:
        len = _RW::__rw_iso2022jp2_do_length (state, from, from_end, cmax);
        break;
    case _RW::iso2022_kr:
    case _RW::iso2022_cn:
    default:
        break;
    };
 
    return int (len);
}
 
 
/* virtual */ int
codecvt_byname<wchar_t, char, _RWSTD_MBSTATE_T>::
do_encoding () const _THROWS (())
{
 
    // -7- Returns: -1 if the encoding of the extern_type sequence is
    //     state-dependent; else the constant number of extern_type
    //     characters needed to produce an internal character;
    //     or 0 if this number is not a constant 227).
    // _____________
    // Footnote 227: If encoding() yields -1, then more than max_length()
    // extern_type elements may be consumed when producing a single internT
    // character, and additional extern_type elements may appear at the end
    // of a sequence after those that yield the final intern_type character.
 
    int enc = 0;   // variable-width stateless encoding
 
    // test the type of the encoding that the facet is interpreting
    switch (ISO2022_TYPE (_C_flags)) {
 
    case _RW::stateless: {
        // obtain the database file mapping
        const _RW::__rw_codecvt_t* impl = 
            _RWSTD_STATIC_CAST(const _RW::__rw_codecvt_t*, this->_C_data ());
 
        if (USE_LIBC (impl, _C_flags)) {
            // 7.20.7.2 of C99: if first arg is 0, mbtowc() returns non-zero 
            // or 0 whether or not the encoding is stateful or stateless
            const _RW::__rw_setlocale clocale (_C_name, LC_CTYPE);
 
            if (mbtowc (0, 0, 0)) {
                // in a stateful encoding, the number of extern_type
                // elements required to produce a single intern_type
                // character is indeterminate
                enc = -1;
            }
            else {
                // in a stateless encoding, the number of extern_type
                // elements required to produce a single intern_type
                // character is guaranteed to be 1 only when MB_CUR_MAX
                // is also 1, otherwise it's most likely to be variable
                // (e.g., EUC, UTF-8, etc.)
                if (1 == MB_CUR_MAX)
                    enc = 1;
            }
        }
        else {
            // use own implementation
            // 22.2.1.5.2 p6
            if (impl)
                enc = 1 < impl->mb_cur_max ? 0 : 1;
            else
                enc = 0;
        }
 
        break;
    }
    case _RW::iso2022_jp:
        enc = _RW::__rw_iso2022jp_do_encoding ();
        break;
    case _RW::iso2022_jp2:
        enc = _RW::__rw_iso2022jp2_do_encoding ();
        break;
    case _RW::iso2022_kr:
    case _RW::iso2022_cn:
    default:
        break;
    };
 
    return enc;
}
 
 
/* virtual */ int
codecvt_byname<wchar_t, char, _RWSTD_MBSTATE_T>::
do_max_length () const _THROWS (())
{
    // returns the max value do_length (s, from, from_end, 1) can return
    // for any valid range [from, from_end) - see LWG issue 74 (a DR)
    size_t max_len = 0;
 
    // test the type of the encoding that the facet is interpreting
    switch (ISO2022_TYPE (_C_flags)) {
 
    case _RW::stateless: {
        // obtain the database file mapping
        const _RW::__rw_codecvt_t* impl = 
            _RWSTD_STATIC_CAST(const _RW::__rw_codecvt_t*, this->_C_data ());
            
        if (USE_LIBC (impl, _C_flags)) {
            // use libc locale
            const _RW::__rw_setlocale clocale (_C_name, LC_CTYPE);
 
            max_len = size_t (MB_CUR_MAX);
        }
        else {
            // use own implementation
            if (IS_UTF8 (_C_flags))
                max_len = _UTF8_MB_CUR_MAX;
            else if (impl)
                max_len = size_t (impl->mb_cur_max);
        }
        break;
    }
    case _RW::iso2022_jp:
        max_len = _RW::__rw_iso2022jp_do_max_length ();
        break;
    case _RW::iso2022_jp2:
        max_len = _RW::__rw_iso2022jp2_do_max_length ();
        break;
    case _RW::iso2022_kr:
    case _RW::iso2022_cn:
    default:
        break;
    };
 
    return int (max_len);
}
 
#endif   // _RWSTD_NO_WCHAR_T
 
}   // namespace std
 
 
#ifndef _RWSTD_NO_WCHAR_T
 
#  define TARGS_W   <wchar_t, char, _RWSTD_MBSTATE_T>
 
_RWSTD_DEFINE_FACET_FACTORY (static, codecvt, TARGS_W, wcodecvt);
_RWSTD_SPECIALIZE_USE_FACET (wcodecvt);
 
#endif   // _RWSTD_NO_WCHAR_T